/*
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.
This program is Free Software; you can redistribute it and/or
- modify it under the terms of version two of the GNU General Public
+ modify it under the terms of version three of the GNU Affero General Public
License as published by the Free Software Foundation and included
in the file LICENSE.
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
+ You should have received a copy of the GNU Affero 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.
*
* Kern Sibbald, October MM
*
- * Version $Id$
*/
#include "bacula.h"
static void job_monitor_destructor(watchdog_t *self);
static bool job_check_maxwaittime(JCR *jcr);
static bool job_check_maxruntime(JCR *jcr);
-static bool job_check_maxschedruntime(JCR *jcr);
+static bool job_check_maxrunschedtime(JCR *jcr);
/* Imported subroutines */
extern void term_scheduler();
int errstat;
jcr->lock();
- sm_check(__FILE__, __LINE__, true);
+ Dsm_check(100);
init_msg(jcr, jcr->messages);
/* Initialize termination condition variable */
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();
/*
* Open database
*/
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);
+ jcr->db = db_init_database(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,
+ jcr->catalog->disable_batch_insert);
if (!jcr->db || !db_open_database(jcr, jcr->db)) {
Jmsg(jcr, M_FATAL, 0, _("Could not open database \"%s\".\n"),
jcr->catalog->db_name);
goto bail_out;
}
Dmsg0(150, "DB opened\n");
-
if (!jcr->fname) {
jcr->fname = get_pool_memory(PM_FNAME);
}
generate_daemon_event(jcr, "JobStart");
new_plugins(jcr); /* instantiate plugins for this jcr */
- generate_plugin_event(jcr, bEventJobStart);
+ generate_plugin_event(jcr, bDirEventJobStart);
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);
+ generate_plugin_event(jcr, bDirEventJobInit);
+ Dsm_check(100);
return true;
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);
}
JCR *jcr = (JCR *)arg;
pthread_detach(pthread_self());
- Dsm_check(1);
+ Dsm_check(100);
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);
- Jmsg(jcr, M_FATAL, 0, _("Job canceled because max sched run time exceeded.\n"));
+ if (job_check_maxrunschedtime(jcr)) {
+ jcr->setJobStatus(JS_Canceled);
+ Jmsg(jcr, M_FATAL, 0, _("Job canceled because max run sched time exceeded.\n"));
}
/* TODO : check if it is used somewhere */
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
generate_job_event(jcr, "JobRun");
- generate_plugin_event(jcr, bEventJobRun);
+ generate_plugin_event(jcr, bDirEventJobRun);
- switch (jcr->get_JobType()) {
+ switch (jcr->getJobType()) {
case JT_BACKUP:
if (!job_canceled(jcr) && do_backup(jcr)) {
do_autoprune(jcr);
}
break;
default:
- Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->get_JobType());
+ Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->getJobType());
break;
}
}
generate_daemon_event(jcr, "JobEnd");
- generate_plugin_event(jcr, bEventJobEnd);
+ generate_plugin_event(jcr, bDirEventJobEnd);
Dmsg1(50, "======== End Job stat=%c ==========\n", jcr->JobStatus);
- sm_check(__FILE__, __LINE__, true);
+ Dsm_check(100);
return NULL;
}
+void sd_msg_thread_send_signal(JCR *jcr, int sig)
+{
+ jcr->lock();
+ if ( !jcr->sd_msg_thread_done
+ && jcr->SD_msg_chan
+ && !pthread_equal(jcr->SD_msg_chan, pthread_self()))
+ {
+ Dmsg1(800, "Send kill to SD msg chan jid=%d\n", jcr->JobId);
+ pthread_kill(jcr->SD_msg_chan, sig);
+ }
+ jcr->unlock();
+}
/*
* Cancel a job -- typically called by the UA (Console program), but may also
char ed1[50];
int32_t old_status = jcr->JobStatus;
- set_jcr_job_status(jcr, JS_Canceled);
+ jcr->setJobStatus(JS_Canceled);
switch (old_status) {
case JS_Created:
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();
+ jcr->my_thread_send_signal(TIMEOUT_SIGNAL);
}
/* 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();
+ sd_msg_thread_send_signal(jcr, TIMEOUT_SIGNAL);
+ jcr->my_thread_send_signal(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();
+ sd_msg_thread_send_signal(jcr, TIMEOUT_SIGNAL);
+ jcr->my_thread_send_signal(TIMEOUT_SIGNAL);
}
bail_out:
free_jcr(control_jcr);
control_jcr = (JCR *)self->data;
- Dsm_check(1);
+ Dsm_check(100);
Dmsg1(800, "job_monitor_watchdog %p called\n", 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(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);
- Qmsg(jcr, M_FATAL, 0, _("Max sched run time exceeded. Job canceled.\n"));
+ } else if (job_check_maxrunschedtime(jcr)) {
+ jcr->setJobStatus(JS_Canceled);
+ Qmsg(jcr, M_FATAL, 0, _("Max run sched time exceeded. Job canceled.\n"));
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;
}
* Check if MaxRunSchedTime has expired and if the job can be
* canceled.
*/
-static bool job_check_maxschedruntime(JCR *jcr)
+static bool job_check_maxrunschedtime(JCR *jcr)
{
- if (jcr->job->MaxRunSchedTime == 0 || job_canceled(jcr)) {
+ if (jcr->MaxRunSchedTime == 0 || job_canceled(jcr)) {
return false;
}
- if ((watchdog_time - jcr->sched_time) < jcr->job->MaxRunSchedTime) {
+ if ((watchdog_time - jcr->sched_time) < jcr->MaxRunSchedTime) {
Dmsg3(200, "Job %p (%s) with MaxRunSchedTime %d not expired\n",
- jcr, jcr->Job, jcr->job->MaxRunSchedTime);
+ jcr, jcr->Job, jcr->MaxRunSchedTime);
return false;
}
bool allow_duplicate_job(JCR *jcr)
{
JOB *job = jcr->job;
- JCR *djcr; /* possible duplicate */
+ JCR *djcr; /* possible duplicate job */
+ bool cancel_dup = false;
+ bool cancel_me = false;
- if (job->AllowDuplicateJobs) {
+ /*
+ * See if AllowDuplicateJobs is set or
+ * if duplicate checking is disabled for this job.
+ */
+ if (job->AllowDuplicateJobs || jcr->IgnoreDuplicateJobChecking) {
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) {
- utime_t now = (utime_t)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 */
+ }
+
+ /*
+ * See if this Job has the IgnoreDuplicateJobChecking flag set, ignore it
+ * for any checking against other jobs.
+ */
+ if (djcr->IgnoreDuplicateJobChecking) {
+ continue;
+ }
+
+ if (strcmp(job->name(), djcr->job->name()) == 0) {
+ 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);
}
+ 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));
len = strlen(dt) + 5; /* dt + .%02d EOS */
bstrncpy(name, base_name, sizeof(name));
name[sizeof(name)-len] = 0; /* truncate if too long */
- bsnprintf(jcr->Job, sizeof(jcr->Job), "%s.%s.%02d", name, dt, seq); /* 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 == ' ') {
/* 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);
}
/*
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);
void set_jcr_defaults(JCR *jcr, JOB *job)
{
jcr->job = job;
- jcr->set_JobType(job->JobType);
+ jcr->setJobType(job->JobType);
jcr->JobStatus = JS_Created;
- switch (jcr->get_JobType()) {
+ switch (jcr->getJobType()) {
case JT_ADMIN:
- jcr->set_JobLevel(L_NONE);
+ jcr->setJobLevel(L_NONE);
break;
default:
- jcr->set_JobLevel(job->JobLevel);
+ jcr->setJobLevel(job->JobLevel);
break;
}
pm_strcpy(jcr->catalog_source, _("Client resource"));
}
jcr->fileset = job->fileset;
+ jcr->accurate = job->accurate;
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;
+ jcr->IgnoreDuplicateJobChecking = job->IgnoreDuplicateJobChecking;
+ jcr->MaxRunSchedTime = job->MaxRunSchedTime;
if (jcr->RestoreBootstrap) {
free(jcr->RestoreBootstrap);
jcr->RestoreBootstrap = NULL;
/* 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);
+ jcr->setJobLevel(L_VERIFY_CATALOG);
break;
case JT_BACKUP:
- jcr->set_JobLevel(L_INCREMENTAL);
+ jcr->setJobLevel(L_INCREMENTAL);
break;
case JT_RESTORE:
case JT_ADMIN:
- jcr->set_JobLevel(L_NONE);
+ jcr->setJobLevel(L_NONE);
break;
default:
- jcr->set_JobLevel(L_FULL);
+ jcr->setJobLevel(L_FULL);
break;
}
}
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)
{
/*
UAContext *ua = new_ua_context(jcr);
ua->batch = true;
foreach_alist(runcmd, job->run_cmds) {
- cmd = edit_job_codes(jcr, cmd, runcmd, "", job_code_callback_clones);
+ cmd = edit_job_codes(jcr, cmd, runcmd, "", job_code_callback_director);
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);
}
/*
* 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);
if (!complete_bsr(ua, rx.bsr)) {
+ files = -1;
goto bail_out;
}
rx.bsr->fi = new_findex();
rx.bsr->fi->findex2 = jcr->previous_jr.JobFiles;
jcr->ExpectedFiles = write_bsr_file(ua, rx);
if (jcr->ExpectedFiles == 0) {
+ 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 false;
+ return files;
}
/* TODO: redirect command ouput to job log */
-bool run_console_command(JCR *jcr, const char *cmd){
+bool run_console_command(JCR *jcr, const char *cmd)
+{
UAContext *ua;
bool ok;
JCR *ljcr = new_control_jcr("-RunScript-", JT_CONSOLE);