/*
* Setup a "daemon" JCR for the various standalone
* tools (e.g. bls, bextract, bscan, ...)
*/
JCR *setup_jcr(const char *name, char *dev_name,
BSR *bsr, DIRRES *director,
const char *VolumeName, int mode)
{
DCR *dcr;
JCR *jcr = new_jcr(sizeof(JCR), my_free_jcr);
jcr->bsr = bsr;
jcr->director = director;
jcr->VolSessionId = 1;
jcr->VolSessionTime = (uint32_t)time(NULL);
jcr->NumReadVolumes = 0;
jcr->NumWriteVolumes = 0;
jcr->JobId = 0;
jcr->setJobType(JT_CONSOLE);
jcr->setJobLevel(L_FULL);
jcr->JobStatus = JS_Terminated;
jcr->where = bstrdup("");
jcr->job_name = get_pool_memory(PM_FNAME);
pm_strcpy(jcr->job_name, "Dummy.Job.Name");
jcr->client_name = get_pool_memory(PM_FNAME);
pm_strcpy(jcr->client_name, "Dummy.Client.Name");
bstrncpy(jcr->Job, name, sizeof(jcr->Job));
jcr->fileset_name = get_pool_memory(PM_FNAME);
pm_strcpy(jcr->fileset_name, "Dummy.fileset.name");
jcr->fileset_md5 = get_pool_memory(PM_FNAME);
pm_strcpy(jcr->fileset_md5, "Dummy.fileset.md5");
new_plugins(jcr); /* instantiate plugins */
init_autochangers();
create_volume_lists();
dcr = setup_to_access_device(jcr, dev_name, VolumeName, mode);
if (!dcr) {
return NULL;
}
if (!bsr && VolumeName) {
bstrncpy(dcr->VolumeName, VolumeName, sizeof(dcr->VolumeName));
}
bstrncpy(dcr->pool_name, "Default", sizeof(dcr->pool_name));
bstrncpy(dcr->pool_type, "Backup", sizeof(dcr->pool_type));
return jcr;
}
/*********************************************************************
*
* Main Bareos Scheduler
*
*/
JCR *wait_for_next_job(char *one_shot_job_to_run)
{
JCR *jcr;
JOBRES *job;
RUNRES *run;
time_t now, prev;
static bool first = true;
job_item *next_job = NULL;
Dmsg0(dbglvl, "Enter wait_for_next_job\n");
if (first) {
first = false;
/* Create scheduled jobs list */
jobs_to_run = New(dlist(next_job, &next_job->link));
if (one_shot_job_to_run) { /* one shot */
job = (JOBRES *)GetResWithName(R_JOB, one_shot_job_to_run);
if (!job) {
Emsg1(M_ABORT, 0, _("Job %s not found\n"), one_shot_job_to_run);
}
Dmsg1(5, "Found one_shot_job_to_run %s\n", one_shot_job_to_run);
jcr = new_jcr(sizeof(JCR), dird_free_jcr);
set_jcr_defaults(jcr, job);
return jcr;
}
}
/* Wait until we have something in the
* next hour or so.
*/
again:
while (jobs_to_run->empty()) {
find_runs();
if (!jobs_to_run->empty()) {
break;
}
bmicrosleep(next_check_secs, 0); /* recheck once per minute */
}
#ifdef list_chain
job_item *je;
foreach_dlist(je, jobs_to_run) {
dump_job(je, _("Walk queue"));
}
/*
* Create a Job Control Record for a control "job",
* filling in all the appropriate fields.
*/
JCR *new_control_jcr(const char *base_name, int job_type)
{
JCR *jcr;
jcr = new_jcr(sizeof(JCR), dird_free_jcr);
/*
* The job and defaults are not really used, but
* we set them up to ensure that everything is correctly
* initialized.
*/
LockRes();
jcr->job = (JOB *)GetNextRes(R_JOB, NULL);
set_jcr_defaults(jcr, jcr->job);
UnlockRes();
jcr->sd_auth_key = bstrdup("dummy"); /* dummy Storage daemon key */
create_unique_job_name(jcr, base_name);
jcr->sched_time = jcr->start_time;
jcr->setJobType(job_type);
jcr->setJobLevel(L_NONE);
jcr->setJobStatus(JS_Running);
jcr->JobId = 0;
return jcr;
}
void *device_initialization(void *arg)
{
DEVRES *device;
DCR *dcr;
JCR *jcr;
DEVICE *dev;
int errstat;
LockRes();
pthread_detach(pthread_self());
jcr = new_jcr(sizeof(JCR), stored_free_jcr);
new_plugins(jcr); /* instantiate plugins */
jcr->setJobType(JT_SYSTEM);
/*
* Initialize job start condition variable
*/
errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
if (errstat != 0) {
berrno be;
Jmsg1(jcr, M_ABORT, 0, _("Unable to init job start cond variable: ERR=%s\n"), be.bstrerror(errstat));
}
/*
* Initialize job end condition variable
*/
errstat = pthread_cond_init(&jcr->job_end_wait, NULL);
if (errstat != 0) {
berrno be;
Jmsg1(jcr, M_ABORT, 0, _("Unable to init job endstart cond variable: ERR=%s\n"), be.bstrerror(errstat));
}
foreach_res(device, R_DEVICE) {
Dmsg1(90, "calling init_dev %s\n", device->device_name);
dev = init_dev(NULL, device);
Dmsg1(10, "SD init done %s\n", device->device_name);
if (!dev) {
Jmsg1(NULL, M_ERROR, 0, _("Could not initialize %s\n"), device->device_name);
continue;
}
jcr->dcr = dcr = new_dcr(jcr, NULL, dev, NULL);
generate_plugin_event(jcr, bsdEventDeviceInit, dcr);
if (dev->is_autochanger()) {
/* If autochanger set slot in dev structure */
get_autochanger_loaded_slot(dcr);
}
if (device->cap_bits & CAP_ALWAYSOPEN) {
Dmsg1(20, "calling first_open_device %s\n", dev->print_name());
if (!first_open_device(dcr)) {
Jmsg1(NULL, M_ERROR, 0, _("Could not open device %s\n"), dev->print_name());
Dmsg1(20, "Could not open device %s\n", dev->print_name());
free_dcr(dcr);
jcr->dcr = NULL;
continue;
}
}
if (device->cap_bits & CAP_AUTOMOUNT && dev->is_open()) {
switch (read_dev_volume_label(dcr)) {
case VOL_OK:
memcpy(&dev->VolCatInfo, &dcr->VolCatInfo, sizeof(dev->VolCatInfo));
volume_unused(dcr); /* mark volume "released" */
break;
default:
Jmsg1(NULL, M_WARNING, 0, _("Could not mount device %s\n"), dev->print_name());
break;
}
}
free_dcr(dcr);
jcr->dcr = NULL;
}
int main (int argc, char *argv[])
{
int ch;
#if defined(HAVE_DYNAMIC_CATS_BACKENDS)
alist *backend_directories = NULL;
#endif
char *jobids = (char *)"1";
char *path=NULL, *client=NULL;
uint64_t limit=0;
bool clean=false;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
Dmsg0(0, "Starting bvfs_test tool\n");
my_name_is(argc, argv, "bvfs_test");
init_msg(NULL, NULL);
OSDependentInit();
while ((ch = getopt(argc, argv, "h:c:l:d:D:n:P:Su:vf:w:?j:p:f:T")) != -1) {
switch (ch) {
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'D':
db_driver = optarg;
break;
case 'l':
limit = str_to_int64(optarg);
break;
case 'c':
client = optarg;
break;
case 'h':
db_host = optarg;
break;
case 'n':
db_name = optarg;
break;
case 'w':
working_directory = optarg;
break;
case 'u':
db_user = optarg;
break;
case 'P':
db_password = optarg;
break;
case 'v':
verbose++;
break;
case 'p':
path = optarg;
break;
case 'f':
file = optarg;
break;
case 'j':
jobids = optarg;
break;
case 'T':
clean = true;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
JCR *bjcr = new_jcr(sizeof(JCR), NULL);
bjcr->JobId = getpid();
bjcr->setJobType(JT_CONSOLE);
bjcr->setJobLevel(L_FULL);
bjcr->JobStatus = JS_Running;
bjcr->client_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->client_name, "Dummy.Client.Name");
bstrncpy(bjcr->Job, "bvfs_test", sizeof(bjcr->Job));
#if defined(HAVE_DYNAMIC_CATS_BACKENDS)
backend_directories = New(alist(10, owned_by_alist));
backend_directories->append((char *)backend_directory);
db_set_backend_dirs(backend_directories);
#endif
if ((db = db_init_database(NULL, NULL, db_name, db_user, db_password, db_host, 0, NULL)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
Dmsg1(0, "db_type=%s\n", db_get_type(db));
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
Dmsg0(200, "Database opened\n");
if (verbose) {
Pmsg2(000, _("Using Database: %s, User: %s\n"), db_name, db_user);
}
bjcr->db = db;
if (clean) {
Pmsg0(0, "Clean old table\n");
db_sql_query(db, "DELETE FROM PathHierarchy", NULL, NULL);
db_sql_query(db, "UPDATE Job SET HasCache=0", NULL, NULL);
db_sql_query(db, "DELETE FROM PathVisibility", NULL, NULL);
bvfs_update_cache(bjcr, db);
}
Bvfs fs(bjcr, db);
fs.set_handler(result_handler, &fs);
fs.set_jobids(jobids);
fs.update_cache();
if (limit)
fs.set_limit(limit);
if (path) {
fs.ch_dir(path);
fs.ls_special_dirs();
fs.ls_dirs();
while (fs.ls_files()) {
fs.next_offset();
}
if (fnid && client) {
Pmsg0(0, "---------------------------------------------\n");
Pmsg1(0, "Getting file version for %s\n", file);
fs.get_all_file_versions(fs.get_pwd(), fnid, client);
}
exit (0);
}
Pmsg0(0, "list /\n");
fs.ch_dir("/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
Pmsg0(0, "list /tmp/\n");
fs.ch_dir("/tmp/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
Pmsg0(0, "list /tmp/regress/\n");
fs.ch_dir("/tmp/regress/");
fs.ls_special_dirs();
fs.ls_files();
fs.ls_dirs();
Pmsg0(0, "list /tmp/regress/build/\n");
fs.ch_dir("/tmp/regress/build/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
fs.get_all_file_versions(1, 347, "zog4-fd");
char p[200];
strcpy(p, "/tmp/toto/rep/");
bvfs_parent_dir(p);
if(!bstrcmp(p, "/tmp/toto/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "/tmp/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
return 0;
}
}
argc -= optind;
argv += optind;
config = new_config_parser();
parse_dir_config(config, configfile, M_ERROR_TERM);
MSGS *msg;
foreach_res(msg, R_MSGS)
{
init_msg(NULL, msg);
}
jcr = new_jcr(sizeof(JCR), NULL);
jcr->fileset = (FILESET *)GetResWithName(R_FILESET, fileset_name);
if (jcr->fileset == NULL) {
fprintf(stderr, "%s: Fileset not found\n", fileset_name);
FILESET *var;
fprintf(stderr, "Valid FileSets:\n");
foreach_res(var, R_FILESET) {
fprintf(stderr, " %s\n", var->hdr.name);
}
exit(1);
}
int main(int argc, char *const *argv)
{
FF_PKT *ff;
char name[1000];
bool quiet = false;
int i, ch;
char *inc = NULL;
char *exc = NULL;
FILE *fd;
setlocale(LC_ALL, "");
bindtextdomain("bacula", LOCALEDIR);
textdomain("bacula");
lmgr_init_thread();
while ((ch = getopt(argc, argv, "ad:e:i:q?")) != -1) {
switch (ch) {
case 'a': /* print extended attributes *debug* */
attrs = 1;
break;
case 'd': /* set debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'e': /* exclude patterns */
exc = optarg;
break;
case 'i': /* include patterns */
inc = optarg;
break;
case 'q':
quiet = true;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
jcr = new_jcr(sizeof(JCR), NULL);
ff = init_find_files();
if (argc == 0 && !inc) {
add_fname_to_include_list(ff, 0, "/"); /* default to / */
} else {
for (i=0; i < argc; i++) {
if (strcmp(argv[i], "-") == 0) {
while (fgets(name, sizeof(name)-1, stdin)) {
strip_trailing_junk(name);
add_fname_to_include_list(ff, 0, name);
}
continue;
}
add_fname_to_include_list(ff, 0, argv[i]);
}
}
if (inc) {
fd = fopen(inc, "rb");
if (!fd) {
printf(_("Could not open include file: %s\n"), inc);
exit(1);
}
while (fgets(name, sizeof(name)-1, fd)) {
strip_trailing_junk(name);
add_fname_to_include_list(ff, 0, name);
}
fclose(fd);
}
if (exc) {
fd = fopen(exc, "rb");
if (!fd) {
printf(_("Could not open exclude file: %s\n"), exc);
exit(1);
}
while (fgets(name, sizeof(name)-1, fd)) {
strip_trailing_junk(name);
add_fname_to_exclude_list(ff, name);
}
fclose(fd);
}
if (quiet) {
match_files(jcr, ff, count_files);
} else {
match_files(jcr, ff, print_file);
}
printf(_("Files seen = %d\n"), num_files);
term_include_exclude_files(ff);
term_find_files(ff);
free_jcr(jcr);
term_last_jobs_list(); /* free jcr chain */
close_memory_pool();
lmgr_cleanup_main();
sm_dump(false);
exit(0);
}
static bool list_nextvol(UAContext *ua, int ndays)
{
JOBRES *job;
JCR *jcr;
USTORERES store;
RUNRES *run;
utime_t runtime;
bool found = false;
MEDIA_DBR mr;
POOL_DBR pr;
int i = find_arg_with_value(ua, "job");
if (i <= 0) {
if ((job = select_job_resource(ua)) == NULL) {
return false;
}
} else {
job = (JOBRES *)GetResWithName(R_JOB, ua->argv[i]);
if (!job) {
Jmsg(ua->jcr, M_ERROR, 0, _("%s is not a job name.\n"), ua->argv[i]);
if ((job = select_job_resource(ua)) == NULL) {
return false;
}
}
}
jcr = new_jcr(sizeof(JCR), dird_free_jcr);
for (run=NULL; (run = find_next_run(run, job, runtime, ndays)); ) {
if (!complete_jcr_for_job(jcr, job, run->pool)) {
found = false;
goto get_out;
}
if (!jcr->jr.PoolId) {
ua->error_msg(_("Could not find Pool for Job %s\n"), job->name());
continue;
}
memset(&pr, 0, sizeof(pr));
pr.PoolId = jcr->jr.PoolId;
if (!db_get_pool_record(jcr, jcr->db, &pr)) {
bstrncpy(pr.Name, "*UnknownPool*", sizeof(pr.Name));
}
mr.PoolId = jcr->jr.PoolId;
get_job_storage(&store, job, run);
set_storageid_in_mr(store.store, &mr);
/* no need to set ScratchPoolId, since we use fnv_no_create_vol */
if (!find_next_volume_for_append(jcr, &mr, 1, fnv_no_create_vol, fnv_prune)) {
ua->error_msg(_("Could not find next Volume for Job %s (Pool=%s, Level=%s).\n"),
job->name(), pr.Name, level_to_str(run->level));
} else {
ua->send_msg(
_("The next Volume to be used by Job \"%s\" (Pool=%s, Level=%s) will be %s\n"),
job->name(), pr.Name, level_to_str(run->level), mr.VolumeName);
found = true;
}
}
get_out:
if (jcr->db) {
db_sql_close_pooled_connection(jcr, jcr->db);
jcr->db = NULL;
}
free_jcr(jcr);
if (!found) {
ua->error_msg(_("Could not find next Volume for Job %s.\n"),
job->hdr.name);
return false;
}
return true;
}
int main (int argc, char *argv[])
{
int ch;
bool disable_batch = false;
char *restore_list=NULL;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
lmgr_init_thread();
char **files = (char **) malloc (10 * sizeof(char *));
int i;
my_name_is(argc, argv, "bbatch");
init_msg(NULL, NULL);
OSDependentInit();
while ((ch = getopt(argc, argv, "bBh:c:d:D:n:P:Su:vf:w:r:?")) != -1) {
switch (ch) {
case 'r':
restore_list=bstrdup(optarg);
break;
case 'B':
disable_batch = true;
break;
case 'b':
disable_batch = false;
break;
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'D':
db_driver = optarg;
break;
case 'h':
db_host = optarg;
break;
case 'n':
db_name = optarg;
break;
case 'w':
working_directory = optarg;
break;
case 'u':
db_user = optarg;
break;
case 'P':
db_password = optarg;
break;
case 'v':
verbose++;
break;
case 'f':
if (nb < 10 ) {
files[nb++] = optarg;
}
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
if (restore_list) {
uint64_t nb_file=0;
btime_t start, end;
/* To use the -r option, the catalog should already contains records */
if ((db = db_init_database(NULL, db_driver, db_name, db_user, db_password,
db_host, 0, NULL, false, disable_batch)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
start = get_current_btime();
db_get_file_list(NULL, db, restore_list, false, false, list_handler, &nb_file);
end = get_current_btime();
Pmsg3(0, _("Computing file list for jobid=%s files=%lld secs=%d\n"),
restore_list, nb_file, (uint32_t)btime_to_unix(end-start));
free(restore_list);
return 0;
}
if (disable_batch) {
printf("Without new Batch mode\n");
} else {
printf("With new Batch mode\n");
}
i = nb;
while (--i >= 0) {
pthread_t thid;
JCR *bjcr = new_jcr(sizeof(JCR), NULL);
bjcr->bsr = NULL;
bjcr->VolSessionId = 1;
bjcr->VolSessionTime = (uint32_t)time(NULL);
bjcr->NumReadVolumes = 0;
bjcr->NumWriteVolumes = 0;
bjcr->JobId = getpid();
bjcr->setJobType(JT_CONSOLE);
bjcr->setJobLevel(L_FULL);
bjcr->JobStatus = JS_Running;
bjcr->where = bstrdup(files[i]);
bjcr->job_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->job_name, "Dummy.Job.Name");
bjcr->client_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->client_name, "Dummy.Client.Name");
bstrncpy(bjcr->Job, "bbatch", sizeof(bjcr->Job));
bjcr->fileset_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->fileset_name, "Dummy.fileset.name");
bjcr->fileset_md5 = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->fileset_md5, "Dummy.fileset.md5");
if ((db = db_init_database(NULL, db_driver, db_name, db_user, db_password,
db_host, 0, NULL, false, false)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
Dmsg0(200, "Database opened\n");
if (verbose) {
Pmsg2(000, _("Using Database: %s, User: %s\n"), db_name, db_user);
}
bjcr->db = db;
pthread_create(&thid, NULL, do_batch, bjcr);
}
while (nb > 0) {
bmicrosleep(1,0);
}
return 0;
}
