git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/job.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *
  30  *   Bacula Director Job processing routines
  31  *
  32  *     Kern Sibbald, October MM
  33  *
  34  *    Version $Id$
  35  */
  36
  37 #include "bacula.h"
  38 #include "dird.h"
  39
  40 /* Forward referenced subroutines */
  41 static void *job_thread(void *arg);
  42 static void job_monitor_watchdog(watchdog_t *self);
  43 static void job_monitor_destructor(watchdog_t *self);
  44 static bool job_check_maxwaittime(JCR *jcr);
  45 static bool job_check_maxruntime(JCR *jcr);
  46 static bool job_check_maxschedruntime(JCR *jcr);
  47
  48 /* Imported subroutines */
  49 extern void term_scheduler();
  50 extern void term_ua_server();
  51
  52 /* Imported variables */
  53
  54 jobq_t job_queue;
  55
  56 void init_job_server(int max_workers)
  57 {
  58    int stat;
  59    watchdog_t *wd;
  60
  61    if ((stat = jobq_init(&job_queue, max_workers, job_thread)) != 0) {
  62       berrno be;
  63       Emsg1(M_ABORT, 0, _("Could not init job queue: ERR=%s\n"), be.bstrerror(stat));
  64    }
  65    wd = new_watchdog();
  66    wd->callback = job_monitor_watchdog;
  67    wd->destructor = job_monitor_destructor;
  68    wd->one_shot = false;
  69    wd->interval = 60;
  70    wd->data = new_control_jcr("*JobMonitor*", JT_SYSTEM);
  71    register_watchdog(wd);
  72 }
  73
  74 void term_job_server()
  75 {
  76    jobq_destroy(&job_queue);          /* ignore any errors */
  77 }
  78
  79 /*
  80  * Run a job -- typically called by the scheduler, but may also
  81  *              be called by the UA (Console program).
  82  *
  83  *  Returns: 0 on failure
  84  *           JobId on success
  85  *
  86  */
  87 JobId_t run_job(JCR *jcr)
  88 {
  89    int stat;
  90    if (setup_job(jcr)) {
  91       Dmsg0(200, "Add jrc to work queue\n");
  92       /* Queue the job to be run */
  93       if ((stat = jobq_add(&job_queue, jcr)) != 0) {
  94          berrno be;
  95          Jmsg(jcr, M_FATAL, 0, _("Could not add job queue: ERR=%s\n"), be.bstrerror(stat));
  96          return 0;
  97       }
  98       return jcr->JobId;
  99    }
 100    return 0;
 101 }
 102
 103 bool setup_job(JCR *jcr)
 104 {
 105    int errstat;
 106
 107    jcr->lock();
 108    sm_check(__FILE__, __LINE__, true);
 109    init_msg(jcr, jcr->messages);
 110
 111    /* Initialize termination condition variable */
 112    if ((errstat = pthread_cond_init(&jcr->term_wait, NULL)) != 0) {
 113       berrno be;
 114       Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
 115       jcr->unlock();
 116       goto bail_out;
 117    }
 118    jcr->term_wait_inited = true;
 119
 120    create_unique_job_name(jcr, jcr->job->name());
 121    set_jcr_job_status(jcr, JS_Created);
 122    jcr->unlock();
 123
 124    /*
 125     * Open database
 126     */
 127    Dmsg0(100, "Open database\n");
 128    jcr->db=db_init(jcr, jcr->catalog->db_driver, jcr->catalog->db_name,
 129                    jcr->catalog->db_user,
 130                    jcr->catalog->db_password, jcr->catalog->db_address,
 131                    jcr->catalog->db_port, jcr->catalog->db_socket,
 132                    jcr->catalog->mult_db_connections);
 133    if (!jcr->db || !db_open_database(jcr, jcr->db)) {
 134       Jmsg(jcr, M_FATAL, 0, _("Could not open database \"%s\".\n"),
 135                  jcr->catalog->db_name);
 136       if (jcr->db) {
 137          Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 138          db_close_database(jcr, jcr->db);
 139       }
 140       goto bail_out;
 141    }
 142    Dmsg0(150, "DB opened\n");
 143
 144    if (!jcr->fname) {
 145       jcr->fname = get_pool_memory(PM_FNAME);
 146    }
 147    if (!jcr->pool_source) {
 148       jcr->pool_source = get_pool_memory(PM_MESSAGE);
 149       pm_strcpy(jcr->pool_source, _("unknown source"));
 150    }
 151
 152    if (jcr->JobReads()) {
 153       if (!jcr->rpool_source) {
 154          jcr->rpool_source = get_pool_memory(PM_MESSAGE);
 155          pm_strcpy(jcr->rpool_source, _("unknown source"));
 156       }
 157    }
 158
 159    /*
 160     * Create Job record
 161     */
 162    init_jcr_job_record(jcr);
 163    if (!get_or_create_client_record(jcr)) {
 164       goto bail_out;
 165    }
 166
 167    if (!db_create_job_record(jcr, jcr->db, &jcr->jr)) {
 168       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 169       goto bail_out;
 170    }
 171    jcr->JobId = jcr->jr.JobId;
 172    Dmsg4(100, "Created job record JobId=%d Name=%s Type=%c Level=%c\n",
 173        jcr->JobId, jcr->Job, jcr->jr.JobType, jcr->jr.JobLevel);
 174
 175    generate_daemon_event(jcr, "JobStart");
 176
 177    if (job_canceled(jcr)) {
 178       goto bail_out;
 179    }
 180
 181    if (jcr->JobReads() && !jcr->rstorage) {
 182       if (jcr->job->storage) {
 183          copy_rwstorage(jcr, jcr->job->storage, _("Job resource"));
 184       } else {
 185          copy_rwstorage(jcr, jcr->job->pool->storage, _("Pool resource"));
 186       }
 187    }
 188    if (!jcr->JobReads()) {
 189       free_rstorage(jcr);
 190    }
 191
 192    /*
 193     * Now, do pre-run stuff, like setting job level (Inc/diff, ...)
 194     *  this allows us to setup a proper job start record for restarting
 195     *  in case of later errors.
 196     */
 197    switch (jcr->get_JobType()) {
 198    case JT_BACKUP:
 199       if (!do_backup_init(jcr)) {
 200          backup_cleanup(jcr, JS_ErrorTerminated);
 201       }
 202       break;
 203    case JT_VERIFY:
 204       if (!do_verify_init(jcr)) {
 205          verify_cleanup(jcr, JS_ErrorTerminated);
 206       }
 207       break;
 208    case JT_RESTORE:
 209       if (!do_restore_init(jcr)) {
 210          restore_cleanup(jcr, JS_ErrorTerminated);
 211       }
 212       break;
 213    case JT_ADMIN:
 214       if (!do_admin_init(jcr)) {
 215          admin_cleanup(jcr, JS_ErrorTerminated);
 216       }
 217       break;
 218    case JT_COPY:
 219    case JT_MIGRATE:
 220       if (!do_migration_init(jcr)) {
 221          migration_cleanup(jcr, JS_ErrorTerminated);
 222       }
 223       break;
 224    default:
 225       Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->get_JobType());
 226       set_jcr_job_status(jcr, JS_ErrorTerminated);
 227       break;
 228    }
 229
 230    generate_job_event(jcr, "JobInit");
 231    Dsm_check(1);
 232    return true;
 233
 234 bail_out:
 235    return false;
 236 }
 237
 238 void update_job_end(JCR *jcr, int TermCode)
 239 {
 240    dequeue_messages(jcr);             /* display any queued messages */
 241    set_jcr_job_status(jcr, TermCode);
 242    update_job_end_record(jcr);
 243 }
 244
 245 /*
 246  * This is the engine called by jobq.c:jobq_add() when we were pulled
 247  *  from the work queue.
 248  *  At this point, we are running in our own thread and all
 249  *    necessary resources are allocated -- see jobq.c
 250  */
 251 static void *job_thread(void *arg)
 252 {
 253    JCR *jcr = (JCR *)arg;
 254
 255    pthread_detach(pthread_self());
 256    Dsm_check(1);
 257
 258    Dmsg0(200, "=====Start Job=========\n");
 259    set_jcr_job_status(jcr, JS_Running);   /* this will be set only if no error */
 260    jcr->start_time = time(NULL);      /* set the real start time */
 261    jcr->jr.StartTime = jcr->start_time;
 262
 263    if (jcr->job->MaxStartDelay != 0 && jcr->job->MaxStartDelay <
 264        (utime_t)(jcr->start_time - jcr->sched_time)) {
 265       set_jcr_job_status(jcr, JS_Canceled);
 266       Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n"));
 267    }
 268
 269    if (job_check_maxschedruntime(jcr)) {
 270       set_jcr_job_status(jcr, JS_Canceled);
 271       Jmsg(jcr, M_FATAL, 0, _("Job canceled because max sched run time exceeded.\n"));
 272    }
 273
 274    /* TODO : check if it is used somewhere */
 275    if (jcr->job->RunScripts == NULL) {
 276       Dmsg0(200, "Warning, job->RunScripts is empty\n");
 277       jcr->job->RunScripts = New(alist(10, not_owned_by_alist));
 278    }
 279
 280    if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
 281       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 282    }
 283
 284    /* Run any script BeforeJob on dird */
 285    run_scripts(jcr, jcr->job->RunScripts, "BeforeJob");
 286
 287    /*
 288     * We re-update the job start record so that the start
 289     *  time is set after the run before job.  This avoids
 290     *  that any files created by the run before job will
 291     *  be saved twice.  They will be backed up in the current
 292     *  job, but not in the next one unless they are changed.
 293     *  Without this, they will be backed up in this job and
 294     *  in the next job run because in that case, their date
 295     *   is after the start of this run.
 296     */
 297    jcr->start_time = time(NULL);
 298    jcr->jr.StartTime = jcr->start_time;
 299    if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
 300       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 301    }
 302    generate_job_event(jcr, "JobRun");
 303
 304    switch (jcr->get_JobType()) {
 305    case JT_BACKUP:
 306       if (!job_canceled(jcr) && do_backup(jcr)) {
 307          do_autoprune(jcr);
 308       } else {
 309          backup_cleanup(jcr, JS_ErrorTerminated);
 310       }
 311       break;
 312    case JT_VERIFY:
 313       if (!job_canceled(jcr) && do_verify(jcr)) {
 314          do_autoprune(jcr);
 315       } else {
 316          verify_cleanup(jcr, JS_ErrorTerminated);
 317       }
 318       break;
 319    case JT_RESTORE:
 320       if (!job_canceled(jcr) && do_restore(jcr)) {
 321          do_autoprune(jcr);
 322       } else {
 323          restore_cleanup(jcr, JS_ErrorTerminated);
 324       }
 325       break;
 326    case JT_ADMIN:
 327       if (!job_canceled(jcr) && do_admin(jcr)) {
 328          do_autoprune(jcr);
 329       } else {
 330          admin_cleanup(jcr, JS_ErrorTerminated);
 331       }
 332       break;
 333    case JT_COPY:
 334    case JT_MIGRATE:
 335       if (!job_canceled(jcr) && do_migration(jcr)) {
 336          do_autoprune(jcr);
 337       } else {
 338          migration_cleanup(jcr, JS_ErrorTerminated);
 339       }
 340       break;
 341    default:
 342       Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->get_JobType());
 343       break;
 344    }
 345
 346    run_scripts(jcr, jcr->job->RunScripts, "AfterJob");
 347
 348    /* Send off any queued messages */
 349    if (jcr->msg_queue && jcr->msg_queue->size() > 0) {
 350       dequeue_messages(jcr);
 351    }
 352
 353    generate_daemon_event(jcr, "JobEnd");
 354    Dmsg1(50, "======== End Job stat=%c ==========\n", jcr->JobStatus);
 355    sm_check(__FILE__, __LINE__, true);
 356    return NULL;
 357 }
 358
 359
 360 /*
 361  * Cancel a job -- typically called by the UA (Console program), but may also
 362  *              be called by the job watchdog.
 363  *
 364  *  Returns: true  if cancel appears to be successful
 365  *           false on failure. Message sent to ua->jcr.
 366  */
 367 bool cancel_job(UAContext *ua, JCR *jcr)
 368 {
 369    BSOCK *sd, *fd;
 370    char ed1[50];
 371    int32_t old_status = jcr->JobStatus;
 372
 373    set_jcr_job_status(jcr, JS_Canceled);
 374
 375    switch (old_status) {
 376    case JS_Created:
 377    case JS_WaitJobRes:
 378    case JS_WaitClientRes:
 379    case JS_WaitStoreRes:
 380    case JS_WaitPriority:
 381    case JS_WaitMaxJobs:
 382    case JS_WaitStartTime:
 383       ua->info_msg(_("JobId %s, Job %s marked to be canceled.\n"),
 384               edit_uint64(jcr->JobId, ed1), jcr->Job);
 385       jobq_remove(&job_queue, jcr); /* attempt to remove it from queue */
 386       return true;
 387
 388    default:
 389       /* Cancel File daemon */
 390       if (jcr->file_bsock) {
 391          ua->jcr->client = jcr->client;
 392          if (!connect_to_file_daemon(ua->jcr, 10, FDConnectTimeout, 1)) {
 393             ua->error_msg(_("Failed to connect to File daemon.\n"));
 394             return 0;
 395          }
 396          Dmsg0(200, "Connected to file daemon\n");
 397          fd = ua->jcr->file_bsock;
 398          fd->fsend("cancel Job=%s\n", jcr->Job);
 399          while (fd->recv() >= 0) {
 400             ua->send_msg("%s", fd->msg);
 401          }
 402          fd->signal(BNET_TERMINATE);
 403          fd->close();
 404          ua->jcr->file_bsock = NULL;
 405       }
 406
 407       /* Cancel Storage daemon */
 408       if (jcr->store_bsock) {
 409          if (!ua->jcr->wstorage) {
 410             if (jcr->rstorage) {
 411                copy_wstorage(ua->jcr, jcr->rstorage, _("Job resource"));
 412             } else {
 413                copy_wstorage(ua->jcr, jcr->wstorage, _("Job resource"));
 414             }
 415          } else {
 416             USTORE store;
 417             if (jcr->rstorage) {
 418                store.store = jcr->rstore;
 419             } else {
 420                store.store = jcr->wstore;
 421             }
 422             set_wstorage(ua->jcr, &store);
 423          }
 424
 425          if (!connect_to_storage_daemon(ua->jcr, 10, SDConnectTimeout, 1)) {
 426             ua->error_msg(_("Failed to connect to Storage daemon.\n"));
 427             return false;
 428          }
 429          Dmsg0(200, "Connected to storage daemon\n");
 430          sd = ua->jcr->store_bsock;
 431          sd->fsend("cancel Job=%s\n", jcr->Job);
 432          while (sd->recv() >= 0) {
 433             ua->send_msg("%s", sd->msg);
 434          }
 435          sd->signal(BNET_TERMINATE);
 436          sd->close();
 437          ua->jcr->store_bsock = NULL;
 438       }
 439    }
 440
 441    return true;
 442 }
 443
 444 void cancel_storage_daemon_job(JCR *jcr)
 445 {
 446    UAContext *ua = new_ua_context(jcr);
 447    JCR *control_jcr = new_control_jcr("*JobCancel*", JT_SYSTEM);
 448    BSOCK *sd;
 449
 450    ua->jcr = control_jcr;
 451    if (jcr->store_bsock) {
 452       if (!ua->jcr->wstorage) {
 453          if (jcr->rstorage) {
 454             copy_wstorage(ua->jcr, jcr->rstorage, _("Job resource"));
 455          } else {
 456             copy_wstorage(ua->jcr, jcr->wstorage, _("Job resource"));
 457          }
 458       } else {
 459          USTORE store;
 460          if (jcr->rstorage) {
 461             store.store = jcr->rstore;
 462          } else {
 463             store.store = jcr->wstore;
 464          }
 465          set_wstorage(ua->jcr, &store);
 466       }
 467
 468       if (!connect_to_storage_daemon(ua->jcr, 10, SDConnectTimeout, 1)) {
 469          goto bail_out;
 470       }
 471       Dmsg0(200, "Connected to storage daemon\n");
 472       sd = ua->jcr->store_bsock;
 473       sd->fsend("cancel Job=%s\n", jcr->Job);
 474       while (sd->recv() >= 0) {
 475       }
 476       sd->signal(BNET_TERMINATE);
 477       sd->close();
 478       ua->jcr->store_bsock = NULL;
 479    }
 480 bail_out:
 481    free_jcr(control_jcr);
 482    free_ua_context(ua);
 483 }
 484
 485 static void job_monitor_destructor(watchdog_t *self)
 486 {
 487    JCR *control_jcr = (JCR *)self->data;
 488
 489    free_jcr(control_jcr);
 490 }
 491
 492 static void job_monitor_watchdog(watchdog_t *self)
 493 {
 494    JCR *control_jcr, *jcr;
 495
 496    control_jcr = (JCR *)self->data;
 497
 498    Dsm_check(1);
 499    Dmsg1(800, "job_monitor_watchdog %p called\n", self);
 500
 501    foreach_jcr(jcr) {
 502       bool cancel = false;
 503
 504       if (jcr->JobId == 0 || job_canceled(jcr)) {
 505          Dmsg2(800, "Skipping JCR=%p Job=%s\n", jcr, jcr->Job);
 506          continue;
 507       }
 508
 509       /* check MaxWaitTime */
 510       if (job_check_maxwaittime(jcr)) {
 511          set_jcr_job_status(jcr, JS_Canceled);
 512          Qmsg(jcr, M_FATAL, 0, _("Max wait time exceeded. Job canceled.\n"));
 513          cancel = true;
 514       /* check MaxRunTime */
 515       } else if (job_check_maxruntime(jcr)) {
 516          set_jcr_job_status(jcr, JS_Canceled);
 517          Qmsg(jcr, M_FATAL, 0, _("Max run time exceeded. Job canceled.\n"));
 518          cancel = true;
 519       /* check MaxRunSchedTime */
 520       } else if (job_check_maxschedruntime(jcr)) {
 521          set_jcr_job_status(jcr, JS_Canceled);
 522          Qmsg(jcr, M_FATAL, 0, _("Max sched run time exceeded. Job canceled.\n"));
 523          cancel = true;
 524       }
 525
 526       if (cancel) {
 527          Dmsg3(800, "Cancelling JCR %p jobid %d (%s)\n", jcr, jcr->JobId, jcr->Job);
 528          UAContext *ua = new_ua_context(jcr);
 529          ua->jcr = control_jcr;
 530          cancel_job(ua, jcr);
 531          free_ua_context(ua);
 532          Dmsg2(800, "Have cancelled JCR %p Job=%d\n", jcr, jcr->JobId);
 533       }
 534
 535    }
 536    /* Keep reference counts correct */
 537    endeach_jcr(jcr);
 538 }
 539
 540 /*
 541  * Check if the maxwaittime has expired and it is possible
 542  *  to cancel the job.
 543  */
 544 static bool job_check_maxwaittime(JCR *jcr)
 545 {
 546    bool cancel = false;
 547    JOB *job = jcr->job;
 548
 549    if (!job_waiting(jcr)) {
 550       return false;
 551    }
 552    Dmsg3(200, "check maxwaittime %u - %u >= %u\n", watchdog_time, jcr->wait_time, job->MaxWaitTime);
 553    if (job->MaxWaitTime != 0 &&
 554        (watchdog_time - jcr->wait_time) >= job->MaxWaitTime) {
 555       cancel = true;
 556    }
 557
 558    return cancel;
 559 }
 560
 561 /*
 562  * Check if maxruntime has expired and if the job can be
 563  *   canceled.
 564  */
 565 static bool job_check_maxruntime(JCR *jcr)
 566 {
 567    bool cancel = false;
 568    JOB *job = jcr->job;
 569
 570    if (job_canceled(jcr) || jcr->JobStatus == JS_Created) {
 571       return false;
 572    }
 573    if (jcr->job->MaxRunTime == 0 && job->FullMaxRunTime == 0 &&
 574        job->IncMaxRunTime == 0 && job->DiffMaxRunTime == 0) {
 575       return false;
 576    }
 577    Dmsg6(200, "check_maxruntime %u - %u >= %u|%u|%u|%u\n\n",
 578          watchdog_time, jcr->start_time, job->MaxRunTime, job->FullMaxRunTime,
 579          job->IncMaxRunTime, job->DiffMaxRunTime);
 580
 581    if (jcr->get_JobLevel() == L_FULL && job->FullMaxRunTime != 0 &&
 582          (watchdog_time - jcr->start_time) >= job->FullMaxRunTime) {
 583       cancel = true;
 584    } else if (jcr->get_JobLevel() == L_DIFFERENTIAL && job->DiffMaxRunTime != 0 &&
 585          (watchdog_time - jcr->start_time) >= job->DiffMaxRunTime) {
 586       cancel = true;
 587    } else if (jcr->get_JobLevel() == L_INCREMENTAL && job->IncMaxRunTime != 0 &&
 588          (watchdog_time - jcr->start_time) >= job->IncMaxRunTime) {
 589       cancel = true;
 590    } else if ((watchdog_time - jcr->start_time) >= job->MaxRunTime) {
 591       cancel = true;
 592    }
 593
 594    return cancel;
 595 }
 596
 597 /*
 598  * Check if MaxRunSchedTime has expired and if the job can be
 599  *   canceled.
 600  */
 601 static bool job_check_maxschedruntime(JCR *jcr)
 602 {
 603    if (jcr->job->MaxRunSchedTime == 0 || job_canceled(jcr)) {
 604       return false;
 605    }
 606    if ((watchdog_time - jcr->sched_time) < jcr->job->MaxRunSchedTime) {
 607       Dmsg3(200, "Job %p (%s) with MaxRunSchedTime %d not expired\n",
 608             jcr, jcr->Job, jcr->job->MaxRunSchedTime);
 609       return false;
 610    }
 611
 612    return true;
 613 }
 614
 615 /*
 616  * Get or create a Pool record with the given name.
 617  * Returns: 0 on error
 618  *          poolid if OK
 619  */
 620 DBId_t get_or_create_pool_record(JCR *jcr, char *pool_name)
 621 {
 622    POOL_DBR pr;
 623
 624    memset(&pr, 0, sizeof(pr));
 625    bstrncpy(pr.Name, pool_name, sizeof(pr.Name));
 626    Dmsg1(110, "get_or_create_pool=%s\n", pool_name);
 627
 628    while (!db_get_pool_record(jcr, jcr->db, &pr)) { /* get by Name */
 629       /* Try to create the pool */
 630       if (create_pool(jcr, jcr->db, jcr->pool, POOL_OP_CREATE) < 0) {
 631          Jmsg(jcr, M_FATAL, 0, _("Pool \"%s\" not in database. ERR=%s"), pr.Name,
 632             db_strerror(jcr->db));
 633          return 0;
 634       } else {
 635          Jmsg(jcr, M_INFO, 0, _("Created database record for Pool \"%s\".\n"), pr.Name);
 636       }
 637    }
 638    return pr.PoolId;
 639 }
 640
 641 /*
 642  * Check for duplicate jobs.
 643  *  Returns: true  if current job should continue
 644  *           false if current job should terminate
 645  */
 646 bool allow_duplicate_job(JCR *jcr)
 647 {
 648    JOB *job = jcr->job;
 649    JCR *djcr;                /* possible duplicate */
 650
 651    if (job->AllowDuplicateJobs) {
 652       return true;
 653    }
 654    if (!job->AllowHigherDuplicates) {
 655       foreach_jcr(djcr) {
 656          char ec1[50];
 657          if (strcmp(job->name(), djcr->job->name()) == 0) {
 658             bool cancel_queued = false;
 659             if (job->DuplicateJobProximity > 0) {
 660                utime_t now = (utime_t)time(NULL);
 661                if ((now - djcr->start_time) > job->DuplicateJobProximity) {
 662                   continue;               /* not really a duplicate */
 663                }
 664             }
 665             /* Cancel */
 666             if (!(job->CancelQueuedDuplicates || job->CancelRunningDuplicates)) {
 667                /* Zap current job */
 668                Jmsg(jcr, M_FATAL, 0, _("Duplicate job not allowed. JobId=%s\n"),
 669                   edit_uint64(djcr->JobId, ec1));
 670                return false;
 671             }
 672             /* If CancelQueuedDuplicates is set do so only if job is queued */
 673             if (job->CancelQueuedDuplicates) {
 674                 switch (djcr->JobStatus) {
 675                 case JS_Created:
 676                 case JS_WaitJobRes:
 677                 case JS_WaitClientRes:
 678                 case JS_WaitStoreRes:
 679                 case JS_WaitPriority:
 680                 case JS_WaitMaxJobs:
 681                 case JS_WaitStartTime:
 682                    cancel_queued = true;
 683                    break;
 684                 default:
 685                    break;
 686                 }
 687             }
 688             if (cancel_queued || job->CancelRunningDuplicates) {
 689                UAContext *ua = new_ua_context(djcr);
 690                Jmsg(jcr, M_INFO, 0, _("Cancelling duplicate JobId=%s.\n"),
 691                   edit_uint64(djcr->JobId, ec1));
 692                ua->jcr = djcr;
 693                cancel_job(ua, djcr);
 694                free_ua_context(ua);
 695                Dmsg2(800, "Have cancelled JCR %p Job=%d\n", djcr, djcr->JobId);
 696             }
 697          }
 698       }
 699    }
 700    return true;
 701 }
 702
 703 void apply_pool_overrides(JCR *jcr)
 704 {
 705    bool pool_override = false;
 706
 707    if (jcr->run_pool_override) {
 708       pm_strcpy(jcr->pool_source, _("Run pool override"));
 709    }
 710    /*
 711     * Apply any level related Pool selections
 712     */
 713    switch (jcr->get_JobLevel()) {
 714    case L_FULL:
 715       if (jcr->full_pool) {
 716          jcr->pool = jcr->full_pool;
 717          pool_override = true;
 718          if (jcr->run_full_pool_override) {
 719             pm_strcpy(jcr->pool_source, _("Run FullPool override"));
 720          } else {
 721             pm_strcpy(jcr->pool_source, _("Job FullPool override"));
 722          }
 723       }
 724       break;
 725    case L_INCREMENTAL:
 726       if (jcr->inc_pool) {
 727          jcr->pool = jcr->inc_pool;
 728          pool_override = true;
 729          if (jcr->run_inc_pool_override) {
 730             pm_strcpy(jcr->pool_source, _("Run IncPool override"));
 731          } else {
 732             pm_strcpy(jcr->pool_source, _("Job IncPool override"));
 733          }
 734       }
 735       break;
 736    case L_DIFFERENTIAL:
 737       if (jcr->diff_pool) {
 738          jcr->pool = jcr->diff_pool;
 739          pool_override = true;
 740          if (jcr->run_diff_pool_override) {
 741             pm_strcpy(jcr->pool_source, _("Run DiffPool override"));
 742          } else {
 743             pm_strcpy(jcr->pool_source, _("Job DiffPool override"));
 744          }
 745       }
 746       break;
 747    }
 748    /* Update catalog if pool overridden */
 749    if (pool_override && jcr->pool->catalog) {
 750       jcr->catalog = jcr->pool->catalog;
 751       pm_strcpy(jcr->catalog_source, _("Pool resource"));
 752    }
 753 }
 754
 755
 756 /*
 757  * Get or create a Client record for this Job
 758  */
 759 bool get_or_create_client_record(JCR *jcr)
 760 {
 761    CLIENT_DBR cr;
 762
 763    memset(&cr, 0, sizeof(cr));
 764    bstrncpy(cr.Name, jcr->client->hdr.name, sizeof(cr.Name));
 765    cr.AutoPrune = jcr->client->AutoPrune;
 766    cr.FileRetention = jcr->client->FileRetention;
 767    cr.JobRetention = jcr->client->JobRetention;
 768    if (!jcr->client_name) {
 769       jcr->client_name = get_pool_memory(PM_NAME);
 770    }
 771    pm_strcpy(jcr->client_name, jcr->client->hdr.name);
 772    if (!db_create_client_record(jcr, jcr->db, &cr)) {
 773       Jmsg(jcr, M_FATAL, 0, _("Could not create Client record. ERR=%s\n"),
 774          db_strerror(jcr->db));
 775       return false;
 776    }
 777    jcr->jr.ClientId = cr.ClientId;
 778    if (cr.Uname[0]) {
 779       if (!jcr->client_uname) {
 780          jcr->client_uname = get_pool_memory(PM_NAME);
 781       }
 782       pm_strcpy(jcr->client_uname, cr.Uname);
 783    }
 784    Dmsg2(100, "Created Client %s record %d\n", jcr->client->hdr.name,
 785       jcr->jr.ClientId);
 786    return true;
 787 }
 788
 789 bool get_or_create_fileset_record(JCR *jcr)
 790 {
 791    FILESET_DBR fsr;
 792    /*
 793     * Get or Create FileSet record
 794     */
 795    memset(&fsr, 0, sizeof(FILESET_DBR));
 796    bstrncpy(fsr.FileSet, jcr->fileset->hdr.name, sizeof(fsr.FileSet));
 797    if (jcr->fileset->have_MD5) {
 798       struct MD5Context md5c;
 799       unsigned char digest[MD5HashSize];
 800       memcpy(&md5c, &jcr->fileset->md5c, sizeof(md5c));
 801       MD5Final(digest, &md5c);
 802       /*
 803        * Keep the flag (last arg) set to false otherwise old FileSets will
 804        * get new MD5 sums and the user will get Full backups on everything
 805        */
 806       bin_to_base64(fsr.MD5, sizeof(fsr.MD5), (char *)digest, MD5HashSize, false);
 807       bstrncpy(jcr->fileset->MD5, fsr.MD5, sizeof(jcr->fileset->MD5));
 808    } else {
 809       Jmsg(jcr, M_WARNING, 0, _("FileSet MD5 digest not found.\n"));
 810    }
 811    if (!jcr->fileset->ignore_fs_changes ||
 812        !db_get_fileset_record(jcr, jcr->db, &fsr)) {
 813       if (!db_create_fileset_record(jcr, jcr->db, &fsr)) {
 814          Jmsg(jcr, M_ERROR, 0, _("Could not create FileSet \"%s\" record. ERR=%s\n"),
 815             fsr.FileSet, db_strerror(jcr->db));
 816          return false;
 817       }
 818    }
 819    jcr->jr.FileSetId = fsr.FileSetId;
 820    bstrncpy(jcr->FSCreateTime, fsr.cCreateTime, sizeof(jcr->FSCreateTime));
 821    Dmsg2(119, "Created FileSet %s record %u\n", jcr->fileset->hdr.name,
 822       jcr->jr.FileSetId);
 823    return true;
 824 }
 825
 826 void init_jcr_job_record(JCR *jcr)
 827 {
 828    jcr->jr.SchedTime = jcr->sched_time;
 829    jcr->jr.StartTime = jcr->start_time;
 830    jcr->jr.EndTime = 0;               /* perhaps rescheduled, clear it */
 831    jcr->jr.JobType = jcr->get_JobType();
 832    jcr->jr.JobLevel = jcr->get_JobLevel();
 833    jcr->jr.JobStatus = jcr->JobStatus;
 834    jcr->jr.JobId = jcr->JobId;
 835    bstrncpy(jcr->jr.Name, jcr->job->name(), sizeof(jcr->jr.Name));
 836    bstrncpy(jcr->jr.Job, jcr->Job, sizeof(jcr->jr.Job));
 837 }
 838
 839 /*
 840  * Write status and such in DB
 841  */
 842 void update_job_end_record(JCR *jcr)
 843 {
 844    jcr->jr.EndTime = time(NULL);
 845    jcr->end_time = jcr->jr.EndTime;
 846    jcr->jr.JobId = jcr->JobId;
 847    jcr->jr.JobStatus = jcr->JobStatus;
 848    jcr->jr.JobFiles = jcr->JobFiles;
 849    jcr->jr.JobBytes = jcr->JobBytes;
 850    jcr->jr.VolSessionId = jcr->VolSessionId;
 851    jcr->jr.VolSessionTime = jcr->VolSessionTime;
 852    jcr->jr.JobErrors = jcr->Errors;
 853    if (!db_update_job_end_record(jcr, jcr->db, &jcr->jr)) {
 854       Jmsg(jcr, M_WARNING, 0, _("Error updating job record. %s"),
 855          db_strerror(jcr->db));
 856    }
 857 }
 858
 859 /*
 860  * Takes base_name and appends (unique) current
 861  *   date and time to form unique job name.
 862  *
 863  *  Note, the seconds are actually a sequence number. This
 864  *   permits us to start a maximum fo 59 unique jobs a second, which
 865  *   should be sufficient.
 866  *
 867  *  Returns: unique job name in jcr->Job
 868  *    date/time in jcr->start_time
 869  */
 870 void create_unique_job_name(JCR *jcr, const char *base_name)
 871 {
 872    /* Job start mutex */
 873    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 874    static time_t last_start_time = 0;
 875    static int seq = 0;
 876    time_t now;
 877    struct tm tm;
 878    char dt[MAX_TIME_LENGTH];
 879    char name[MAX_NAME_LENGTH];
 880    char *p;
 881
 882    /* Guarantee unique start time -- maximum one per second, and
 883     * thus unique Job Name
 884     */
 885    P(mutex);                          /* lock creation of jobs */
 886    now = time(NULL);
 887    seq++;
 888    if (seq > 59) {                    /* wrap as if it is seconds */
 889       seq = 0;
 890       while (now == last_start_time) {
 891          bmicrosleep(0, 500000);
 892          now = time(NULL);
 893       }
 894    }
 895    last_start_time = now;
 896    V(mutex);                          /* allow creation of jobs */
 897    jcr->start_time = now;
 898    /* Form Unique JobName */
 899    (void)localtime_r(&now, &tm);
 900    /* Use only characters that are permitted in Windows filenames */
 901    strftime(dt, sizeof(dt), "%Y-%m-%d_%H.%M", &tm);
 902    bstrncpy(name, base_name, sizeof(name));
 903    name[sizeof(name)-22] = 0;          /* truncate if too long */
 904    bsnprintf(jcr->Job, sizeof(jcr->Job), "%s.%s.%02d", name, dt, seq); /* add date & time */
 905    /* Convert spaces into underscores */
 906    for (p=jcr->Job; *p; p++) {
 907       if (*p == ' ') {
 908          *p = '_';
 909       }
 910    }
 911 }
 912
 913 /* Called directly from job rescheduling */
 914 void dird_free_jcr_pointers(JCR *jcr)
 915 {
 916    if (jcr->sd_auth_key) {
 917       free(jcr->sd_auth_key);
 918       jcr->sd_auth_key = NULL;
 919    }
 920    if (jcr->where) {
 921       free(jcr->where);
 922       jcr->where = NULL;
 923    }
 924    if (jcr->file_bsock) {
 925       Dmsg0(200, "Close File bsock\n");
 926       bnet_close(jcr->file_bsock);
 927       jcr->file_bsock = NULL;
 928    }
 929    if (jcr->store_bsock) {
 930       Dmsg0(200, "Close Store bsock\n");
 931       bnet_close(jcr->store_bsock);
 932       jcr->store_bsock = NULL;
 933    }
 934    if (jcr->fname) {
 935       Dmsg0(200, "Free JCR fname\n");
 936       free_pool_memory(jcr->fname);
 937       jcr->fname = NULL;
 938    }
 939    if (jcr->RestoreBootstrap) {
 940       free(jcr->RestoreBootstrap);
 941       jcr->RestoreBootstrap = NULL;
 942    }
 943    if (jcr->client_uname) {
 944       free_pool_memory(jcr->client_uname);
 945       jcr->client_uname = NULL;
 946    }
 947    if (jcr->attr) {
 948       free_pool_memory(jcr->attr);
 949       jcr->attr = NULL;
 950    }
 951    if (jcr->ar) {
 952       free(jcr->ar);
 953       jcr->ar = NULL;
 954    }
 955 }
 956
 957 /*
 958  * Free the Job Control Record if no one is still using it.
 959  *  Called from main free_jcr() routine in src/lib/jcr.c so
 960  *  that we can do our Director specific cleanup of the jcr.
 961  */
 962 void dird_free_jcr(JCR *jcr)
 963 {
 964    Dmsg0(200, "Start dird free_jcr\n");
 965
 966    dird_free_jcr_pointers(jcr);
 967    if (jcr->term_wait_inited) {
 968       pthread_cond_destroy(&jcr->term_wait);
 969       jcr->term_wait_inited = false;
 970    }
 971    if (jcr->db_batch) {
 972       db_close_database(jcr, jcr->db_batch);
 973       jcr->db_batch = NULL;
 974       jcr->batch_started = false;
 975    }
 976    if (jcr->db) {
 977       db_close_database(jcr, jcr->db);
 978       jcr->db = NULL;
 979    }
 980    if (jcr->stime) {
 981       Dmsg0(200, "Free JCR stime\n");
 982       free_pool_memory(jcr->stime);
 983       jcr->stime = NULL;
 984    }
 985    if (jcr->fname) {
 986       Dmsg0(200, "Free JCR fname\n");
 987       free_pool_memory(jcr->fname);
 988       jcr->fname = NULL;
 989    }
 990    if (jcr->pool_source) {
 991       free_pool_memory(jcr->pool_source);
 992       jcr->pool_source = NULL;
 993    }
 994    if (jcr->catalog_source) {
 995       free_pool_memory(jcr->catalog_source);
 996       jcr->catalog_source = NULL;
 997    }
 998    if (jcr->rpool_source) {
 999       free_pool_memory(jcr->rpool_source);
1000       jcr->rpool_source = NULL;
1001    }
1002    if (jcr->wstore_source) {
1003       free_pool_memory(jcr->wstore_source);
1004       jcr->wstore_source = NULL;
1005    }
1006    if (jcr->rstore_source) {
1007       free_pool_memory(jcr->rstore_source);
1008       jcr->rstore_source = NULL;
1009    }
1010
1011    /* Delete lists setup to hold storage pointers */
1012    free_rwstorage(jcr);
1013
1014    jcr->job_end_push.destroy();
1015
1016    if (jcr->JobId != 0)
1017       write_state_file(director->working_directory, "bacula-dir", get_first_port_host_order(director->DIRaddrs));
1018
1019    Dmsg0(200, "End dird free_jcr\n");
1020 }
1021
1022 /*
1023  * The Job storage definition must be either in the Job record
1024  *  or in the Pool record.  The Pool record overrides the Job
1025  *  record.
1026  */
1027 void get_job_storage(USTORE *store, JOB *job, RUN *run)
1028 {
1029    if (run && run->pool && run->pool->storage) {
1030       store->store = (STORE *)run->pool->storage->first();
1031       pm_strcpy(store->store_source, _("Run pool override"));
1032       return;
1033    }
1034    if (run && run->storage) {
1035       store->store = run->storage;
1036       pm_strcpy(store->store_source, _("Run storage override"));
1037       return;
1038    }
1039    if (job->pool->storage) {
1040       store->store = (STORE *)job->pool->storage->first();
1041       pm_strcpy(store->store_source, _("Pool resource"));
1042    } else {
1043       store->store = (STORE *)job->storage->first();
1044       pm_strcpy(store->store_source, _("Job resource"));
1045    }
1046 }
1047
1048 /*
1049  * Set some defaults in the JCR necessary to
1050  * run. These items are pulled from the job
1051  * definition as defaults, but can be overridden
1052  * later either by the Run record in the Schedule resource,
1053  * or by the Console program.
1054  */
1055 void set_jcr_defaults(JCR *jcr, JOB *job)
1056 {
1057    jcr->job = job;
1058    jcr->set_JobType(job->JobType);
1059    jcr->JobStatus = JS_Created;
1060
1061    switch (jcr->get_JobType()) {
1062    case JT_ADMIN:
1063       jcr->set_JobLevel(L_NONE);
1064       break;
1065    default:
1066       jcr->set_JobLevel(job->JobLevel);
1067       break;
1068    }
1069
1070    if (!jcr->fname) {
1071       jcr->fname = get_pool_memory(PM_FNAME);
1072    }
1073    if (!jcr->pool_source) {
1074       jcr->pool_source = get_pool_memory(PM_MESSAGE);
1075       pm_strcpy(jcr->pool_source, _("unknown source"));
1076    }
1077    if (!jcr->catalog_source) {
1078       jcr->catalog_source = get_pool_memory(PM_MESSAGE);
1079       pm_strcpy(jcr->catalog_source, _("unknown source"));
1080    }
1081
1082    jcr->JobPriority = job->Priority;
1083    /* Copy storage definitions -- deleted in dir_free_jcr above */
1084    if (job->storage) {
1085       copy_rwstorage(jcr, job->storage, _("Job resource"));
1086    } else {
1087       copy_rwstorage(jcr, job->pool->storage, _("Pool resource"));
1088    }
1089    jcr->client = job->client;
1090    if (!jcr->client_name) {
1091       jcr->client_name = get_pool_memory(PM_NAME);
1092    }
1093    pm_strcpy(jcr->client_name, jcr->client->hdr.name);
1094    pm_strcpy(jcr->pool_source, _("Job resource"));
1095    jcr->pool = job->pool;
1096    jcr->full_pool = job->full_pool;
1097    jcr->inc_pool = job->inc_pool;
1098    jcr->diff_pool = job->diff_pool;
1099    if (job->pool->catalog) {
1100       jcr->catalog = job->pool->catalog;
1101       pm_strcpy(jcr->catalog_source, _("Pool resource"));
1102    } else {
1103       jcr->catalog = job->client->catalog;
1104       pm_strcpy(jcr->catalog_source, _("Client resource"));
1105    }
1106    jcr->fileset = job->fileset;
1107    jcr->messages = job->messages;
1108    jcr->spool_data = job->spool_data;
1109    jcr->spool_size = job->spool_size;
1110    jcr->write_part_after_job = job->write_part_after_job;
1111    jcr->accurate = job->accurate;
1112    if (jcr->RestoreBootstrap) {
1113       free(jcr->RestoreBootstrap);
1114       jcr->RestoreBootstrap = NULL;
1115    }
1116    /* This can be overridden by Console program */
1117    if (job->RestoreBootstrap) {
1118       jcr->RestoreBootstrap = bstrdup(job->RestoreBootstrap);
1119    }
1120    /* This can be overridden by Console program */
1121    jcr->verify_job = job->verify_job;
1122    /* If no default level given, set one */
1123    if (jcr->get_JobLevel() == 0) {
1124       switch (jcr->get_JobType()) {
1125       case JT_VERIFY:
1126          jcr->set_JobLevel(L_VERIFY_CATALOG);
1127          break;
1128       case JT_BACKUP:
1129          jcr->set_JobLevel(L_INCREMENTAL);
1130          break;
1131       case JT_RESTORE:
1132       case JT_ADMIN:
1133          jcr->set_JobLevel(L_NONE);
1134          break;
1135       default:
1136          jcr->set_JobLevel(L_FULL);
1137          break;
1138       }
1139    }
1140 }
1141
1142 /*
1143  * Copy the storage definitions from an alist to the JCR
1144  */
1145 void copy_rwstorage(JCR *jcr, alist *storage, const char *where)
1146 {
1147    if (jcr->JobReads()) {
1148       copy_rstorage(jcr, storage, where);
1149    }
1150    copy_wstorage(jcr, storage, where);
1151 }
1152
1153
1154 /* Set storage override.  Releases any previous storage definition */
1155 void set_rwstorage(JCR *jcr, USTORE *store)
1156 {
1157    if (!store) {
1158       Jmsg(jcr, M_FATAL, 0, _("No storage specified.\n"));
1159       return;
1160    }
1161    if (jcr->JobReads()) {
1162       set_rstorage(jcr, store);
1163    }
1164    set_wstorage(jcr, store);
1165 }
1166
1167 void free_rwstorage(JCR *jcr)
1168 {
1169    free_rstorage(jcr);
1170    free_wstorage(jcr);
1171 }
1172
1173 /*
1174  * Copy the storage definitions from an alist to the JCR
1175  */
1176 void copy_rstorage(JCR *jcr, alist *storage, const char *where)
1177 {
1178    if (storage) {
1179       STORE *st;
1180       if (jcr->rstorage) {
1181          delete jcr->rstorage;
1182       }
1183       jcr->rstorage = New(alist(10, not_owned_by_alist));
1184       foreach_alist(st, storage) {
1185          jcr->rstorage->append(st);
1186       }
1187       if (!jcr->rstore_source) {
1188          jcr->rstore_source = get_pool_memory(PM_MESSAGE);
1189       }
1190       pm_strcpy(jcr->rstore_source, where);
1191       if (jcr->rstorage) {
1192          jcr->rstore = (STORE *)jcr->rstorage->first();
1193       }
1194    }
1195 }
1196
1197
1198 /* Set storage override.  Remove all previous storage */
1199 void set_rstorage(JCR *jcr, USTORE *store)
1200 {
1201    STORE *storage;
1202
1203    if (!store->store) {
1204       return;
1205    }
1206    if (jcr->rstorage) {
1207       free_rstorage(jcr);
1208    }
1209    if (!jcr->rstorage) {
1210       jcr->rstorage = New(alist(10, not_owned_by_alist));
1211    }
1212    jcr->rstore = store->store;
1213    if (!jcr->rstore_source) {
1214       jcr->rstore_source = get_pool_memory(PM_MESSAGE);
1215    }
1216    pm_strcpy(jcr->rstore_source, store->store_source);
1217    foreach_alist(storage, jcr->rstorage) {
1218       if (store->store == storage) {
1219          return;
1220       }
1221    }
1222    /* Store not in list, so add it */
1223    jcr->rstorage->prepend(store->store);
1224 }
1225
1226 void free_rstorage(JCR *jcr)
1227 {
1228    if (jcr->rstorage) {
1229       delete jcr->rstorage;
1230       jcr->rstorage = NULL;
1231    }
1232    jcr->rstore = NULL;
1233 }
1234
1235 /*
1236  * Copy the storage definitions from an alist to the JCR
1237  */
1238 void copy_wstorage(JCR *jcr, alist *storage, const char *where)
1239 {
1240    if (storage) {
1241       STORE *st;
1242       if (jcr->wstorage) {
1243          delete jcr->wstorage;
1244       }
1245       jcr->wstorage = New(alist(10, not_owned_by_alist));
1246       foreach_alist(st, storage) {
1247          Dmsg1(100, "wstorage=%s\n", st->name());
1248          jcr->wstorage->append(st);
1249       }
1250       if (!jcr->wstore_source) {
1251          jcr->wstore_source = get_pool_memory(PM_MESSAGE);
1252       }
1253       pm_strcpy(jcr->wstore_source, where);
1254       if (jcr->wstorage) {
1255          jcr->wstore = (STORE *)jcr->wstorage->first();
1256          Dmsg2(100, "wstore=%s where=%s\n", jcr->wstore->name(), jcr->wstore_source);
1257       }
1258    }
1259 }
1260
1261
1262 /* Set storage override. Remove all previous storage */
1263 void set_wstorage(JCR *jcr, USTORE *store)
1264 {
1265    STORE *storage;
1266
1267    if (!store->store) {
1268       return;
1269    }
1270    if (jcr->wstorage) {
1271       free_wstorage(jcr);
1272    }
1273    if (!jcr->wstorage) {
1274       jcr->wstorage = New(alist(10, not_owned_by_alist));
1275    }
1276    jcr->wstore = store->store;
1277    if (!jcr->wstore_source) {
1278       jcr->wstore_source = get_pool_memory(PM_MESSAGE);
1279    }
1280    pm_strcpy(jcr->wstore_source, store->store_source);
1281    Dmsg2(50, "wstore=%s where=%s\n", jcr->wstore->name(), jcr->wstore_source);
1282    foreach_alist(storage, jcr->wstorage) {
1283       if (store->store == storage) {
1284          return;
1285       }
1286    }
1287    /* Store not in list, so add it */
1288    jcr->wstorage->prepend(store->store);
1289 }
1290
1291 void free_wstorage(JCR *jcr)
1292 {
1293    if (jcr->wstorage) {
1294       delete jcr->wstorage;
1295       jcr->wstorage = NULL;
1296    }
1297    jcr->wstore = NULL;
1298 }
1299
1300 char *job_code_callback_clones(JCR *jcr, const char* param)
1301 {
1302    if (param[0] == 'p') {
1303       return jcr->pool->name();
1304    }
1305    return NULL;
1306 }
1307
1308 void create_clones(JCR *jcr)
1309 {
1310    /*
1311     * Fire off any clone jobs (run directives)
1312     */
1313    Dmsg2(900, "cloned=%d run_cmds=%p\n", jcr->cloned, jcr->job->run_cmds);
1314    if (!jcr->cloned && jcr->job->run_cmds) {
1315       char *runcmd;
1316       JOB *job = jcr->job;
1317       POOLMEM *cmd = get_pool_memory(PM_FNAME);
1318       UAContext *ua = new_ua_context(jcr);
1319       ua->batch = true;
1320       foreach_alist(runcmd, job->run_cmds) {
1321          cmd = edit_job_codes(jcr, cmd, runcmd, "", job_code_callback_clones);
1322          Mmsg(ua->cmd, "run %s cloned=yes", cmd);
1323          Dmsg1(900, "=============== Clone cmd=%s\n", ua->cmd);
1324          parse_ua_args(ua);                 /* parse command */
1325          int stat = run_cmd(ua, ua->cmd);
1326          if (stat == 0) {
1327             Jmsg(jcr, M_ERROR, 0, _("Could not start clone job.\n"));
1328          } else {
1329             Jmsg(jcr, M_INFO, 0, _("Clone JobId %d started.\n"), stat);
1330          }
1331       }
1332       free_ua_context(ua);
1333       free_pool_memory(cmd);
1334    }
1335 }
1336
1337 /*
1338  * Given: a JobId in jcr->previous_jr.JobId,
1339  *  this subroutine writes a bsr file to restore that job.
1340  */
1341 bool create_restore_bootstrap_file(JCR *jcr)
1342 {
1343    RESTORE_CTX rx;
1344    UAContext *ua;
1345    memset(&rx, 0, sizeof(rx));
1346    rx.bsr = new_bsr();
1347    rx.JobIds = (char *)"";
1348    rx.bsr->JobId = jcr->previous_jr.JobId;
1349    ua = new_ua_context(jcr);
1350    complete_bsr(ua, rx.bsr);
1351    rx.bsr->fi = new_findex();
1352    rx.bsr->fi->findex = 1;
1353    rx.bsr->fi->findex2 = jcr->previous_jr.JobFiles;
1354    jcr->ExpectedFiles = write_bsr_file(ua, rx);
1355    if (jcr->ExpectedFiles == 0) {
1356       free_ua_context(ua);
1357       free_bsr(rx.bsr);
1358       return false;
1359    }
1360    free_ua_context(ua);
1361    free_bsr(rx.bsr);
1362    jcr->needs_sd = true;
1363    return true;
1364 }
1365
1366 /* TODO: redirect command ouput to job log */
1367 bool run_console_command(JCR *jcr, const char *cmd){
1368    UAContext *ua;
1369    bool ok;
1370    JCR *ljcr = new_control_jcr("-RunScript-", JT_CONSOLE);
1371    ua = new_ua_context(ljcr);
1372    /* run from runscript and check if commands are autorized */
1373    ua->runscript = true;
1374    Mmsg(ua->cmd, "%s", cmd);
1375    Dmsg1(100, "Console command: %s\n", ua->cmd);
1376    parse_ua_args(ua);
1377    ok= do_a_command(ua);
1378    free_ua_context(ua);
1379    free_jcr(ljcr);
1380    return ok;
1381 }