/*
Bacula® - The Network Backup Solution
- Copyright (C) 2000-2009 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 */
* 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->comment) {
- jcr->comment = get_pool_memory(PM_MESSAGE);
- *jcr->comment = '\0';
- }
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;
}
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:
JCR *jcr = (JCR *)arg;
pthread_detach(pthread_self());
- Dsm_check(1);
+ Dsm_check(100);
Dmsg0(200, "=====Start Job=========\n");
jcr->setJobStatus(JS_Running); /* this will be set only if no error */
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n"));
}
- if (job_check_maxschedruntime(jcr)) {
+ if (job_check_maxrunschedtime(jcr)) {
jcr->setJobStatus(JS_Canceled);
- Jmsg(jcr, M_FATAL, 0, _("Job canceled because max sched run time exceeded.\n"));
+ 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->getJobType()) {
case JT_BACKUP:
}
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
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;
}
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) {
Qmsg(jcr, M_FATAL, 0, _("Max run time exceeded. Job canceled.\n"));
cancel = true;
/* check MaxRunSchedTime */
- } else if (job_check_maxschedruntime(jcr)) {
+ } else if (job_check_maxrunschedtime(jcr)) {
jcr->setJobStatus(JS_Canceled);
- Qmsg(jcr, M_FATAL, 0, _("Max sched run time exceeded. Job canceled.\n"));
+ Qmsg(jcr, M_FATAL, 0, _("Max run sched time exceeded. Job canceled.\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) {
- if (jcr == djcr || djcr->JobId == 0) {
- continue; /* do not cancel this job or consoles */
+
+ 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 (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 */
+ 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 */
- /* 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);
- Jmsg(jcr, M_INFO, 0, _("Cancelling duplicate JobId=%d.\n"), djcr->JobId);
- ua->jcr = djcr;
- cancel_job(ua, djcr);
- free_ua_context(ua);
- Dmsg2(800, "Have cancelled JCR %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);
+ /*
+ * 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 */
}
- break; /* did our work, get out */
}
+
+ /*
+ * 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;
}
/* 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->comment) {
- free_pool_memory(jcr->comment);
- jcr->comment = 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->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;
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 */