X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fdird%2Fjob.c;h=3a0bd8f7f2afca99d7632f5e824a1ac6f0fcae6f;hb=5e70231c4ca1e035795a7e005faac68b7bb67391;hp=aca03f5d7779e83070553feb38474f4e9eeb7dc1;hpb=d63d9c8839f6520ce4abb18cca73cb6ea5fd17a5;p=bacula%2Fbacula diff --git a/bacula/src/dird/job.c b/bacula/src/dird/job.c index aca03f5d77..3a0bd8f7f2 100644 --- a/bacula/src/dird/job.c +++ b/bacula/src/dird/job.c @@ -1,3 +1,30 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2000-2008 Free Software Foundation Europe e.V. + + The main author of Bacula is Kern Sibbald, with contributions from + many others, a complete list can be found in the file AUTHORS. + This program is Free Software; you can redistribute it and/or + modify it under the terms of version two of the GNU General Public + License as published by the Free Software Foundation and included + in the file LICENSE. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. + + Bacula® is a registered trademark of John Walker. + The licensor of Bacula is the Free Software Foundation Europe + (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, + Switzerland, email:ftf@fsfeurope.org. +*/ /* * * Bacula Director Job processing routines @@ -6,20 +33,6 @@ * * Version $Id$ */ -/* - Copyright (C) 2000-2005 Kern Sibbald - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - version 2 as ammended with additional clauses defined in the - file LICENSE in the main source directory. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - the file LICENSE for additional details. - - */ #include "bacula.h" #include "dird.h" @@ -36,7 +49,6 @@ extern void term_scheduler(); extern void term_ua_server(); /* Imported variables */ -extern time_t watchdog_time; jobq_t job_queue; @@ -47,7 +59,7 @@ void init_job_server(int max_workers) if ((stat = jobq_init(&job_queue, max_workers, job_thread)) != 0) { berrno be; - Emsg1(M_ABORT, 0, _("Could not init job queue: ERR=%s\n"), be.strerror(stat)); + Emsg1(M_ABORT, 0, _("Could not init job queue: ERR=%s\n"), be.bstrerror(stat)); } wd = new_watchdog(); wd->callback = job_monitor_watchdog; @@ -73,125 +85,97 @@ void term_job_server() */ JobId_t run_job(JCR *jcr) { - int stat, errstat; - JobId_t JobId = 0; + int stat; + if (setup_job(jcr)) { + Dmsg0(200, "Add jrc to work queue\n"); + /* Queue the job to be run */ + if ((stat = jobq_add(&job_queue, jcr)) != 0) { + berrno be; + Jmsg(jcr, M_FATAL, 0, _("Could not add job queue: ERR=%s\n"), be.bstrerror(stat)); + return 0; + } + return jcr->JobId; + } + return 0; +} - P(jcr->mutex); +bool setup_job(JCR *jcr) +{ + int errstat; + + jcr->lock(); sm_check(__FILE__, __LINE__, true); init_msg(jcr, jcr->messages); /* Initialize termination condition variable */ if ((errstat = pthread_cond_init(&jcr->term_wait, NULL)) != 0) { berrno be; - Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.strerror(errstat)); + Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat)); goto bail_out; } jcr->term_wait_inited = true; + create_unique_job_name(jcr, jcr->job->name()); + set_jcr_job_status(jcr, JS_Created); + jcr->unlock(); /* * Open database */ - Dmsg0(50, "Open database\n"); - jcr->db=db_init_database(jcr, jcr->catalog->db_name, jcr->catalog->db_user, - jcr->catalog->db_password, jcr->catalog->db_address, - jcr->catalog->db_port, jcr->catalog->db_socket, - jcr->catalog->mult_db_connections); + Dmsg0(100, "Open database\n"); + jcr->db=db_init(jcr, jcr->catalog->db_driver, jcr->catalog->db_name, + jcr->catalog->db_user, + jcr->catalog->db_password, jcr->catalog->db_address, + jcr->catalog->db_port, jcr->catalog->db_socket, + jcr->catalog->mult_db_connections); if (!jcr->db || !db_open_database(jcr, jcr->db)) { Jmsg(jcr, M_FATAL, 0, _("Could not open database \"%s\".\n"), jcr->catalog->db_name); if (jcr->db) { Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); + db_close_database(jcr, jcr->db); } goto bail_out; } - Dmsg0(50, "DB opened\n"); + Dmsg0(150, "DB opened\n"); + + if (!jcr->fname) { + jcr->fname = get_pool_memory(PM_FNAME); + } + if (!jcr->pool_source) { + jcr->pool_source = get_pool_memory(PM_MESSAGE); + pm_strcpy(jcr->pool_source, _("unknown source")); + } + Dmsg2(500, "pool=%s (From %s)\n", jcr->pool->name(), jcr->pool_source); + if (jcr->JobType == JT_MIGRATE || jcr->JobType == JT_COPY) { + if (!jcr->rpool_source) { + jcr->rpool_source = get_pool_memory(PM_MESSAGE); + pm_strcpy(jcr->rpool_source, _("unknown source")); + } + } /* * Create Job record */ - create_unique_job_name(jcr, jcr->job->hdr.name); - set_jcr_job_status(jcr, JS_Created); init_jcr_job_record(jcr); + if (!get_or_create_client_record(jcr)) { + goto bail_out; + } + if (!db_create_job_record(jcr, jcr->db, &jcr->jr)) { Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); goto bail_out; } - JobId = jcr->JobId = jcr->jr.JobId; + jcr->JobId = jcr->jr.JobId; Dmsg4(100, "Created job record JobId=%d Name=%s Type=%c Level=%c\n", jcr->JobId, jcr->Job, jcr->jr.JobType, jcr->jr.JobLevel); generate_daemon_event(jcr, "JobStart"); - if (!get_or_create_client_record(jcr)) { - goto bail_out; - } - if (job_canceled(jcr)) { goto bail_out; } - Dmsg0(200, "Add jrc to work queue\n"); - - /* Queue the job to be run */ - if ((stat = jobq_add(&job_queue, jcr)) != 0) { - berrno be; - Jmsg(jcr, M_FATAL, 0, _("Could not add job queue: ERR=%s\n"), be.strerror(stat)); - JobId = 0; - goto bail_out; - } - Dmsg0(100, "Done run_job()\n"); - - V(jcr->mutex); - return JobId; - -bail_out: - if (jcr->fname) { - free_memory(jcr->fname); - jcr->fname = NULL; - } - V(jcr->mutex); - return JobId; -} - - -/* - * This is the engine called by jobq.c:jobq_add() when we were pulled - * from the work queue. - * At this point, we are running in our own thread and all - * necessary resources are allocated -- see jobq.c - */ -static void *job_thread(void *arg) -{ - JCR *jcr = (JCR *)arg; - - jcr->my_thread_id = pthread_self(); - pthread_detach(jcr->my_thread_id); - sm_check(__FILE__, __LINE__, true); - - Dmsg0(200, "=====Start Job=========\n"); - jcr->start_time = time(NULL); /* set the real start time */ - jcr->jr.StartTime = jcr->start_time; - - if (jcr->job->MaxStartDelay != 0 && jcr->job->MaxStartDelay < - (utime_t)(jcr->start_time - jcr->sched_time)) { - Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n")); - set_jcr_job_status(jcr, JS_Canceled); - } - - /* - * Note, we continue, even if the job is canceled above. This - * will permit proper setting of the job start record and - * the error (cancel) will be picked up below. - */ - - generate_job_event(jcr, "JobInit"); - set_jcr_job_status(jcr, JS_Running); /* this will be set only if no error */ - - if (!jcr->fname) { - jcr->fname = get_pool_memory(PM_FNAME); - } - /* * Now, do pre-run stuff, like setting job level (Inc/diff, ...) * this allows us to setup a proper job start record for restarting @@ -218,51 +202,89 @@ static void *job_thread(void *arg) admin_cleanup(jcr, JS_ErrorTerminated); } break; - case JT_MIGRATION: case JT_COPY: - case JT_ARCHIVE: - if (!do_mac_init(jcr)) { /* migration, archive, copy */ - mac_cleanup(jcr, JS_ErrorTerminated); + case JT_MIGRATE: + if (!do_migration_init(jcr)) { + migration_cleanup(jcr, JS_ErrorTerminated); } break; default: - Pmsg1(0, "Unimplemented job type: %d\n", jcr->JobType); + Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->JobType); set_jcr_job_status(jcr, JS_ErrorTerminated); break; } + generate_job_event(jcr, "JobInit"); + Dsm_check(1); + return true; + +bail_out: + return false; +} + +void update_job_end(JCR *jcr, int TermCode) +{ + dequeue_messages(jcr); /* display any queued messages */ + set_jcr_job_status(jcr, TermCode); + update_job_end_record(jcr); +} + +/* + * This is the engine called by jobq.c:jobq_add() when we were pulled + * from the work queue. + * At this point, we are running in our own thread and all + * necessary resources are allocated -- see jobq.c + */ +static void *job_thread(void *arg) +{ + JCR *jcr = (JCR *)arg; + + pthread_detach(pthread_self()); + Dsm_check(1); + + Dmsg0(200, "=====Start Job=========\n"); + set_jcr_job_status(jcr, JS_Running); /* this will be set only if no error */ + jcr->start_time = time(NULL); /* set the real start time */ + jcr->jr.StartTime = jcr->start_time; + + if (jcr->job->MaxStartDelay != 0 && jcr->job->MaxStartDelay < + (utime_t)(jcr->start_time - jcr->sched_time)) { + set_jcr_job_status(jcr, JS_Canceled); + Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n")); + } + + /* TODO : check if it is used somewhere */ + if (jcr->job->RunScripts == NULL) { + Dmsg0(200, "Warning, job->RunScripts is empty\n"); + jcr->job->RunScripts = New(alist(10, not_owned_by_alist)); + } + if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) { Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); } + /* Run any script BeforeJob on dird */ + run_scripts(jcr, jcr->job->RunScripts, "BeforeJob"); + if (job_canceled(jcr)) { - update_job_end_record(jcr); + update_job_end(jcr, jcr->JobStatus); } else { - - /* Run Job */ - if (jcr->job->RunBeforeJob) { - POOLMEM *before = get_pool_memory(PM_FNAME); - int status; - BPIPE *bpipe; - char line[MAXSTRING]; - - before = edit_job_codes(jcr, before, jcr->job->RunBeforeJob, ""); - bpipe = open_bpipe(before, 0, "r"); - free_pool_memory(before); - while (fgets(line, sizeof(line), bpipe->rfd)) { - Jmsg(jcr, M_INFO, 0, _("RunBefore: %s"), line); - } - status = close_bpipe(bpipe); - if (status != 0) { - berrno be; - Jmsg(jcr, M_FATAL, 0, _("RunBeforeJob error: ERR=%s\n"), be.strerror(status)); - set_jcr_job_status(jcr, JS_FatalError); - update_job_end_record(jcr); - goto bail_out; - } + /* + * We re-update the job start record so that the start + * time is set after the run before job. This avoids + * that any files created by the run before job will + * be saved twice. They will be backed up in the current + * job, but not in the next one unless they are changed. + * Without this, they will be backed up in this job and + * in the next job run because in that case, their date + * is after the start of this run. + */ + jcr->start_time = time(NULL); + jcr->jr.StartTime = jcr->start_time; + if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) { + Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); } - generate_job_event(jcr, "JobRun"); switch (jcr->JobType) { @@ -294,57 +316,27 @@ static void *job_thread(void *arg) admin_cleanup(jcr, JS_ErrorTerminated); } break; - case JT_MIGRATION: case JT_COPY: - case JT_ARCHIVE: - if (do_mac(jcr)) { /* migration, archive, copy */ + case JT_MIGRATE: + if (do_migration(jcr)) { do_autoprune(jcr); } else { - mac_cleanup(jcr, JS_ErrorTerminated); + migration_cleanup(jcr, JS_ErrorTerminated); } break; default: - Pmsg1(0, "Unimplemented job type: %d\n", jcr->JobType); + Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->JobType); break; } - if ((jcr->job->RunAfterJob && jcr->JobStatus == JS_Terminated) || - (jcr->job->RunAfterFailedJob && jcr->JobStatus != JS_Terminated)) { - POOLMEM *after = get_pool_memory(PM_FNAME); - int status; - BPIPE *bpipe; - char line[MAXSTRING]; + } - if (jcr->JobStatus == JS_Terminated) { - after = edit_job_codes(jcr, after, jcr->job->RunAfterJob, ""); - } else { - after = edit_job_codes(jcr, after, jcr->job->RunAfterFailedJob, ""); - } - bpipe = open_bpipe(after, 0, "r"); - free_pool_memory(after); - while (fgets(line, sizeof(line), bpipe->rfd)) { - Jmsg(jcr, M_INFO, 0, _("RunAfter: %s"), line); - } - status = close_bpipe(bpipe); - /* - * Note, if we get an error here, do not mark the - * job in error, simply report the error condition. - */ - if (status != 0) { - berrno be; - if (jcr->JobStatus == JS_Terminated) { - Jmsg(jcr, M_WARNING, 0, _("RunAfterJob error: ERR=%s\n"), be.strerror(status)); - } else { - Jmsg(jcr, M_FATAL, 0, _("RunAfterFailedJob error: ERR=%s\n"), be.strerror(status)); - } - } - } - /* Send off any queued messages */ - if (jcr->msg_queue->size() > 0) { - dequeue_messages(jcr); - } + run_scripts(jcr, jcr->job->RunScripts, "AfterJob"); + + /* Send off any queued messages */ + if (jcr->msg_queue && jcr->msg_queue->size() > 0) { + dequeue_messages(jcr); } -bail_out: generate_daemon_event(jcr, "JobEnd"); Dmsg1(50, "======== End Job stat=%c ==========\n", jcr->JobStatus); sm_check(__FILE__, __LINE__, true); @@ -356,12 +348,13 @@ bail_out: * Cancel a job -- typically called by the UA (Console program), but may also * be called by the job watchdog. * - * Returns: 1 if cancel appears to be successful - * 0 on failure. Message sent to ua->jcr. + * Returns: true if cancel appears to be successful + * false on failure. Message sent to ua->jcr. */ -int cancel_job(UAContext *ua, JCR *jcr) +bool cancel_job(UAContext *ua, JCR *jcr) { BSOCK *sd, *fd; + char ed1[50]; set_jcr_job_status(jcr, JS_Canceled); @@ -373,25 +366,24 @@ int cancel_job(UAContext *ua, JCR *jcr) case JS_WaitPriority: case JS_WaitMaxJobs: case JS_WaitStartTime: - bsendmsg(ua, _("JobId %d, Job %s marked to be canceled.\n"), - jcr->JobId, jcr->Job); + ua->info_msg(_("JobId %s, Job %s marked to be canceled.\n"), + edit_uint64(jcr->JobId, ed1), jcr->Job); jobq_remove(&job_queue, jcr); /* attempt to remove it from queue */ - return 1; + return true; default: - /* Cancel File daemon */ if (jcr->file_bsock) { ua->jcr->client = jcr->client; if (!connect_to_file_daemon(ua->jcr, 10, FDConnectTimeout, 1)) { - bsendmsg(ua, _("Failed to connect to File daemon.\n")); + ua->error_msg(_("Failed to connect to File daemon.\n")); return 0; } Dmsg0(200, "Connected to file daemon\n"); fd = ua->jcr->file_bsock; bnet_fsend(fd, "cancel Job=%s\n", jcr->Job); while (bnet_recv(fd) >= 0) { - bsendmsg(ua, "%s", fd->msg); + ua->send_msg("%s", fd->msg); } bnet_sig(fd, BNET_TERMINATE); bnet_close(fd); @@ -400,34 +392,85 @@ int cancel_job(UAContext *ua, JCR *jcr) /* Cancel Storage daemon */ if (jcr->store_bsock) { - if (!ua->jcr->storage) { - copy_storage(ua->jcr, jcr); + if (!ua->jcr->wstorage) { + if (jcr->rstorage) { + copy_wstorage(ua->jcr, jcr->rstorage, _("Job resource")); + } else { + copy_wstorage(ua->jcr, jcr->wstorage, _("Job resource")); + } } else { - set_storage(ua->jcr, jcr->store); + USTORE store; + if (jcr->rstorage) { + store.store = jcr->rstore; + } else { + store.store = jcr->wstore; + } + set_wstorage(ua->jcr, &store); } + if (!connect_to_storage_daemon(ua->jcr, 10, SDConnectTimeout, 1)) { - bsendmsg(ua, _("Failed to connect to Storage daemon.\n")); - return 0; + ua->error_msg(_("Failed to connect to Storage daemon.\n")); + return false; } Dmsg0(200, "Connected to storage daemon\n"); sd = ua->jcr->store_bsock; - bnet_fsend(sd, "cancel Job=%s\n", jcr->Job); - while (bnet_recv(sd) >= 0) { - bsendmsg(ua, "%s", sd->msg); + sd->fsend("cancel Job=%s\n", jcr->Job); + while (sd->recv() >= 0) { + ua->send_msg("%s", sd->msg); } - bnet_sig(sd, BNET_TERMINATE); - bnet_close(sd); + sd->signal(BNET_TERMINATE); + sd->close(); ua->jcr->store_bsock = NULL; } } - return 1; + return true; } +void cancel_storage_daemon_job(JCR *jcr) +{ + UAContext *ua = new_ua_context(jcr); + JCR *control_jcr = new_control_jcr("*JobCancel*", JT_SYSTEM); + BSOCK *sd; + + ua->jcr = control_jcr; + if (jcr->store_bsock) { + if (!ua->jcr->wstorage) { + if (jcr->rstorage) { + copy_wstorage(ua->jcr, jcr->rstorage, _("Job resource")); + } else { + copy_wstorage(ua->jcr, jcr->wstorage, _("Job resource")); + } + } else { + USTORE store; + if (jcr->rstorage) { + store.store = jcr->rstore; + } else { + store.store = jcr->wstore; + } + set_wstorage(ua->jcr, &store); + } + + if (!connect_to_storage_daemon(ua->jcr, 10, SDConnectTimeout, 1)) { + goto bail_out; + } + Dmsg0(200, "Connected to storage daemon\n"); + sd = ua->jcr->store_bsock; + sd->fsend("cancel Job=%s\n", jcr->Job); + while (sd->recv() >= 0) { + } + sd->signal(BNET_TERMINATE); + sd->close(); + ua->jcr->store_bsock = NULL; + } +bail_out: + free_jcr(control_jcr); + free_ua_context(ua); +} static void job_monitor_destructor(watchdog_t *self) { - JCR *control_jcr = (JCR *) self->data; + JCR *control_jcr = (JCR *)self->data; free_jcr(control_jcr); } @@ -438,40 +481,41 @@ static void job_monitor_watchdog(watchdog_t *self) control_jcr = (JCR *)self->data; + Dsm_check(1); Dmsg1(800, "job_monitor_watchdog %p called\n", self); foreach_jcr(jcr) { - bool cancel; + bool cancel = false; - if (jcr->JobId == 0) { - Dmsg2(800, "Skipping JCR %p (%s) with JobId 0\n", - jcr, jcr->Job); - /* Keep reference counts correct */ - free_jcr(jcr); + if (jcr->JobId == 0 || job_canceled(jcr)) { + Dmsg2(800, "Skipping JCR=%p Job=%s\n", jcr, jcr->Job); continue; } /* check MaxWaitTime */ - cancel = job_check_maxwaittime(control_jcr, jcr); - + if (job_check_maxwaittime(control_jcr, jcr)) { + set_jcr_job_status(jcr, JS_Canceled); + Jmsg(jcr, M_FATAL, 0, _("Max wait time exceeded. Job canceled.\n")); + cancel = true; /* check MaxRunTime */ - cancel |= job_check_maxruntime(control_jcr, jcr); + } else if (job_check_maxruntime(control_jcr, jcr)) { + set_jcr_job_status(jcr, JS_Canceled); + Jmsg(jcr, M_FATAL, 0, _("Max run time exceeded. Job canceled.\n")); + cancel = true; + } if (cancel) { - Dmsg3(800, "Cancelling JCR %p jobid %d (%s)\n", - jcr, jcr->JobId, jcr->Job); - + Dmsg3(800, "Cancelling JCR %p jobid %d (%s)\n", jcr, jcr->JobId, jcr->Job); UAContext *ua = new_ua_context(jcr); ua->jcr = control_jcr; cancel_job(ua, jcr); free_ua_context(ua); - - Dmsg1(800, "Have cancelled JCR %p\n", jcr); + Dmsg2(800, "Have cancelled JCR %p Job=%d\n", jcr, jcr->JobId); } - /* Keep reference counts correct */ - free_jcr(jcr); } + /* Keep reference counts correct */ + endeach_jcr(jcr); } /* @@ -481,72 +525,28 @@ static void job_monitor_watchdog(watchdog_t *self) static bool job_check_maxwaittime(JCR *control_jcr, JCR *jcr) { bool cancel = false; - bool ok_to_cancel = false; JOB *job = jcr->job; + if (job_canceled(jcr)) { + return false; /* already canceled */ + } if (job->MaxWaitTime == 0 && job->FullMaxWaitTime == 0 && job->IncMaxWaitTime == 0 && job->DiffMaxWaitTime == 0) { return false; } if (jcr->JobLevel == L_FULL && job->FullMaxWaitTime != 0 && (watchdog_time - jcr->start_time) >= job->FullMaxWaitTime) { - ok_to_cancel = true; + cancel = true; } else if (jcr->JobLevel == L_DIFFERENTIAL && job->DiffMaxWaitTime != 0 && (watchdog_time - jcr->start_time) >= job->DiffMaxWaitTime) { - ok_to_cancel = true; + cancel = true; } else if (jcr->JobLevel == L_INCREMENTAL && job->IncMaxWaitTime != 0 && (watchdog_time - jcr->start_time) >= job->IncMaxWaitTime) { - ok_to_cancel = true; + cancel = true; } else if (job->MaxWaitTime != 0 && (watchdog_time - jcr->start_time) >= job->MaxWaitTime) { - ok_to_cancel = true; - } - if (!ok_to_cancel) { - return false; - } - Dmsg3(800, "Job %d (%s): MaxWaitTime of %d seconds exceeded, " - "checking status\n", - jcr->JobId, jcr->Job, job->MaxWaitTime); - switch (jcr->JobStatus) { - case JS_Created: - case JS_Blocked: - case JS_WaitFD: - case JS_WaitSD: - case JS_WaitStoreRes: - case JS_WaitClientRes: - case JS_WaitJobRes: - case JS_WaitPriority: - case JS_WaitMaxJobs: - case JS_WaitStartTime: cancel = true; - Dmsg0(200, "JCR blocked in #1\n"); - break; - case JS_Running: - Dmsg0(800, "JCR running, checking SD status\n"); - switch (jcr->SDJobStatus) { - case JS_WaitMount: - case JS_WaitMedia: - case JS_WaitFD: - cancel = true; - Dmsg0(800, "JCR blocked in #2\n"); - break; - default: - Dmsg0(800, "JCR not blocked in #2\n"); - break; - } - break; - case JS_Terminated: - case JS_ErrorTerminated: - case JS_Canceled: - case JS_FatalError: - Dmsg0(800, "JCR already dead in #3\n"); - break; - default: - Jmsg1(jcr, M_ERROR, 0, _("Unhandled job status code %d\n"), - jcr->JobStatus); } - Dmsg3(800, "MaxWaitTime result: %scancel JCR %p (%s)\n", - cancel ? "" : "do not ", jcr, jcr->job); return cancel; } @@ -557,9 +557,7 @@ static bool job_check_maxwaittime(JCR *control_jcr, JCR *jcr) */ static bool job_check_maxruntime(JCR *control_jcr, JCR *jcr) { - bool cancel = false; - - if (jcr->job->MaxRunTime == 0) { + if (jcr->job->MaxRunTime == 0 || job_canceled(jcr) || jcr->JobStatus == JS_Created) { return false; } if ((watchdog_time - jcr->start_time) < jcr->job->MaxRunTime) { @@ -568,36 +566,146 @@ static bool job_check_maxruntime(JCR *control_jcr, JCR *jcr) return false; } - switch (jcr->JobStatus) { - case JS_Created: - case JS_Running: - case JS_Blocked: - case JS_WaitFD: - case JS_WaitSD: - case JS_WaitStoreRes: - case JS_WaitClientRes: - case JS_WaitJobRes: - case JS_WaitPriority: - case JS_WaitMaxJobs: - case JS_WaitStartTime: - case JS_Differences: - cancel = true; - break; - case JS_Terminated: - case JS_ErrorTerminated: - case JS_Canceled: - case JS_FatalError: - cancel = false; - break; - default: - Jmsg1(jcr, M_ERROR, 0, _("Unhandled job status code %d\n"), - jcr->JobStatus); + return true; +} + +/* + * Get or create a Pool record with the given name. + * Returns: 0 on error + * poolid if OK + */ +DBId_t get_or_create_pool_record(JCR *jcr, char *pool_name) +{ + POOL_DBR pr; + + memset(&pr, 0, sizeof(pr)); + bstrncpy(pr.Name, pool_name, sizeof(pr.Name)); + Dmsg1(110, "get_or_create_pool=%s\n", pool_name); + + while (!db_get_pool_record(jcr, jcr->db, &pr)) { /* get by Name */ + /* Try to create the pool */ + if (create_pool(jcr, jcr->db, jcr->pool, POOL_OP_CREATE) < 0) { + Jmsg(jcr, M_FATAL, 0, _("Pool \"%s\" not in database. ERR=%s"), pr.Name, + db_strerror(jcr->db)); + return 0; + } else { + Jmsg(jcr, M_INFO, 0, _("Created database record for Pool \"%s\".\n"), pr.Name); + } } + return pr.PoolId; +} - Dmsg3(200, "MaxRunTime result: %scancel JCR %p (%s)\n", - cancel ? "" : "do not ", jcr, jcr->job); +/* + * Check for duplicate jobs. + * Returns: true if current job should continue + * false if current job should terminate + */ +bool allow_duplicate_job(JCR *jcr) +{ + JOB *job = jcr->job; + JCR *djcr; /* possible duplicate */ - return cancel; + if (job->AllowDuplicateJobs) { + return true; + } + if (!job->AllowHigherDuplicates) { + foreach_jcr(djcr) { + if (strcmp(job->name(), djcr->job->name()) == 0) { + bool cancel_queued = false; + if (job->DuplicateJobProximity > 0) { + time_t now = time(NULL); + if ((now - djcr->start_time) > job->DuplicateJobProximity) { + continue; /* not really a duplicate */ + } + } + /* Cancel */ + if (!(job->CancelQueuedDuplicates || job->CancelRunningDuplicates)) { + /* Zap current job */ + Jmsg(jcr, M_FATAL, 0, _("Duplicate job not allowed.\n")); + return false; + } + /* If CancelQueuedDuplicates is set do so only if job is queued */ + if (job->CancelQueuedDuplicates) { + switch (djcr->JobStatus) { + case JS_Created: + case JS_WaitJobRes: + case JS_WaitClientRes: + case JS_WaitStoreRes: + case JS_WaitPriority: + case JS_WaitMaxJobs: + case JS_WaitStartTime: + cancel_queued = true; + break; + default: + break; + } + } + if (cancel_queued || job->CancelRunningDuplicates) { + UAContext *ua = new_ua_context(djcr); + char ec1[50]; + Jmsg(jcr, M_INFO, 0, _("Cancelling duplicate JobId=%s.\n"), + edit_uint64(djcr->JobId, ec1)); + ua->jcr = djcr; + cancel_job(ua, djcr); + free_ua_context(ua); + Dmsg2(800, "Have cancelled JCR %p Job=%d\n", djcr, djcr->JobId); + } + } + } + } + return true; +} + +void apply_pool_overrides(JCR *jcr) +{ + bool pool_override = false; + + if (jcr->run_pool_override) { + pm_strcpy(jcr->pool_source, _("Run pool override")); + } + /* + * Apply any level related Pool selections + */ + switch (jcr->JobLevel) { + case L_FULL: + if (jcr->full_pool) { + jcr->pool = jcr->full_pool; + pool_override = true; + if (jcr->run_full_pool_override) { + pm_strcpy(jcr->pool_source, _("Run FullPool override")); + } else { + pm_strcpy(jcr->pool_source, _("Job FullPool override")); + } + } + break; + case L_INCREMENTAL: + if (jcr->inc_pool) { + jcr->pool = jcr->inc_pool; + pool_override = true; + if (jcr->run_inc_pool_override) { + pm_strcpy(jcr->pool_source, _("Run IncPool override")); + } else { + pm_strcpy(jcr->pool_source, _("Job IncPool override")); + } + } + break; + case L_DIFFERENTIAL: + if (jcr->diff_pool) { + jcr->pool = jcr->diff_pool; + pool_override = true; + if (jcr->run_diff_pool_override) { + pm_strcpy(jcr->pool_source, _("Run DiffPool override")); + } else { + pm_strcpy(jcr->pool_source, _("Job DiffPool override")); + } + } + break; + } + /* Update catalog if pool overridden */ + if (pool_override && jcr->pool->catalog) { + jcr->catalog = jcr->pool->catalog; + pm_strcpy(jcr->catalog_source, _("Pool resource")); + } } @@ -634,32 +742,38 @@ bool get_or_create_client_record(JCR *jcr) return true; } -bool get_or_create_fileset_record(JCR *jcr, FILESET_DBR *fsr) +bool get_or_create_fileset_record(JCR *jcr) { + FILESET_DBR fsr; /* * Get or Create FileSet record */ - memset(fsr, 0, sizeof(FILESET_DBR)); - bstrncpy(fsr->FileSet, jcr->fileset->hdr.name, sizeof(fsr->FileSet)); + memset(&fsr, 0, sizeof(FILESET_DBR)); + bstrncpy(fsr.FileSet, jcr->fileset->hdr.name, sizeof(fsr.FileSet)); if (jcr->fileset->have_MD5) { struct MD5Context md5c; - unsigned char signature[16]; + unsigned char digest[MD5HashSize]; memcpy(&md5c, &jcr->fileset->md5c, sizeof(md5c)); - MD5Final(signature, &md5c); - bin_to_base64(fsr->MD5, (char *)signature, 16); /* encode 16 bytes */ - bstrncpy(jcr->fileset->MD5, fsr->MD5, sizeof(jcr->fileset->MD5)); + MD5Final(digest, &md5c); + /* + * Keep the flag (last arg) set to false otherwise old FileSets will + * get new MD5 sums and the user will get Full backups on everything + */ + bin_to_base64(fsr.MD5, sizeof(fsr.MD5), (char *)digest, MD5HashSize, false); + bstrncpy(jcr->fileset->MD5, fsr.MD5, sizeof(jcr->fileset->MD5)); } else { - Jmsg(jcr, M_WARNING, 0, _("FileSet MD5 signature not found.\n")); + Jmsg(jcr, M_WARNING, 0, _("FileSet MD5 digest not found.\n")); } if (!jcr->fileset->ignore_fs_changes || - !db_get_fileset_record(jcr, jcr->db, fsr)) { - if (!db_create_fileset_record(jcr, jcr->db, fsr)) { + !db_get_fileset_record(jcr, jcr->db, &fsr)) { + if (!db_create_fileset_record(jcr, jcr->db, &fsr)) { Jmsg(jcr, M_ERROR, 0, _("Could not create FileSet \"%s\" record. ERR=%s\n"), - fsr->FileSet, db_strerror(jcr->db)); + fsr.FileSet, db_strerror(jcr->db)); return false; } } - jcr->jr.FileSetId = fsr->FileSetId; + jcr->jr.FileSetId = fsr.FileSetId; + bstrncpy(jcr->FSCreateTime, fsr.cCreateTime, sizeof(jcr->FSCreateTime)); Dmsg2(119, "Created FileSet %s record %u\n", jcr->fileset->hdr.name, jcr->jr.FileSetId); return true; @@ -674,7 +788,7 @@ void init_jcr_job_record(JCR *jcr) jcr->jr.JobLevel = jcr->JobLevel; jcr->jr.JobStatus = jcr->JobStatus; jcr->jr.JobId = jcr->JobId; - bstrncpy(jcr->jr.Name, jcr->job->hdr.name, sizeof(jcr->jr.Name)); + bstrncpy(jcr->jr.Name, jcr->job->name(), sizeof(jcr->jr.Name)); bstrncpy(jcr->jr.Job, jcr->Job, sizeof(jcr->jr.Job)); } @@ -691,6 +805,7 @@ void update_job_end_record(JCR *jcr) jcr->jr.JobBytes = jcr->JobBytes; jcr->jr.VolSessionId = jcr->VolSessionId; jcr->jr.VolSessionTime = jcr->VolSessionTime; + jcr->jr.JobErrors = jcr->Errors; if (!db_update_job_end_record(jcr, jcr->db, &jcr->jr)) { Jmsg(jcr, M_WARNING, 0, _("Error updating job record. %s"), db_strerror(jcr->db)); @@ -701,6 +816,10 @@ void update_job_end_record(JCR *jcr) * Takes base_name and appends (unique) current * date and time to form unique job name. * + * Note, the seconds are actually a sequence number. This + * permits us to start a maximum fo 59 unique jobs a second, which + * should be sufficient. + * * Returns: unique job name in jcr->Job * date/time in jcr->start_time */ @@ -709,6 +828,7 @@ void create_unique_job_name(JCR *jcr, const char *base_name) /* Job start mutex */ static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; static time_t last_start_time = 0; + static int seq = 0; time_t now; struct tm tm; char dt[MAX_TIME_LENGTH]; @@ -720,20 +840,24 @@ void create_unique_job_name(JCR *jcr, const char *base_name) */ P(mutex); /* lock creation of jobs */ now = time(NULL); - while (now == last_start_time) { - bmicrosleep(0, 500000); - now = time(NULL); + seq++; + if (seq > 59) { /* wrap as if it is seconds */ + seq = 0; + while (now == last_start_time) { + bmicrosleep(0, 500000); + now = time(NULL); + } } last_start_time = now; V(mutex); /* allow creation of jobs */ jcr->start_time = now; /* Form Unique JobName */ - localtime_r(&now, &tm); + (void)localtime_r(&now, &tm); /* Use only characters that are permitted in Windows filenames */ - strftime(dt, sizeof(dt), "%Y-%m-%d_%H.%M.%S", &tm); + strftime(dt, sizeof(dt), "%Y-%m-%d_%H.%M", &tm); bstrncpy(name, base_name, sizeof(name)); name[sizeof(name)-22] = 0; /* truncate if too long */ - bsnprintf(jcr->Job, sizeof(jcr->Job), "%s.%s", name, dt); /* add date & time */ + bsnprintf(jcr->Job, sizeof(jcr->Job), "%s.%s.%02d", name, dt, seq); /* add date & time */ /* Convert spaces into underscores */ for (p=jcr->Job; *p; p++) { if (*p == ' ') { @@ -768,11 +892,6 @@ void dird_free_jcr_pointers(JCR *jcr) free_pool_memory(jcr->fname); jcr->fname = NULL; } - if (jcr->stime) { - Dmsg0(200, "Free JCR stime\n"); - free_pool_memory(jcr->stime); - jcr->stime = NULL; - } if (jcr->RestoreBootstrap) { free(jcr->RestoreBootstrap); jcr->RestoreBootstrap = NULL; @@ -781,10 +900,6 @@ void dird_free_jcr_pointers(JCR *jcr) free_pool_memory(jcr->client_uname); jcr->client_uname = NULL; } - if (jcr->term_wait_inited) { - pthread_cond_destroy(&jcr->term_wait); - jcr->term_wait_inited = false; - } if (jcr->attr) { free_pool_memory(jcr->attr); jcr->attr = NULL; @@ -805,15 +920,86 @@ void dird_free_jcr(JCR *jcr) Dmsg0(200, "Start dird free_jcr\n"); dird_free_jcr_pointers(jcr); + if (jcr->term_wait_inited) { + pthread_cond_destroy(&jcr->term_wait); + jcr->term_wait_inited = false; + } + if (jcr->db_batch && jcr->db_batch != jcr->db) { + db_close_database(jcr, jcr->db_batch); + } + jcr->db_batch = NULL; + if (jcr->db) { + db_close_database(jcr, jcr->db); + jcr->db = NULL; + } + if (jcr->stime) { + Dmsg0(200, "Free JCR stime\n"); + free_pool_memory(jcr->stime); + jcr->stime = NULL; + } + if (jcr->fname) { + Dmsg0(200, "Free JCR fname\n"); + free_pool_memory(jcr->fname); + jcr->fname = NULL; + } + if (jcr->pool_source) { + free_pool_memory(jcr->pool_source); + jcr->pool_source = NULL; + } + if (jcr->catalog_source) { + free_pool_memory(jcr->catalog_source); + jcr->catalog_source = NULL; + } + if (jcr->rpool_source) { + free_pool_memory(jcr->rpool_source); + jcr->rpool_source = NULL; + } + if (jcr->wstore_source) { + free_pool_memory(jcr->wstore_source); + jcr->wstore_source = NULL; + } + if (jcr->rstore_source) { + free_pool_memory(jcr->rstore_source); + jcr->rstore_source = NULL; + } /* Delete lists setup to hold storage pointers */ - if (jcr->storage) { - delete jcr->storage; - } + free_rwstorage(jcr); + jcr->job_end_push.destroy(); + + if (jcr->JobId != 0) + write_state_file(director->working_directory, "bacula-dir", get_first_port_host_order(director->DIRaddrs)); + Dmsg0(200, "End dird free_jcr\n"); } +/* + * The Job storage definition must be either in the Job record + * or in the Pool record. The Pool record overrides the Job + * record. + */ +void get_job_storage(USTORE *store, JOB *job, RUN *run) +{ + if (run && run->pool && run->pool->storage) { + store->store = (STORE *)run->pool->storage->first(); + pm_strcpy(store->store_source, _("Run pool override")); + return; + } + if (run && run->storage) { + store->store = run->storage; + pm_strcpy(store->store_source, _("Run storage override")); + return; + } + if (job->pool->storage) { + store->store = (STORE *)job->pool->storage->first(); + pm_strcpy(store->store_source, _("Pool resource")); + } else { + store->store = (STORE *)job->storage->first(); + pm_strcpy(store->store_source, _("Job resource")); + } +} + /* * Set some defaults in the JCR necessary to * run. These items are pulled from the job @@ -823,46 +1009,67 @@ void dird_free_jcr(JCR *jcr) */ void set_jcr_defaults(JCR *jcr, JOB *job) { - STORE *st; jcr->job = job; jcr->JobType = job->JobType; + jcr->JobStatus = JS_Created; switch (jcr->JobType) { case JT_ADMIN: case JT_RESTORE: jcr->JobLevel = L_NONE; break; + case JT_COPY: + case JT_MIGRATE: + if (!jcr->rpool_source) { + jcr->rpool_source = get_pool_memory(PM_MESSAGE); + pm_strcpy(jcr->rpool_source, _("unknown source")); + } + /* Fall-through wanted */ default: jcr->JobLevel = job->JobLevel; break; } + if (!jcr->fname) { + jcr->fname = get_pool_memory(PM_FNAME); + } + if (!jcr->pool_source) { + jcr->pool_source = get_pool_memory(PM_MESSAGE); + pm_strcpy(jcr->pool_source, _("unknown source")); + } + if (!jcr->catalog_source) { + jcr->catalog_source = get_pool_memory(PM_MESSAGE); + pm_strcpy(jcr->catalog_source, _("unknown source")); + } + jcr->JobPriority = job->Priority; /* Copy storage definitions -- deleted in dir_free_jcr above */ if (job->storage) { - if (jcr->storage) { - delete jcr->storage; - } - jcr->storage = New(alist(10, not_owned_by_alist)); - foreach_alist(st, job->storage) { - jcr->storage->append(st); - } - } - if (jcr->storage) { - jcr->store = (STORE *)jcr->storage->first(); + copy_rwstorage(jcr, job->storage, _("Job resource")); + } else { + copy_rwstorage(jcr, job->pool->storage, _("Pool resource")); } jcr->client = job->client; if (!jcr->client_name) { jcr->client_name = get_pool_memory(PM_NAME); } pm_strcpy(jcr->client_name, jcr->client->hdr.name); + pm_strcpy(jcr->pool_source, _("Job resource")); jcr->pool = job->pool; jcr->full_pool = job->full_pool; jcr->inc_pool = job->inc_pool; - jcr->dif_pool = job->dif_pool; - jcr->catalog = job->client->catalog; + jcr->diff_pool = job->diff_pool; + if (job->pool->catalog) { + jcr->catalog = job->pool->catalog; + pm_strcpy(jcr->catalog_source, _("Pool resource")); + } else { + jcr->catalog = job->client->catalog; + pm_strcpy(jcr->catalog_source, _("Client resource")); + } jcr->fileset = job->fileset; jcr->messages = job->messages; jcr->spool_data = job->spool_data; + jcr->spool_size = job->spool_size; jcr->write_part_after_job = job->write_part_after_job; + jcr->accurate = job->accurate; if (jcr->RestoreBootstrap) { free(jcr->RestoreBootstrap); jcr->RestoreBootstrap = NULL; @@ -887,44 +1094,247 @@ void set_jcr_defaults(JCR *jcr, JOB *job) jcr->JobLevel = L_NONE; break; default: + jcr->JobLevel = L_FULL; break; } } } -/* - * copy the storage definitions from an old JCR to a new one +/* + * Copy the storage definitions from an alist to the JCR */ -void copy_storage(JCR *new_jcr, JCR *old_jcr) +void copy_rwstorage(JCR *jcr, alist *storage, const char *where) { - if (old_jcr->storage) { + switch(jcr->JobType) { + case JT_RESTORE: + case JT_VERIFY: + case JT_COPY: + case JT_MIGRATE: + copy_rstorage(jcr, storage, where); + break; + default: + copy_wstorage(jcr, storage, where); + break; + } +} + + +/* Set storage override. Releases any previous storage definition */ +void set_rwstorage(JCR *jcr, USTORE *store) +{ + if (!store) { + Jmsg(jcr, M_FATAL, 0, _("No storage specified.\n")); + return; + } + switch(jcr->JobType) { + case JT_RESTORE: + case JT_VERIFY: + case JT_COPY: + case JT_MIGRATE: + set_rstorage(jcr, store); + break; + default: + set_wstorage(jcr, store); + break; + } +} + +void free_rwstorage(JCR *jcr) +{ + free_rstorage(jcr); + free_wstorage(jcr); +} + +/* + * Copy the storage definitions from an alist to the JCR + */ +void copy_rstorage(JCR *jcr, alist *storage, const char *where) +{ + if (storage) { STORE *st; - if (old_jcr->storage) { - delete old_jcr->storage; + if (jcr->rstorage) { + delete jcr->rstorage; + } + jcr->rstorage = New(alist(10, not_owned_by_alist)); + foreach_alist(st, storage) { + jcr->rstorage->append(st); } - new_jcr->storage = New(alist(10, not_owned_by_alist)); - foreach_alist(st, old_jcr->storage) { - new_jcr->storage->append(st); + if (!jcr->rstore_source) { + jcr->rstore_source = get_pool_memory(PM_MESSAGE); } + pm_strcpy(jcr->rstore_source, where); + if (jcr->rstorage) { + jcr->rstore = (STORE *)jcr->rstorage->first(); + } + } +} + + +/* Set storage override. Remove all previous storage */ +void set_rstorage(JCR *jcr, USTORE *store) +{ + STORE *storage; + + if (!store->store) { + return; } - if (old_jcr->store) { - new_jcr->store = old_jcr->store; - } else if (new_jcr->storage) { - new_jcr->store = (STORE *)new_jcr->storage->first(); + if (jcr->rstorage) { + free_rstorage(jcr); } + if (!jcr->rstorage) { + jcr->rstorage = New(alist(10, not_owned_by_alist)); + } + jcr->rstore = store->store; + if (!jcr->rstore_source) { + jcr->rstore_source = get_pool_memory(PM_MESSAGE); + } + pm_strcpy(jcr->rstore_source, store->store_source); + foreach_alist(storage, jcr->rstorage) { + if (store->store == storage) { + return; + } + } + /* Store not in list, so add it */ + jcr->rstorage->prepend(store->store); } -/* Set storage override */ -void set_storage(JCR *jcr, STORE *store) +void free_rstorage(JCR *jcr) +{ + if (jcr->rstorage) { + delete jcr->rstorage; + jcr->rstorage = NULL; + } + jcr->rstore = NULL; +} + +/* + * Copy the storage definitions from an alist to the JCR + */ +void copy_wstorage(JCR *jcr, alist *storage, const char *where) +{ + if (storage) { + STORE *st; + if (jcr->wstorage) { + delete jcr->wstorage; + } + jcr->wstorage = New(alist(10, not_owned_by_alist)); + foreach_alist(st, storage) { + Dmsg1(100, "wstorage=%s\n", st->name()); + jcr->wstorage->append(st); + } + if (!jcr->wstore_source) { + jcr->wstore_source = get_pool_memory(PM_MESSAGE); + } + pm_strcpy(jcr->wstore_source, where); + if (jcr->wstorage) { + jcr->wstore = (STORE *)jcr->wstorage->first(); + Dmsg2(100, "wstore=%s where=%s\n", jcr->wstore->name(), jcr->wstore_source); + } + } +} + + +/* Set storage override. Remove all previous storage */ +void set_wstorage(JCR *jcr, USTORE *store) { STORE *storage; - jcr->store = store; - foreach_alist(storage, jcr->storage) { - if (store == storage) { + if (!store->store) { + return; + } + if (jcr->wstorage) { + free_wstorage(jcr); + } + if (!jcr->wstorage) { + jcr->wstorage = New(alist(10, not_owned_by_alist)); + } + jcr->wstore = store->store; + if (!jcr->wstore_source) { + jcr->wstore_source = get_pool_memory(PM_MESSAGE); + } + pm_strcpy(jcr->wstore_source, store->store_source); + Dmsg2(50, "wstore=%s where=%s\n", jcr->wstore->name(), jcr->wstore_source); + foreach_alist(storage, jcr->wstorage) { + if (store->store == storage) { return; } } /* Store not in list, so add it */ - jcr->storage->prepend(store); + jcr->wstorage->prepend(store->store); +} + +void free_wstorage(JCR *jcr) +{ + if (jcr->wstorage) { + delete jcr->wstorage; + jcr->wstorage = NULL; + } + jcr->wstore = NULL; +} + +void create_clones(JCR *jcr) +{ + /* + * Fire off any clone jobs (run directives) + */ + Dmsg2(900, "cloned=%d run_cmds=%p\n", jcr->cloned, jcr->job->run_cmds); + if (!jcr->cloned && jcr->job->run_cmds) { + char *runcmd; + JOB *job = jcr->job; + POOLMEM *cmd = get_pool_memory(PM_FNAME); + UAContext *ua = new_ua_context(jcr); + ua->batch = true; + foreach_alist(runcmd, job->run_cmds) { + cmd = edit_job_codes(jcr, cmd, runcmd, ""); + Mmsg(ua->cmd, "run %s cloned=yes", cmd); + Dmsg1(900, "=============== Clone cmd=%s\n", ua->cmd); + parse_ua_args(ua); /* parse command */ + int stat = run_cmd(ua, ua->cmd); + if (stat == 0) { + Jmsg(jcr, M_ERROR, 0, _("Could not start clone job.\n")); + } else { + Jmsg(jcr, M_INFO, 0, _("Clone JobId %d started.\n"), stat); + } + } + free_ua_context(ua); + free_pool_memory(cmd); + } +} + +bool create_restore_bootstrap_file(JCR *jcr) +{ + RESTORE_CTX rx; + UAContext *ua; + memset(&rx, 0, sizeof(rx)); + rx.bsr = new_bsr(); + rx.JobIds = (char *)""; + rx.bsr->JobId = jcr->previous_jr.JobId; + ua = new_ua_context(jcr); + complete_bsr(ua, rx.bsr); + rx.bsr->fi = new_findex(); + rx.bsr->fi->findex = 1; + rx.bsr->fi->findex2 = jcr->previous_jr.JobFiles; + jcr->ExpectedFiles = write_bsr_file(ua, rx); + if (jcr->ExpectedFiles == 0) { + free_ua_context(ua); + free_bsr(rx.bsr); + return false; + } + free_ua_context(ua); + free_bsr(rx.bsr); + jcr->needs_sd = true; + return true; +} + +bool run_console_command(JCR *jcr, const char *cmd){ + UAContext *ua; + bool ok; + + ua = new_ua_context(jcr); + Mmsg(ua->cmd, "%s", cmd); + Dmsg1(100, "Console command: %s\n", ua->cmd); + parse_ua_args(ua); + ok= do_a_command(ua); + free_ua_context(ua); + return ok; }