X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fdird%2Fjob.c;h=48556976e74f34e007532d6dbb409f4838ac3274;hb=e1e7c2aaef15193daad550d12c2ca4c65e76778c;hp=209d3d6fca0b5d286380b9a59e7cbe579c85a309;hpb=df52881557e0f6ae6f3db898c7ccf1e4ab87d65d;p=bacula%2Fbacula

diff --git a/bacula/src/dird/job.c b/bacula/src/dird/job.c
index 209d3d6fca..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.
@@ -31,7 +31,6 @@
  *
  *     Kern Sibbald, October MM
  *
- *    Version $Id$
  */
 
 #include "bacula.h"
@@ -118,7 +117,7 @@ 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();
 
    /*
@@ -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);
    }
@@ -148,9 +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);
-   /* ****FIXME**** */
-   if (jcr->JobType == JT_MIGRATE || jcr->JobType == JT_COPY) {
+
+   if (jcr->JobReads()) {
       if (!jcr->rpool_source) {
          jcr->rpool_source = get_pool_memory(PM_MESSAGE);
          pm_strcpy(jcr->rpool_source, _("unknown source"));
@@ -174,50 +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;
 
@@ -228,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);
 }
 
@@ -246,18 +262,18 @@ 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)) {
-      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"));
    }
 
@@ -274,68 +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_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->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");
@@ -346,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;
@@ -363,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:
@@ -377,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 */
@@ -389,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 */
@@ -429,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;
@@ -437,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;
@@ -470,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);
@@ -495,24 +538,24 @@ 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(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;
       }
@@ -539,13 +582,20 @@ static bool job_check_maxwaittime(JCR *jcr)
 {
    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;
    }
 
@@ -560,6 +610,7 @@ 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;
@@ -568,20 +619,25 @@ static bool job_check_maxruntime(JCR *jcr)
        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->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->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->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;
    }
  
@@ -640,57 +696,102 @@ 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 */
 
    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;   
 }
 
@@ -704,7 +805,7 @@ void apply_pool_overrides(JCR *jcr)
    /*
     * Apply any level related Pool selections
     */
-   switch (jcr->JobLevel) {
+   switch (jcr->getJobLevel()) {
    case L_FULL:
       if (jcr->full_pool) {
          jcr->pool = jcr->full_pool;
@@ -822,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));
@@ -841,10 +942,12 @@ 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;
-   if (!db_update_job_end_record(jcr, jcr->db, &jcr->jr, jcr->job->stats_enabled)) {
+   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));
    }
@@ -867,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;
@@ -892,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);
@@ -925,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);
 }
 
 /*
@@ -962,44 +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->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);
@@ -1009,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");
 }
 
@@ -1048,35 +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:
-      jcr->JobLevel = L_NONE;
-      break;
-   case JT_VERIFY:
-   case JT_RESTORE:
-   case JT_COPY:
-   case JT_MIGRATE:
-      jcr->JobReads = true;
-      jcr->JobLevel = job->JobLevel;
-      break;
-   case JT_BACKUP:
-      jcr->JobLevel = job->JobLevel;
-      if (jcr->JobLevel == L_VIRTUAL_FULL) {
-         jcr->JobReads = true;
-      }
+      jcr->set_JobLevel(L_NONE);
       break;
    default:
-      jcr->JobLevel = job->JobLevel;
+      jcr->set_JobLevel(job->JobLevel);
       break;
    }
-   if (jcr->JobReads) {
-      if (!jcr->rpool_source) {
-         jcr->rpool_source = get_pool_memory(PM_MESSAGE);
-         pm_strcpy(jcr->rpool_source, _("unknown source"));
-      }
-   }
+
    if (!jcr->fname) {
       jcr->fname = get_pool_memory(PM_FNAME);
    }
@@ -1130,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;
       }
    }
@@ -1154,7 +1204,7 @@ void set_jcr_defaults(JCR *jcr, JOB *job)
  */
 void copy_rwstorage(JCR *jcr, alist *storage, const char *where)
 {
-   if (jcr->JobReads) {
+   if (jcr->JobReads()) {
       copy_rstorage(jcr, storage, where);
    }
    copy_wstorage(jcr, storage, where);
@@ -1168,7 +1218,7 @@ void set_rwstorage(JCR *jcr, USTORE *store)
       Jmsg(jcr, M_FATAL, 0, _("No storage specified.\n"));
       return;
    }
-   if (jcr->JobReads) {
+   if (jcr->JobReads()) {
       set_rstorage(jcr, store);
    }
    set_wstorage(jcr, store);
@@ -1334,7 +1384,8 @@ void create_clones(JCR *jcr)
          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);
          }
@@ -1347,41 +1398,57 @@ void create_clones(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
  */
-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;
 }