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

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