X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fdird%2Fjob.c;h=768b6cf1cfe34924ffca573c9ec4b50c18fd29ce;hb=b7d55c258d091d7be881e0fb413c10accd1dd5d6;hp=bd3b8df48da997d77be877af469702e272cc85e3;hpb=0ca08a92931dc6677546cbc9026bd6eac6bafea1;p=bacula%2Fbacula

diff --git a/bacula/src/dird/job.c b/bacula/src/dird/job.c
index bd3b8df48d..768b6cf1cf 100644
--- a/bacula/src/dird/job.c
+++ b/bacula/src/dird/job.c
@@ -1,12 +1,12 @@
 /*
    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.
 
@@ -15,7 +15,7 @@
    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.
@@ -31,7 +31,6 @@
  *
  *     Kern Sibbald, October MM
  *
- *    Version $Id$
  */
 
 #include "bacula.h"
@@ -43,7 +42,7 @@ static void job_monitor_watchdog(watchdog_t *self);
 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();
@@ -105,7 +104,7 @@ bool setup_job(JCR *jcr)
    int errstat;
 
    jcr->lock();
-   sm_check(__FILE__, __LINE__, true);
+   Dsm_check(100);
    init_msg(jcr, jcr->messages);
 
    /* Initialize termination condition variable */
@@ -118,18 +117,18 @@ bool setup_job(JCR *jcr)
    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);
@@ -140,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);
    }
@@ -174,7 +172,7 @@ bool setup_job(JCR *jcr)
 
    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;
@@ -196,7 +194,7 @@ bool setup_job(JCR *jcr)
     *  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);
@@ -229,14 +227,14 @@ bool setup_job(JCR *jcr)
       }
       break;
    default:
-      Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->get_JobType());
-      set_jcr_job_status(jcr, JS_ErrorTerminated);
+      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:
@@ -246,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);
 }
 
@@ -261,22 +259,22 @@ static void *job_thread(void *arg)
    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 */
@@ -308,9 +306,9 @@ static void *job_thread(void *arg)
       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);
@@ -348,7 +346,7 @@ static void *job_thread(void *arg)
       }
       break;
    default:
-      Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->get_JobType());
+      Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->getJobType());
       break;
    }
 
@@ -360,12 +358,24 @@ static void *job_thread(void *arg)
    }
 
    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
@@ -380,7 +390,7 @@ bool cancel_job(UAContext *ua, JCR *jcr)
    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:
@@ -393,7 +403,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 */
@@ -412,6 +422,8 @@ bool cancel_job(UAContext *ua, JCR *jcr)
          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 */
@@ -445,7 +457,12 @@ 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();
+         sd_msg_thread_send_signal(jcr, TIMEOUT_SIGNAL);
+         jcr->my_thread_send_signal(TIMEOUT_SIGNAL);
       }
+      break;
    }
 
    return true;
@@ -453,6 +470,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;
@@ -486,6 +507,11 @@ 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();
+      sd_msg_thread_send_signal(jcr, TIMEOUT_SIGNAL);
+      jcr->my_thread_send_signal(TIMEOUT_SIGNAL);
    }
 bail_out:
    free_jcr(control_jcr);
@@ -505,7 +531,7 @@ static void job_monitor_watchdog(watchdog_t *self)
 
    control_jcr = (JCR *)self->data;
 
-   Dsm_check(1);
+   Dsm_check(100);
    Dmsg1(800, "job_monitor_watchdog %p called\n", self);
 
    foreach_jcr(jcr) {
@@ -518,18 +544,18 @@ static void job_monitor_watchdog(watchdog_t *self)
 
       /* 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;
       }
 
@@ -597,15 +623,15 @@ static bool job_check_maxruntime(JCR *jcr)
          watchdog_time, jcr->start_time, run_time, job->MaxRunTime, job->FullMaxRunTime, 
          job->IncMaxRunTime, job->DiffMaxRunTime);
 
-   if (jcr->get_JobLevel() == L_FULL && job->FullMaxRunTime != 0 &&
+   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 &&
+   } 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 &&
+   } else if (jcr->getJobLevel() == L_INCREMENTAL && job->IncMaxRunTime != 0 &&
          run_time >= job->IncMaxRunTime) {
       Dmsg0(200, "check_maxwaittime: IncMaxcancel\n");
       cancel = true;
@@ -621,14 +647,14 @@ static bool job_check_maxruntime(JCR *jcr)
  * 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;
    }
 
@@ -669,58 +695,125 @@ DBId_t get_or_create_pool_record(JCR *jcr, char *pool_name)
 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;   
 }
 
@@ -734,7 +827,7 @@ void apply_pool_overrides(JCR *jcr)
    /*
     * 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;
@@ -852,8 +945,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->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));
@@ -941,14 +1034,6 @@ void create_unique_job_name(JCR *jcr, const char *base_name)
 /* 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);
@@ -959,27 +1044,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);
 }
 
 /*
@@ -1005,36 +1079,14 @@ void dird_free_jcr(JCR *jcr)
       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);
@@ -1085,15 +1137,15 @@ void get_job_storage(USTORE *store, JOB *job, RUN *run)
 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;
    }
 
@@ -1134,11 +1186,13 @@ void set_jcr_defaults(JCR *jcr, JOB *job)
       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;
@@ -1150,20 +1204,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->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;
       }
    }
@@ -1327,14 +1381,6 @@ 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)
 {
    /*
@@ -1348,7 +1394,7 @@ 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 */