/*
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.
*
* Kern Sibbald, October MM
*
- * Version $Id$
*/
#include "bacula.h"
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();
/*
goto bail_out;
}
Dmsg0(150, "DB opened\n");
-
if (!jcr->fname) {
jcr->fname = get_pool_memory(PM_FNAME);
}
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;
* this allows us to setup a proper job start record for restarting
* in case of later errors.
*/
- switch (jcr->get_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->get_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;
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);
}
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)) {
- set_jcr_job_status(jcr, JS_Canceled);
+ jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max sched run time exceeded.\n"));
}
/* 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->get_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_COPY:
- case JT_MIGRATE:
- if (do_migration(jcr)) {
- do_autoprune(jcr);
- } else {
- migration_cleanup(jcr, JS_ErrorTerminated);
- }
- break;
- default:
- Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->get_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");
}
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;
{
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:
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 */
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 */
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;
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;
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);
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(jcr)) {
- set_jcr_job_status(jcr, JS_Canceled);
+ 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(jcr)) {
- set_jcr_job_status(jcr, JS_Canceled);
+ 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)) {
- set_jcr_job_status(jcr, JS_Canceled);
+ jcr->setJobStatus(JS_Canceled);
Qmsg(jcr, M_FATAL, 0, _("Max sched run time exceeded. Job canceled.\n"));
cancel = true;
}
{
bool cancel = false;
JOB *job = jcr->job;
+ utime_t current=0;
if (!job_waiting(jcr)) {
return false;
}
- Dmsg3(200, "check maxwaittime %u - %u >= %u\n", watchdog_time, jcr->wait_time, job->MaxWaitTime);
+
+ 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 &&
- (watchdog_time - jcr->wait_time) >= job->MaxWaitTime) {
+ (current + jcr->wait_time_sum) >= job->MaxWaitTime) {
cancel = true;
}
{
bool cancel = false;
JOB *job = jcr->job;
+ utime_t run_time;
if (job_canceled(jcr) || jcr->JobStatus == JS_Created) {
return false;
job->IncMaxRunTime == 0 && job->DiffMaxRunTime == 0) {
return false;
}
- Dmsg6(200, "check_maxruntime %u - %u >= %u|%u|%u|%u\n\n",
- watchdog_time, jcr->start_time, job->MaxRunTime, job->FullMaxRunTime,
+ 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->get_JobLevel() == L_FULL && job->FullMaxRunTime != 0 &&
- (watchdog_time - jcr->start_time) >= job->FullMaxRunTime) {
+ if (jcr->getJobLevel() == L_FULL && job->FullMaxRunTime != 0 &&
+ run_time >= job->FullMaxRunTime) {
+ Dmsg0(200, "check_maxwaittime: FullMaxcancel\n");
cancel = true;
- } else if (jcr->get_JobLevel() == L_DIFFERENTIAL && job->DiffMaxRunTime != 0 &&
- (watchdog_time - jcr->start_time) >= job->DiffMaxRunTime) {
+ } else if (jcr->getJobLevel() == L_DIFFERENTIAL && job->DiffMaxRunTime != 0 &&
+ run_time >= job->DiffMaxRunTime) {
+ Dmsg0(200, "check_maxwaittime: DiffMaxcancel\n");
cancel = true;
- } else if (jcr->get_JobLevel() == L_INCREMENTAL && job->IncMaxRunTime != 0 &&
- (watchdog_time - jcr->start_time) >= job->IncMaxRunTime) {
+ } else if (jcr->getJobLevel() == L_INCREMENTAL && job->IncMaxRunTime != 0 &&
+ run_time >= job->IncMaxRunTime) {
+ Dmsg0(200, "check_maxwaittime: IncMaxcancel\n");
cancel = true;
- } else if ((watchdog_time - jcr->start_time) >= job->MaxRunTime) {
+ } else if (job->MaxRunTime > 0 && run_time >= job->MaxRunTime) {
+ Dmsg0(200, "check_maxwaittime: Maxcancel\n");
cancel = true;
}
bool allow_duplicate_job(JCR *jcr)
{
JOB *job = jcr->job;
- JCR *djcr; /* possible duplicate */
+ JCR *djcr; /* possible duplicate job */
if (job->AllowDuplicateJobs) {
return true;
}
- if (!job->AllowHigherDuplicates) {
- foreach_jcr(djcr) {
- char ec1[50];
- 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. JobId=%s\n"),
- edit_uint64(djcr->JobId, ec1));
- return false;
+ 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 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 (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;
+ }
}
- if (cancel_queued || job->CancelRunningDuplicates) {
- UAContext *ua = new_ua_context(djcr);
- 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);
+ /*
+ * 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;
}
/*
* Apply any level related Pool selections
*/
- switch (jcr->get_JobLevel()) {
+ switch (jcr->getJobLevel()) {
case L_FULL:
if (jcr->full_pool) {
jcr->pool = jcr->full_pool;
jcr->jr.SchedTime = jcr->sched_time;
jcr->jr.StartTime = jcr->start_time;
jcr->jr.EndTime = 0; /* perhaps rescheduled, clear it */
- jcr->jr.JobType = jcr->get_JobType();
- jcr->jr.JobLevel = jcr->get_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));
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));
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;
/* 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);
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);
}
/*
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->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;
- }
+
+ 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);
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");
}
jcr->set_JobType(job->JobType);
jcr->JobStatus = JS_Created;
- switch (jcr->get_JobType()) {
+ switch (jcr->getJobType()) {
case JT_ADMIN:
jcr->set_JobLevel(L_NONE);
break;
/* This can be overridden by Console program */
jcr->verify_job = job->verify_job;
/* If no default level given, set one */
- if (jcr->get_JobLevel() == 0) {
- switch (jcr->get_JobType()) {
+ if (jcr->getJobLevel() == 0) {
+ switch (jcr->getJobType()) {
case JT_VERIFY:
jcr->set_JobLevel(L_VERIFY_CATALOG);
break;
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);
}
/*
* 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
*/
-bool create_restore_bootstrap_file(JCR *jcr)
+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;
}