X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fdird%2Fjob.c;h=48556976e74f34e007532d6dbb409f4838ac3274;hb=e1e7c2aaef15193daad550d12c2ca4c65e76778c;hp=4b1b858b56ba9973ed320eed3d3ae3e8f6567e49;hpb=9213f5d7f00e56f0d3c5146a7aafab0f6ccd0965;p=bacula%2Fbacula diff --git a/bacula/src/dird/job.c b/bacula/src/dird/job.c index 4b1b858b56..48556976e7 100644 --- a/bacula/src/dird/job.c +++ b/bacula/src/dird/job.c @@ -1,7 +1,7 @@ /* Bacula® - The Network Backup Solution - Copyright (C) 2000-2008 Free Software Foundation Europe e.V. + Copyright (C) 2000-2010 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. @@ -20,7 +20,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - Bacula® is a registered trademark of John Walker. + Bacula® is a registered trademark of Kern Sibbald. The licensor of Bacula is the Free Software Foundation Europe (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, Switzerland, email:ftf@fsfeurope.org. @@ -31,7 +31,6 @@ * * Kern Sibbald, October MM * - * Version $Id$ */ #include "bacula.h" @@ -41,8 +40,9 @@ static void *job_thread(void *arg); static void job_monitor_watchdog(watchdog_t *self); static void job_monitor_destructor(watchdog_t *self); -static bool job_check_maxwaittime(JCR *control_jcr, JCR *jcr); -static bool job_check_maxruntime(JCR *control_jcr, JCR *jcr); +static bool job_check_maxwaittime(JCR *jcr); +static bool job_check_maxruntime(JCR *jcr); +static bool job_check_maxschedruntime(JCR *jcr); /* Imported subroutines */ extern void term_scheduler(); @@ -111,12 +111,13 @@ bool setup_job(JCR *jcr) 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.bstrerror(errstat)); + jcr->unlock(); goto bail_out; } jcr->term_wait_inited = true; create_unique_job_name(jcr, jcr->job->name()); - set_jcr_job_status(jcr, JS_Created); + jcr->setJobStatus(JS_Created); jcr->unlock(); /* @@ -138,7 +139,6 @@ bool setup_job(JCR *jcr) goto bail_out; } Dmsg0(150, "DB opened\n"); - if (!jcr->fname) { jcr->fname = get_pool_memory(PM_FNAME); } @@ -146,8 +146,8 @@ bool setup_job(JCR *jcr) 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) { + + if (jcr->JobReads()) { if (!jcr->rpool_source) { jcr->rpool_source = get_pool_memory(PM_MESSAGE); pm_strcpy(jcr->rpool_source, _("unknown source")); @@ -171,49 +171,69 @@ bool setup_job(JCR *jcr) jcr->JobId, jcr->Job, jcr->jr.JobType, jcr->jr.JobLevel); generate_daemon_event(jcr, "JobStart"); + new_plugins(jcr); /* instantiate plugins for this jcr */ + generate_plugin_event(jcr, bEventJobStart); if (job_canceled(jcr)) { goto bail_out; } + if (jcr->JobReads() && !jcr->rstorage) { + if (jcr->job->storage) { + copy_rwstorage(jcr, jcr->job->storage, _("Job resource")); + } else { + copy_rwstorage(jcr, jcr->job->pool->storage, _("Pool resource")); + } + } + if (!jcr->JobReads()) { + free_rstorage(jcr); + } + /* * Now, do pre-run stuff, like setting job level (Inc/diff, ...) * this allows us to setup a proper job start record for restarting * in case of later errors. */ - switch (jcr->JobType) { + switch (jcr->getJobType()) { case JT_BACKUP: if (!do_backup_init(jcr)) { backup_cleanup(jcr, JS_ErrorTerminated); + goto bail_out; } break; case JT_VERIFY: if (!do_verify_init(jcr)) { verify_cleanup(jcr, JS_ErrorTerminated); + goto bail_out; } break; case JT_RESTORE: if (!do_restore_init(jcr)) { restore_cleanup(jcr, JS_ErrorTerminated); + goto bail_out; } break; case JT_ADMIN: if (!do_admin_init(jcr)) { admin_cleanup(jcr, JS_ErrorTerminated); + goto bail_out; } break; + case JT_COPY: case JT_MIGRATE: if (!do_migration_init(jcr)) { migration_cleanup(jcr, JS_ErrorTerminated); + goto bail_out; } break; default: - Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->JobType); - set_jcr_job_status(jcr, JS_ErrorTerminated); - break; + Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->getJobType()); + jcr->setJobStatus(JS_ErrorTerminated); + goto bail_out; } generate_job_event(jcr, "JobInit"); + generate_plugin_event(jcr, bEventJobInit); Dsm_check(1); return true; @@ -224,7 +244,7 @@ bail_out: void update_job_end(JCR *jcr, int TermCode) { dequeue_messages(jcr); /* display any queued messages */ - set_jcr_job_status(jcr, TermCode); + jcr->setJobStatus(TermCode); update_job_end_record(jcr); } @@ -242,16 +262,21 @@ static void *job_thread(void *arg) Dsm_check(1); Dmsg0(200, "=====Start Job=========\n"); - set_jcr_job_status(jcr, JS_Running); /* this will be set only if no error */ + jcr->setJobStatus(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); + jcr->setJobStatus(JS_Canceled); Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n")); } + if (job_check_maxschedruntime(jcr)) { + jcr->setJobStatus(JS_Canceled); + Jmsg(jcr, M_FATAL, 0, _("Job canceled because max sched run time exceeded.\n")); + } + /* TODO : check if it is used somewhere */ if (jcr->job->RunScripts == NULL) { Dmsg0(200, "Warning, job->RunScripts is empty\n"); @@ -265,69 +290,64 @@ static void *job_thread(void *arg) /* Run any script BeforeJob on dird */ run_scripts(jcr, jcr->job->RunScripts, "BeforeJob"); - if (job_canceled(jcr)) { - update_job_end(jcr, jcr->JobStatus); + /* + * 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"); + generate_plugin_event(jcr, bEventJobRun); - } else { - /* - * 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)); + switch (jcr->getJobType()) { + case JT_BACKUP: + if (!job_canceled(jcr) && do_backup(jcr)) { + do_autoprune(jcr); + } else { + backup_cleanup(jcr, JS_ErrorTerminated); } - generate_job_event(jcr, "JobRun"); - - switch (jcr->JobType) { - case JT_BACKUP: - if (do_backup(jcr)) { - do_autoprune(jcr); - } else { - backup_cleanup(jcr, JS_ErrorTerminated); - } - break; - case JT_VERIFY: - if (do_verify(jcr)) { - do_autoprune(jcr); - } else { - verify_cleanup(jcr, JS_ErrorTerminated); - } - break; - case JT_RESTORE: - if (do_restore(jcr)) { - do_autoprune(jcr); - } else { - restore_cleanup(jcr, JS_ErrorTerminated); - } - break; - case JT_ADMIN: - if (do_admin(jcr)) { - do_autoprune(jcr); - } else { - admin_cleanup(jcr, JS_ErrorTerminated); - } - break; - case JT_MIGRATE: - case JT_COPY: - case JT_ARCHIVE: - if (do_migration(jcr)) { - do_autoprune(jcr); - } else { - migration_cleanup(jcr, JS_ErrorTerminated); - } - break; - default: - Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->JobType); - break; + break; + case JT_VERIFY: + if (!job_canceled(jcr) && do_verify(jcr)) { + do_autoprune(jcr); + } else { + verify_cleanup(jcr, JS_ErrorTerminated); } + break; + case JT_RESTORE: + if (!job_canceled(jcr) && do_restore(jcr)) { + do_autoprune(jcr); + } else { + restore_cleanup(jcr, JS_ErrorTerminated); + } + break; + case JT_ADMIN: + if (!job_canceled(jcr) && do_admin(jcr)) { + do_autoprune(jcr); + } else { + admin_cleanup(jcr, JS_ErrorTerminated); + } + break; + case JT_COPY: + case JT_MIGRATE: + if (!job_canceled(jcr) && do_migration(jcr)) { + do_autoprune(jcr); + } else { + migration_cleanup(jcr, JS_ErrorTerminated); + } + break; + default: + Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->getJobType()); + break; } run_scripts(jcr, jcr->job->RunScripts, "AfterJob"); @@ -338,6 +358,7 @@ static void *job_thread(void *arg) } generate_daemon_event(jcr, "JobEnd"); + generate_plugin_event(jcr, bEventJobEnd); Dmsg1(50, "======== End Job stat=%c ==========\n", jcr->JobStatus); sm_check(__FILE__, __LINE__, true); return NULL; @@ -355,10 +376,11 @@ bool cancel_job(UAContext *ua, JCR *jcr) { BSOCK *sd, *fd; char ed1[50]; + int32_t old_status = jcr->JobStatus; - set_jcr_job_status(jcr, JS_Canceled); + jcr->setJobStatus(JS_Canceled); - switch (jcr->JobStatus) { + switch (old_status) { case JS_Created: case JS_WaitJobRes: case JS_WaitClientRes: @@ -369,7 +391,7 @@ bool cancel_job(UAContext *ua, JCR *jcr) 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 true; + break; default: /* Cancel File daemon */ @@ -381,13 +403,18 @@ bool cancel_job(UAContext *ua, JCR *jcr) } 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) { + fd->fsend("cancel Job=%s\n", jcr->Job); + while (fd->recv() >= 0) { ua->send_msg("%s", fd->msg); } - bnet_sig(fd, BNET_TERMINATE); - bnet_close(fd); + fd->signal(BNET_TERMINATE); + fd->close(); ua->jcr->file_bsock = NULL; + jcr->file_bsock->set_terminated(); + if (jcr->my_thread_id) { + pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL); + Dmsg1(800, "Send kill to jid=%d\n", jcr->JobId); + } } /* Cancel Storage daemon */ @@ -421,7 +448,17 @@ bool cancel_job(UAContext *ua, JCR *jcr) sd->signal(BNET_TERMINATE); sd->close(); ua->jcr->store_bsock = NULL; + jcr->store_bsock->set_timed_out(); + jcr->store_bsock->set_terminated(); + if (jcr->SD_msg_chan) { + Dmsg2(400, "kill jobid=%d use=%d\n", (int)jcr->JobId, jcr->use_count()); + pthread_kill(jcr->SD_msg_chan, TIMEOUT_SIGNAL); + } + if (jcr->my_thread_id) { + pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL); + } } + break; } return true; @@ -429,6 +466,10 @@ bool cancel_job(UAContext *ua, JCR *jcr) void cancel_storage_daemon_job(JCR *jcr) { + if (jcr->sd_canceled) { + return; /* cancel only once */ + } + UAContext *ua = new_ua_context(jcr); JCR *control_jcr = new_control_jcr("*JobCancel*", JT_SYSTEM); BSOCK *sd; @@ -462,6 +503,16 @@ void cancel_storage_daemon_job(JCR *jcr) sd->signal(BNET_TERMINATE); sd->close(); ua->jcr->store_bsock = NULL; + jcr->sd_canceled = true; + jcr->store_bsock->set_timed_out(); + jcr->store_bsock->set_terminated(); + if (jcr->SD_msg_chan) { + Dmsg2(400, "kill jobid=%d use=%d\n", (int)jcr->JobId, jcr->use_count()); + pthread_kill(jcr->SD_msg_chan, TIMEOUT_SIGNAL); + } + if (jcr->my_thread_id) { + pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL); + } } bail_out: free_jcr(control_jcr); @@ -487,20 +538,25 @@ static void job_monitor_watchdog(watchdog_t *self) foreach_jcr(jcr) { bool cancel = false; - if (jcr->JobId == 0 || job_canceled(jcr)) { + if (jcr->JobId == 0 || job_canceled(jcr) || jcr->no_maxtime) { Dmsg2(800, "Skipping JCR=%p Job=%s\n", jcr, jcr->Job); continue; } /* check MaxWaitTime */ - 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")); + if (job_check_maxwaittime(jcr)) { + jcr->setJobStatus(JS_Canceled); + Qmsg(jcr, M_FATAL, 0, _("Max wait time exceeded. Job canceled.\n")); cancel = true; /* check MaxRunTime */ - } 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")); + } else if (job_check_maxruntime(jcr)) { + jcr->setJobStatus(JS_Canceled); + Qmsg(jcr, M_FATAL, 0, _("Max run time exceeded. Job canceled.\n")); + cancel = true; + /* check MaxRunSchedTime */ + } else if (job_check_maxschedruntime(jcr)) { + jcr->setJobStatus(JS_Canceled); + Qmsg(jcr, M_FATAL, 0, _("Max sched run time exceeded. Job canceled.\n")); cancel = true; } @@ -522,47 +578,84 @@ static void job_monitor_watchdog(watchdog_t *self) * Check if the maxwaittime has expired and it is possible * to cancel the job. */ -static bool job_check_maxwaittime(JCR *control_jcr, JCR *jcr) +static bool job_check_maxwaittime(JCR *jcr) { bool cancel = false; JOB *job = jcr->job; + utime_t current=0; - if (job_canceled(jcr)) { - return false; /* already canceled */ + if (!job_waiting(jcr)) { + return false; + } + + if (jcr->wait_time) { + current = watchdog_time - jcr->wait_time; + } + + Dmsg2(200, "check maxwaittime %u >= %u\n", + current + jcr->wait_time_sum, job->MaxWaitTime); + if (job->MaxWaitTime != 0 && + (current + jcr->wait_time_sum) >= job->MaxWaitTime) { + cancel = true; + } + + return cancel; +} + +/* + * Check if maxruntime has expired and if the job can be + * canceled. + */ +static bool job_check_maxruntime(JCR *jcr) +{ + bool cancel = false; + JOB *job = jcr->job; + utime_t run_time; + + if (job_canceled(jcr) || jcr->JobStatus == JS_Created) { + return false; } - if (job->MaxWaitTime == 0 && job->FullMaxWaitTime == 0 && - job->IncMaxWaitTime == 0 && job->DiffMaxWaitTime == 0) { + if (jcr->job->MaxRunTime == 0 && job->FullMaxRunTime == 0 && + job->IncMaxRunTime == 0 && job->DiffMaxRunTime == 0) { return false; - } - if (jcr->JobLevel == L_FULL && job->FullMaxWaitTime != 0 && - (watchdog_time - jcr->start_time) >= job->FullMaxWaitTime) { + } + run_time = watchdog_time - jcr->start_time; + Dmsg7(200, "check_maxruntime %llu-%u=%llu >= %llu|%llu|%llu|%llu\n", + watchdog_time, jcr->start_time, run_time, job->MaxRunTime, job->FullMaxRunTime, + job->IncMaxRunTime, job->DiffMaxRunTime); + + if (jcr->getJobLevel() == L_FULL && job->FullMaxRunTime != 0 && + run_time >= job->FullMaxRunTime) { + Dmsg0(200, "check_maxwaittime: FullMaxcancel\n"); cancel = true; - } else if (jcr->JobLevel == L_DIFFERENTIAL && job->DiffMaxWaitTime != 0 && - (watchdog_time - jcr->start_time) >= job->DiffMaxWaitTime) { + } else if (jcr->getJobLevel() == L_DIFFERENTIAL && job->DiffMaxRunTime != 0 && + run_time >= job->DiffMaxRunTime) { + Dmsg0(200, "check_maxwaittime: DiffMaxcancel\n"); cancel = true; - } else if (jcr->JobLevel == L_INCREMENTAL && job->IncMaxWaitTime != 0 && - (watchdog_time - jcr->start_time) >= job->IncMaxWaitTime) { + } else if (jcr->getJobLevel() == L_INCREMENTAL && job->IncMaxRunTime != 0 && + run_time >= job->IncMaxRunTime) { + Dmsg0(200, "check_maxwaittime: IncMaxcancel\n"); cancel = true; - } else if (job->MaxWaitTime != 0 && - (watchdog_time - jcr->start_time) >= job->MaxWaitTime) { + } else if (job->MaxRunTime > 0 && run_time >= job->MaxRunTime) { + Dmsg0(200, "check_maxwaittime: Maxcancel\n"); cancel = true; } - + return cancel; } /* - * Check if maxruntime has expired and if the job can be + * Check if MaxRunSchedTime has expired and if the job can be * canceled. */ -static bool job_check_maxruntime(JCR *control_jcr, JCR *jcr) +static bool job_check_maxschedruntime(JCR *jcr) { - if (jcr->job->MaxRunTime == 0 || job_canceled(jcr) || jcr->JobStatus == JS_Created) { + if (jcr->job->MaxRunSchedTime == 0 || job_canceled(jcr)) { return false; } - if ((watchdog_time - jcr->start_time) < jcr->job->MaxRunTime) { - Dmsg3(200, "Job %p (%s) with MaxRunTime %d not expired\n", - jcr, jcr->Job, jcr->job->MaxRunTime); + if ((watchdog_time - jcr->sched_time) < jcr->job->MaxRunSchedTime) { + Dmsg3(200, "Job %p (%s) with MaxRunSchedTime %d not expired\n", + jcr, jcr->Job, jcr->job->MaxRunSchedTime); return false; } @@ -585,28 +678,138 @@ DBId_t get_or_create_pool_record(JCR *jcr, char *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. %s"), pr.Name, + 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, _("Pool %s created in database.\n"), pr.Name); + Jmsg(jcr, M_INFO, 0, _("Created database record for Pool \"%s\".\n"), pr.Name); } } return pr.PoolId; } +/* + * 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 job */ + + if (job->AllowDuplicateJobs) { + return true; + } + Dmsg0(800, "Enter allow_duplicate_job\n"); + /* + * After this point, we do not want to allow any duplicate + * job to run. + */ + + foreach_jcr(djcr) { + if (jcr == djcr || djcr->JobId == 0) { + continue; /* do not cancel this job or consoles */ + } + if (strcmp(job->name(), djcr->job->name()) == 0) { + bool cancel_dup = false; + bool cancel_me = false; + if (job->DuplicateJobProximity > 0) { + utime_t now = (utime_t)time(NULL); + if ((now - djcr->start_time) > job->DuplicateJobProximity) { + continue; /* not really a duplicate */ + } + } + if (job->CancelLowerLevelDuplicates && + djcr->getJobType() == 'B' && jcr->getJobType() == 'B') { + switch (jcr->getJobLevel()) { + case L_FULL: + if (djcr->getJobLevel() == L_DIFFERENTIAL || + djcr->getJobLevel() == L_INCREMENTAL) { + cancel_dup = true; + } + break; + case L_DIFFERENTIAL: + if (djcr->getJobLevel() == L_INCREMENTAL) { + cancel_dup = true; + } + if (djcr->getJobLevel() == L_FULL) { + cancel_me = true; + } + break; + case L_INCREMENTAL: + if (djcr->getJobLevel() == L_FULL || + djcr->getJobLevel() == L_DIFFERENTIAL) { + cancel_me = true; + } + } + /* + * cancel_dup will be done below + */ + if (cancel_me) { + /* Zap current job */ + Jmsg(jcr, M_FATAL, 0, _("JobId %d already running. Duplicate job not allowed.\n"), + djcr->JobId); + break; /* get out of foreach_jcr */ + } + } + /* Cancel one of the two jobs (me or dup) */ + /* 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_dup = true; /* cancel queued duplicate */ + break; + default: + break; + } + } + if (cancel_dup || job->CancelRunningDuplicates) { + /* Zap the duplicated job djcr */ + UAContext *ua = new_ua_context(jcr); + Jmsg(jcr, M_INFO, 0, _("Cancelling duplicate JobId=%d.\n"), djcr->JobId); + cancel_job(ua, djcr); + bmicrosleep(0, 500000); + cancel_job(ua, djcr); + free_ua_context(ua); + Dmsg2(800, "Cancel dup %p JobId=%d\n", djcr, djcr->JobId); + } else { + /* Zap current job */ + Jmsg(jcr, M_FATAL, 0, _("JobId %d already running. Duplicate job not allowed.\n"), + djcr->JobId); + Dmsg2(800, "Cancel me %p JobId=%d\n", jcr, jcr->JobId); + } + Dmsg4(800, "curJobId=%d use_cnt=%d dupJobId=%d use_cnt=%d\n", + jcr->JobId, jcr->use_count(), djcr->JobId, djcr->use_count()); + break; /* did our work, get out of foreach loop */ + } + } + endeach_jcr(djcr); + + 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) { + switch (jcr->getJobLevel()) { 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 { @@ -617,6 +820,7 @@ void apply_pool_overrides(JCR *jcr) 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 { @@ -627,6 +831,7 @@ void apply_pool_overrides(JCR *jcr) 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 { @@ -635,6 +840,11 @@ void apply_pool_overrides(JCR *jcr) } break; } + /* Update catalog if pool overridden */ + if (pool_override && jcr->pool->catalog) { + jcr->catalog = jcr->pool->catalog; + pm_strcpy(jcr->catalog_source, _("Pool resource")); + } } @@ -713,8 +923,8 @@ void init_jcr_job_record(JCR *jcr) jcr->jr.SchedTime = jcr->sched_time; jcr->jr.StartTime = jcr->start_time; jcr->jr.EndTime = 0; /* perhaps rescheduled, clear it */ - jcr->jr.JobType = jcr->JobType; - jcr->jr.JobLevel = jcr->JobLevel; + jcr->jr.JobType = jcr->getJobType(); + jcr->jr.JobLevel = jcr->getJobLevel(); jcr->jr.JobStatus = jcr->JobStatus; jcr->jr.JobId = jcr->JobId; bstrncpy(jcr->jr.Name, jcr->job->name(), sizeof(jcr->jr.Name)); @@ -732,9 +942,11 @@ void update_job_end_record(JCR *jcr) jcr->jr.JobStatus = jcr->JobStatus; jcr->jr.JobFiles = jcr->JobFiles; jcr->jr.JobBytes = jcr->JobBytes; + jcr->jr.ReadBytes = jcr->ReadBytes; jcr->jr.VolSessionId = jcr->VolSessionId; jcr->jr.VolSessionTime = jcr->VolSessionTime; - jcr->jr.JobErrors = jcr->Errors; + jcr->jr.JobErrors = jcr->JobErrors; + jcr->jr.HasBase = jcr->HasBase; 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)); @@ -758,17 +970,17 @@ void create_unique_job_name(JCR *jcr, const char *base_name) static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; static time_t last_start_time = 0; static int seq = 0; - time_t now; + time_t now = time(NULL); struct tm tm; char dt[MAX_TIME_LENGTH]; char name[MAX_NAME_LENGTH]; char *p; + int len; /* Guarantee unique start time -- maximum one per second, and * thus unique Job Name */ P(mutex); /* lock creation of jobs */ - now = time(NULL); seq++; if (seq > 59) { /* wrap as if it is seconds */ seq = 0; @@ -783,29 +995,23 @@ void create_unique_job_name(JCR *jcr, const char *base_name) /* Form Unique JobName */ (void)localtime_r(&now, &tm); /* Use only characters that are permitted in Windows filenames */ - strftime(dt, sizeof(dt), "%Y-%m-%d_%H.%M", &tm); + strftime(dt, sizeof(dt), "%Y-%m-%d_%H.%M.%S", &tm); + len = strlen(dt) + 5; /* dt + .%02d EOS */ bstrncpy(name, base_name, sizeof(name)); - name[sizeof(name)-22] = 0; /* truncate if too long */ - bsnprintf(jcr->Job, sizeof(jcr->Job), "%s.%s.%02d", name, dt, seq); /* add date & time */ + name[sizeof(name)-len] = 0; /* truncate if too long */ + 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 == ' ') { *p = '_'; } } + Dmsg2(100, "JobId=%u created Job=%s\n", jcr->JobId, jcr->Job); } /* Called directly from job rescheduling */ void dird_free_jcr_pointers(JCR *jcr) { - if (jcr->sd_auth_key) { - free(jcr->sd_auth_key); - jcr->sd_auth_key = NULL; - } - if (jcr->where) { - free(jcr->where); - jcr->where = NULL; - } if (jcr->file_bsock) { Dmsg0(200, "Close File bsock\n"); bnet_close(jcr->file_bsock); @@ -816,27 +1022,16 @@ void dird_free_jcr_pointers(JCR *jcr) bnet_close(jcr->store_bsock); jcr->store_bsock = NULL; } - if (jcr->fname) { - Dmsg0(200, "Free JCR fname\n"); - free_pool_memory(jcr->fname); - jcr->fname = NULL; - } - if (jcr->RestoreBootstrap) { - free(jcr->RestoreBootstrap); - jcr->RestoreBootstrap = NULL; - } - if (jcr->client_uname) { - free_pool_memory(jcr->client_uname); - jcr->client_uname = NULL; - } - if (jcr->attr) { - free_pool_memory(jcr->attr); - jcr->attr = NULL; - } - if (jcr->ar) { - free(jcr->ar); - jcr->ar = NULL; - } + + bfree_and_null(jcr->sd_auth_key); + bfree_and_null(jcr->where); + bfree_and_null(jcr->RestoreBootstrap); + bfree_and_null(jcr->ar); + + free_and_null_pool_memory(jcr->JobIds); + free_and_null_pool_memory(jcr->client_uname); + free_and_null_pool_memory(jcr->attr); + free_and_null_pool_memory(jcr->fname); } /* @@ -853,40 +1048,23 @@ void dird_free_jcr(JCR *jcr) pthread_cond_destroy(&jcr->term_wait); jcr->term_wait_inited = false; } - if (jcr->db_batch && jcr->db_batch != jcr->db) { + if (jcr->db_batch) { db_close_database(jcr, jcr->db_batch); + jcr->db_batch = NULL; + jcr->batch_started = false; } - 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->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; - } + + free_and_null_pool_memory(jcr->stime); + free_and_null_pool_memory(jcr->fname); + free_and_null_pool_memory(jcr->pool_source); + free_and_null_pool_memory(jcr->catalog_source); + free_and_null_pool_memory(jcr->rpool_source); + free_and_null_pool_memory(jcr->wstore_source); + free_and_null_pool_memory(jcr->rstore_source); /* Delete lists setup to hold storage pointers */ free_rwstorage(jcr); @@ -896,6 +1074,8 @@ void dird_free_jcr(JCR *jcr) if (jcr->JobId != 0) write_state_file(director->working_directory, "bacula-dir", get_first_port_host_order(director->DIRaddrs)); + free_plugins(jcr); /* release instantiated plugins */ + Dmsg0(200, "End dird free_jcr\n"); } @@ -935,23 +1115,18 @@ void get_job_storage(USTORE *store, JOB *job, RUN *run) void set_jcr_defaults(JCR *jcr, JOB *job) { jcr->job = job; - jcr->JobType = job->JobType; + jcr->set_JobType(job->JobType); jcr->JobStatus = JS_Created; - switch (jcr->JobType) { + + switch (jcr->getJobType()) { case JT_ADMIN: - case JT_RESTORE: - jcr->JobLevel = L_NONE; + jcr->set_JobLevel(L_NONE); break; - 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; + jcr->set_JobLevel(job->JobLevel); break; } + if (!jcr->fname) { jcr->fname = get_pool_memory(PM_FNAME); } @@ -959,6 +1134,10 @@ void set_jcr_defaults(JCR *jcr, JOB *job) 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 */ @@ -977,7 +1156,13 @@ void set_jcr_defaults(JCR *jcr, JOB *job) jcr->full_pool = job->full_pool; jcr->inc_pool = job->inc_pool; jcr->diff_pool = job->diff_pool; - jcr->catalog = job->client->catalog; + 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; @@ -995,20 +1180,20 @@ void set_jcr_defaults(JCR *jcr, JOB *job) /* This can be overridden by Console program */ jcr->verify_job = job->verify_job; /* If no default level given, set one */ - if (jcr->JobLevel == 0) { - switch (jcr->JobType) { + if (jcr->getJobLevel() == 0) { + switch (jcr->getJobType()) { case JT_VERIFY: - jcr->JobLevel = L_VERIFY_CATALOG; + jcr->set_JobLevel(L_VERIFY_CATALOG); break; case JT_BACKUP: - jcr->JobLevel = L_INCREMENTAL; + jcr->set_JobLevel(L_INCREMENTAL); break; case JT_RESTORE: case JT_ADMIN: - jcr->JobLevel = L_NONE; + jcr->set_JobLevel(L_NONE); break; default: - jcr->JobLevel = L_FULL; + jcr->set_JobLevel(L_FULL); break; } } @@ -1019,16 +1204,10 @@ void set_jcr_defaults(JCR *jcr, JOB *job) */ void copy_rwstorage(JCR *jcr, alist *storage, const char *where) { - switch(jcr->JobType) { - case JT_RESTORE: - case JT_VERIFY: - case JT_MIGRATE: + if (jcr->JobReads()) { copy_rstorage(jcr, storage, where); - break; - default: - copy_wstorage(jcr, storage, where); - break; } + copy_wstorage(jcr, storage, where); } @@ -1039,16 +1218,10 @@ void set_rwstorage(JCR *jcr, USTORE *store) Jmsg(jcr, M_FATAL, 0, _("No storage specified.\n")); return; } - switch(jcr->JobType) { - case JT_RESTORE: - case JT_VERIFY: - case JT_MIGRATE: + if (jcr->JobReads()) { set_rstorage(jcr, store); - break; - default: - set_wstorage(jcr, store); - break; } + set_wstorage(jcr, store); } void free_rwstorage(JCR *jcr) @@ -1184,6 +1357,14 @@ void free_wstorage(JCR *jcr) jcr->wstore = NULL; } +char *job_code_callback_clones(JCR *jcr, const char* param) +{ + if (param[0] == 'p') { + return jcr->pool->name(); + } + return NULL; +} + void create_clones(JCR *jcr) { /* @@ -1197,13 +1378,14 @@ void create_clones(JCR *jcr) UAContext *ua = new_ua_context(jcr); ua->batch = true; foreach_alist(runcmd, job->run_cmds) { - cmd = edit_job_codes(jcr, cmd, runcmd, ""); + cmd = edit_job_codes(jcr, cmd, runcmd, "", job_code_callback_clones); 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")); + Jmsg(jcr, M_ERROR, 0, _("Could not start clone job: \"%s\".\n"), + ua->cmd); } else { Jmsg(jcr, M_INFO, 0, _("Clone JobId %d started.\n"), stat); } @@ -1213,40 +1395,60 @@ void create_clones(JCR *jcr) } } -bool create_restore_bootstrap_file(JCR *jcr) +/* + * Given: a JobId in jcr->previous_jr.JobId, + * this subroutine writes a bsr file to restore that job. + * Returns: -1 on error + * number of files if OK + */ +int create_restore_bootstrap_file(JCR *jcr) { RESTORE_CTX rx; UAContext *ua; + int files; + 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); + if (!complete_bsr(ua, rx.bsr)) { + files = -1; + goto bail_out; + } 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; + files = 0; + goto bail_out; } free_ua_context(ua); free_bsr(rx.bsr); jcr->needs_sd = true; - return true; + return jcr->ExpectedFiles; + +bail_out: + free_ua_context(ua); + free_bsr(rx.bsr); + return files; } -bool run_console_command(JCR *jcr, const char *cmd){ +/* TODO: redirect command ouput to job log */ +bool run_console_command(JCR *jcr, const char *cmd) +{ UAContext *ua; bool ok; - - ua = new_ua_context(jcr); + JCR *ljcr = new_control_jcr("-RunScript-", JT_CONSOLE); + ua = new_ua_context(ljcr); + /* run from runscript and check if commands are autorized */ + ua->runscript = true; 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); + free_jcr(ljcr); return ok; }