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    Copyright (C) 2000-2006 Kern Sibbald
  11
  12    This program is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU General Public License
  14    version 2 as amended with additional clauses defined in the
  15    file LICENSE in the main source directory.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20    the file LICENSE for additional details.
  21
  22  */
  23
  24 #include "bacula.h"
  25 #include "dird.h"
  26
  27 /* Forward referenced subroutines */
  28 static void *job_thread(void *arg);
  29 static void job_monitor_watchdog(watchdog_t *self);
  30 static void job_monitor_destructor(watchdog_t *self);
  31 static bool job_check_maxwaittime(JCR *control_jcr, JCR *jcr);
  32 static bool job_check_maxruntime(JCR *control_jcr, JCR *jcr);
  33
  34 /* Imported subroutines */
  35 extern void term_scheduler();
  36 extern void term_ua_server();
  37
  38 /* Imported variables */
  39 extern time_t watchdog_time;
  40
  41 jobq_t job_queue;
  42
  43 void init_job_server(int max_workers)
  44 {
  45    int stat;
  46    watchdog_t *wd;
  47
  48    if ((stat = jobq_init(&job_queue, max_workers, job_thread)) != 0) {
  49       berrno be;
  50       Emsg1(M_ABORT, 0, _("Could not init job queue: ERR=%s\n"), be.strerror(stat));
  51    }
  52    wd = new_watchdog();
  53    wd->callback = job_monitor_watchdog;
  54    wd->destructor = job_monitor_destructor;
  55    wd->one_shot = false;
  56    wd->interval = 60;
  57    wd->data = new_control_jcr("*JobMonitor*", JT_SYSTEM);
  58    register_watchdog(wd);
  59 }
  60
  61 void term_job_server()
  62 {
  63    jobq_destroy(&job_queue);          /* ignore any errors */
  64 }
  65
  66 /*
  67  * Run a job -- typically called by the scheduler, but may also
  68  *              be called by the UA (Console program).
  69  *
  70  *  Returns: 0 on failure
  71  *           JobId on success
  72  *
  73  */
  74 JobId_t run_job(JCR *jcr)
  75 {
  76    int stat, errstat;
  77    JobId_t JobId = 0;
  78
  79    jcr->lock();
  80    sm_check(__FILE__, __LINE__, true);
  81    init_msg(jcr, jcr->messages);
  82
  83    /* Initialize termination condition variable */
  84    if ((errstat = pthread_cond_init(&jcr->term_wait, NULL)) != 0) {
  85       berrno be;
  86       Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.strerror(errstat));
  87       goto bail_out;
  88    }
  89    jcr->term_wait_inited = true;
  90
  91    create_unique_job_name(jcr, jcr->job->hdr.name);
  92    set_jcr_job_status(jcr, JS_Created);
  93    jcr->unlock();
  94
  95    /*
  96     * Open database
  97     */
  98    Dmsg0(50, "Open database\n");
  99    jcr->db=db_init_database(jcr, jcr->catalog->db_name, jcr->catalog->db_user,
 100                             jcr->catalog->db_password, jcr->catalog->db_address,
 101                             jcr->catalog->db_port, jcr->catalog->db_socket,
 102                             jcr->catalog->mult_db_connections);
 103    if (!jcr->db || !db_open_database(jcr, jcr->db)) {
 104       Jmsg(jcr, M_FATAL, 0, _("Could not open database \"%s\".\n"),
 105                  jcr->catalog->db_name);
 106       if (jcr->db) {
 107          Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 108       }
 109       goto bail_out;
 110    }
 111    Dmsg0(50, "DB opened\n");
 112
 113    /*
 114     * Create Job record
 115     */
 116    init_jcr_job_record(jcr);
 117    if (!db_create_job_record(jcr, jcr->db, &jcr->jr)) {
 118       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 119       goto bail_out;
 120    }
 121    JobId = jcr->JobId = jcr->jr.JobId;
 122    Dmsg4(100, "Created job record JobId=%d Name=%s Type=%c Level=%c\n",
 123        jcr->JobId, jcr->Job, jcr->jr.JobType, jcr->jr.JobLevel);
 124
 125    generate_daemon_event(jcr, "JobStart");
 126
 127    if (!get_or_create_client_record(jcr)) {
 128       goto bail_out;
 129    }
 130
 131    if (job_canceled(jcr)) {
 132       goto bail_out;
 133    }
 134
 135    Dmsg0(200, "Add jrc to work queue\n");
 136
 137    /* Queue the job to be run */
 138    if ((stat = jobq_add(&job_queue, jcr)) != 0) {
 139       berrno be;
 140       Jmsg(jcr, M_FATAL, 0, _("Could not add job queue: ERR=%s\n"), be.strerror(stat));
 141       JobId = 0;
 142       goto bail_out;
 143    }
 144    Dmsg0(100, "Done run_job()\n");
 145
 146    return JobId;
 147
 148 bail_out:
 149    if (jcr->fname) {
 150       free_memory(jcr->fname);
 151       jcr->fname = NULL;
 152    }
 153    return JobId;
 154 }
 155
 156
 157 /*
 158  * This is the engine called by jobq.c:jobq_add() when we were pulled
 159  *  from the work queue.
 160  *  At this point, we are running in our own thread and all
 161  *    necessary resources are allocated -- see jobq.c
 162  */
 163 static void *job_thread(void *arg)
 164 {
 165    JCR *jcr = (JCR *)arg;
 166
 167    jcr->my_thread_id = pthread_self();
 168    pthread_detach(jcr->my_thread_id);
 169    sm_check(__FILE__, __LINE__, true);
 170
 171    Dmsg0(200, "=====Start Job=========\n");
 172    jcr->start_time = time(NULL);      /* set the real start time */
 173    jcr->jr.StartTime = jcr->start_time;
 174
 175    if (jcr->job->MaxStartDelay != 0 && jcr->job->MaxStartDelay <
 176        (utime_t)(jcr->start_time - jcr->sched_time)) {
 177       Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n"));
 178       set_jcr_job_status(jcr, JS_Canceled);
 179    }
 180
 181    /*
 182     * Note, we continue, even if the job is canceled above. This
 183     *  will permit proper setting of the job start record and
 184     *  the error (cancel) will be picked up below.
 185     */
 186
 187    generate_job_event(jcr, "JobInit");
 188    set_jcr_job_status(jcr, JS_Running);   /* this will be set only if no error */
 189
 190    if (!jcr->fname) {
 191       jcr->fname = get_pool_memory(PM_FNAME);
 192    }
 193
 194    /*
 195     * Now, do pre-run stuff, like setting job level (Inc/diff, ...)
 196     *  this allows us to setup a proper job start record for restarting
 197     *  in case of later errors.
 198     */
 199    switch (jcr->JobType) {
 200    case JT_BACKUP:
 201       if (!do_backup_init(jcr)) {
 202          backup_cleanup(jcr, JS_ErrorTerminated);
 203       }
 204       break;
 205    case JT_VERIFY:
 206       if (!do_verify_init(jcr)) {
 207          verify_cleanup(jcr, JS_ErrorTerminated);
 208       }
 209       break;
 210    case JT_RESTORE:
 211       if (!do_restore_init(jcr)) {
 212          restore_cleanup(jcr, JS_ErrorTerminated);
 213       }
 214       break;
 215    case JT_ADMIN:
 216       if (!do_admin_init(jcr)) {
 217          admin_cleanup(jcr, JS_ErrorTerminated);
 218       }
 219       break;
 220    case JT_MIGRATE:
 221    case JT_COPY:
 222    case JT_ARCHIVE:
 223       if (!do_mac_init(jcr)) {             /* migration, archive, copy */
 224          mac_cleanup(jcr, JS_ErrorTerminated);
 225       }
 226       break;
 227    default:
 228       Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->JobType);
 229       set_jcr_job_status(jcr, JS_ErrorTerminated);
 230       break;
 231    }
 232
 233    if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
 234       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 235    }
 236
 237    if (job_canceled(jcr)) {
 238       update_job_end_record(jcr);
 239
 240    } else {
 241
 242       /* Run Job */
 243       if (jcr->job->RunBeforeJob) {
 244          POOLMEM *before = get_pool_memory(PM_FNAME);
 245          int status;
 246          BPIPE *bpipe;
 247          char line[MAXSTRING];
 248
 249          before = edit_job_codes(jcr, before, jcr->job->RunBeforeJob, "");
 250          bpipe = open_bpipe(before, 0, "r");
 251          free_pool_memory(before);
 252          while (fgets(line, sizeof(line), bpipe->rfd)) {
 253             Jmsg(jcr, M_INFO, 0, _("RunBefore: %s"), line);
 254          }
 255          status = close_bpipe(bpipe);
 256          if (status != 0) {
 257             berrno be;
 258             Jmsg(jcr, M_FATAL, 0, _("RunBeforeJob error: ERR=%s\n"), be.strerror(status));
 259             set_jcr_job_status(jcr, JS_FatalError);
 260             update_job_end_record(jcr);
 261             goto bail_out;
 262          }
 263       }
 264
 265       /*
 266        * We re-update the job start record so that the start
 267        *  time is set after the run before job.  This avoids
 268        *  that any files created by the run before job will
 269        *  be saved twice.  They will be backed up in the current
 270        *  job, but not in the next one unless they are changed.
 271        *  Without this, they will be backed up in this job and
 272        *  in the next job run because in that case, their date
 273        *   is after the start of this run.
 274        */
 275       jcr->start_time = time(NULL);
 276       jcr->jr.StartTime = jcr->start_time;
 277       if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
 278          Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 279       }
 280       generate_job_event(jcr, "JobRun");
 281
 282       switch (jcr->JobType) {
 283       case JT_BACKUP:
 284          if (do_backup(jcr)) {
 285             do_autoprune(jcr);
 286          } else {
 287             backup_cleanup(jcr, JS_ErrorTerminated);
 288          }
 289          break;
 290       case JT_VERIFY:
 291          if (do_verify(jcr)) {
 292             do_autoprune(jcr);
 293          } else {
 294             verify_cleanup(jcr, JS_ErrorTerminated);
 295          }
 296          break;
 297       case JT_RESTORE:
 298          if (do_restore(jcr)) {
 299             do_autoprune(jcr);
 300          } else {
 301             restore_cleanup(jcr, JS_ErrorTerminated);
 302          }
 303          break;
 304       case JT_ADMIN:
 305          if (do_admin(jcr)) {
 306             do_autoprune(jcr);
 307          } else {
 308             admin_cleanup(jcr, JS_ErrorTerminated);
 309          }
 310          break;
 311       case JT_MIGRATE:
 312       case JT_COPY:
 313       case JT_ARCHIVE:
 314          if (do_mac(jcr)) {              /* migration, archive, copy */
 315             do_autoprune(jcr);
 316          } else {
 317             mac_cleanup(jcr, JS_ErrorTerminated);
 318          }
 319          break;
 320       default:
 321          Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->JobType);
 322          break;
 323       }
 324       if ((jcr->job->RunAfterJob && jcr->JobStatus == JS_Terminated) ||
 325           (jcr->job->RunAfterFailedJob && jcr->JobStatus != JS_Terminated)) {
 326          POOLMEM *after = get_pool_memory(PM_FNAME);
 327          int status;
 328          BPIPE *bpipe;
 329          char line[MAXSTRING];
 330
 331          if (jcr->JobStatus == JS_Terminated) {
 332             after = edit_job_codes(jcr, after, jcr->job->RunAfterJob, "");
 333          } else {
 334             after = edit_job_codes(jcr, after, jcr->job->RunAfterFailedJob, "");
 335          }
 336          bpipe = open_bpipe(after, 0, "r");
 337          free_pool_memory(after);
 338          while (fgets(line, sizeof(line), bpipe->rfd)) {
 339             Jmsg(jcr, M_INFO, 0, _("RunAfter: %s"), line);
 340          }
 341          status = close_bpipe(bpipe);
 342          /*
 343           * Note, if we get an error here, do not mark the
 344           *  job in error, simply report the error condition.
 345           */
 346          if (status != 0) {
 347             berrno be;
 348             if (jcr->JobStatus == JS_Terminated) {
 349                Jmsg(jcr, M_WARNING, 0, _("RunAfterJob error: ERR=%s\n"), be.strerror(status));
 350             } else {
 351                Jmsg(jcr, M_FATAL, 0, _("RunAfterFailedJob error: ERR=%s\n"), be.strerror(status));
 352             }
 353          }
 354       }
 355       /* Send off any queued messages */
 356       if (jcr->msg_queue->size() > 0) {
 357          dequeue_messages(jcr);
 358       }
 359    }
 360
 361 bail_out:
 362    generate_daemon_event(jcr, "JobEnd");
 363    Dmsg1(50, "======== End Job stat=%c ==========\n", jcr->JobStatus);
 364    sm_check(__FILE__, __LINE__, true);
 365    return NULL;
 366 }
 367
 368
 369 /*
 370  * Cancel a job -- typically called by the UA (Console program), but may also
 371  *              be called by the job watchdog.
 372  *
 373  *  Returns: true  if cancel appears to be successful
 374  *           false on failure. Message sent to ua->jcr.
 375  */
 376 bool cancel_job(UAContext *ua, JCR *jcr)
 377 {
 378    BSOCK *sd, *fd;
 379
 380    set_jcr_job_status(jcr, JS_Canceled);
 381
 382    switch (jcr->JobStatus) {
 383    case JS_Created:
 384    case JS_WaitJobRes:
 385    case JS_WaitClientRes:
 386    case JS_WaitStoreRes:
 387    case JS_WaitPriority:
 388    case JS_WaitMaxJobs:
 389    case JS_WaitStartTime:
 390       bsendmsg(ua, _("JobId %d, Job %s marked to be canceled.\n"),
 391               jcr->JobId, jcr->Job);
 392       jobq_remove(&job_queue, jcr); /* attempt to remove it from queue */
 393       return true;
 394
 395    default:
 396
 397       /* Cancel File daemon */
 398       if (jcr->file_bsock) {
 399          ua->jcr->client = jcr->client;
 400          if (!connect_to_file_daemon(ua->jcr, 10, FDConnectTimeout, 1)) {
 401             bsendmsg(ua, _("Failed to connect to File daemon.\n"));
 402             return 0;
 403          }
 404          Dmsg0(200, "Connected to file daemon\n");
 405          fd = ua->jcr->file_bsock;
 406          bnet_fsend(fd, "cancel Job=%s\n", jcr->Job);
 407          while (bnet_recv(fd) >= 0) {
 408             bsendmsg(ua, "%s", fd->msg);
 409          }
 410          bnet_sig(fd, BNET_TERMINATE);
 411          bnet_close(fd);
 412          ua->jcr->file_bsock = NULL;
 413       }
 414
 415       /* Cancel Storage daemon */
 416       if (jcr->store_bsock) {
 417          if (!ua->jcr->storage) {
 418             copy_storage(ua->jcr, jcr);
 419          } else {
 420             set_storage(ua->jcr, jcr->store);
 421          }
 422          if (!connect_to_storage_daemon(ua->jcr, 10, SDConnectTimeout, 1)) {
 423             bsendmsg(ua, _("Failed to connect to Storage daemon.\n"));
 424             return false;
 425          }
 426          Dmsg0(200, "Connected to storage daemon\n");
 427          sd = ua->jcr->store_bsock;
 428          bnet_fsend(sd, "cancel Job=%s\n", jcr->Job);
 429          while (bnet_recv(sd) >= 0) {
 430             bsendmsg(ua, "%s", sd->msg);
 431          }
 432          bnet_sig(sd, BNET_TERMINATE);
 433          bnet_close(sd);
 434          ua->jcr->store_bsock = NULL;
 435       }
 436    }
 437
 438    return true;
 439 }
 440
 441
 442 static void job_monitor_destructor(watchdog_t *self)
 443 {
 444    JCR *control_jcr = (JCR *)self->data;
 445
 446    free_jcr(control_jcr);
 447 }
 448
 449 static void job_monitor_watchdog(watchdog_t *self)
 450 {
 451    JCR *control_jcr, *jcr;
 452
 453    control_jcr = (JCR *)self->data;
 454
 455    Dmsg1(800, "job_monitor_watchdog %p called\n", self);
 456
 457    foreach_jcr(jcr) {
 458       bool cancel;
 459
 460       if (jcr->JobId == 0) {
 461          Dmsg2(800, "Skipping JCR %p (%s) with JobId 0\n",
 462                jcr, jcr->Job);
 463          continue;
 464       }
 465
 466       /* check MaxWaitTime */
 467       cancel = job_check_maxwaittime(control_jcr, jcr);
 468
 469       /* check MaxRunTime */
 470       cancel |= job_check_maxruntime(control_jcr, jcr);
 471
 472       if (cancel) {
 473          Dmsg3(800, "Cancelling JCR %p jobid %d (%s)\n",
 474                jcr, jcr->JobId, jcr->Job);
 475
 476          UAContext *ua = new_ua_context(jcr);
 477          ua->jcr = control_jcr;
 478          cancel_job(ua, jcr);
 479          free_ua_context(ua);
 480
 481          Dmsg2(800, "Have cancelled JCR %p Job=%d\n", jcr, jcr->JobId);
 482       }
 483
 484       /* Keep reference counts correct */
 485    }
 486    endeach_jcr(jcr);
 487 }
 488
 489 /*
 490  * Check if the maxwaittime has expired and it is possible
 491  *  to cancel the job.
 492  */
 493 static bool job_check_maxwaittime(JCR *control_jcr, JCR *jcr)
 494 {
 495    bool cancel = false;
 496    bool ok_to_cancel = false;
 497    JOB *job = jcr->job;
 498
 499    if (job->MaxWaitTime == 0 && job->FullMaxWaitTime == 0 &&
 500        job->IncMaxWaitTime == 0 && job->DiffMaxWaitTime == 0) {
 501       return false;
 502    }
 503    if (jcr->JobLevel == L_FULL && job->FullMaxWaitTime != 0 &&
 504          (watchdog_time - jcr->start_time) >= job->FullMaxWaitTime) {
 505       ok_to_cancel = true;
 506    } else if (jcr->JobLevel == L_DIFFERENTIAL && job->DiffMaxWaitTime != 0 &&
 507          (watchdog_time - jcr->start_time) >= job->DiffMaxWaitTime) {
 508       ok_to_cancel = true;
 509    } else if (jcr->JobLevel == L_INCREMENTAL && job->IncMaxWaitTime != 0 &&
 510          (watchdog_time - jcr->start_time) >= job->IncMaxWaitTime) {
 511       ok_to_cancel = true;
 512    } else if (job->MaxWaitTime != 0 &&
 513          (watchdog_time - jcr->start_time) >= job->MaxWaitTime) {
 514       ok_to_cancel = true;
 515    }
 516    if (!ok_to_cancel) {
 517       return false;
 518    }
 519    Dmsg3(800, "Job %d (%s): MaxWaitTime of %d seconds exceeded, "
 520          "checking status\n",
 521          jcr->JobId, jcr->Job, job->MaxWaitTime);
 522    switch (jcr->JobStatus) {
 523    case JS_Created:
 524    case JS_Blocked:
 525    case JS_WaitFD:
 526    case JS_WaitSD:
 527    case JS_WaitStoreRes:
 528    case JS_WaitClientRes:
 529    case JS_WaitJobRes:
 530    case JS_WaitPriority:
 531    case JS_WaitMaxJobs:
 532    case JS_WaitStartTime:
 533       cancel = true;
 534       Dmsg0(200, "JCR blocked in #1\n");
 535       break;
 536    case JS_Running:
 537       Dmsg0(800, "JCR running, checking SD status\n");
 538       switch (jcr->SDJobStatus) {
 539       case JS_WaitMount:
 540       case JS_WaitMedia:
 541       case JS_WaitFD:
 542          cancel = true;
 543          Dmsg0(800, "JCR blocked in #2\n");
 544          break;
 545       default:
 546          Dmsg0(800, "JCR not blocked in #2\n");
 547          break;
 548       }
 549       break;
 550    case JS_Terminated:
 551    case JS_ErrorTerminated:
 552    case JS_Canceled:
 553    case JS_FatalError:
 554       Dmsg0(800, "JCR already dead in #3\n");
 555       break;
 556    default:
 557       Jmsg1(jcr, M_ERROR, 0, _("Unhandled job status code %d\n"),
 558             jcr->JobStatus);
 559    }
 560    Dmsg3(800, "MaxWaitTime result: %scancel JCR %p (%s)\n",
 561          cancel ? "" : "do not ", jcr, jcr->job);
 562
 563    return cancel;
 564 }
 565
 566 /*
 567  * Check if maxruntime has expired and if the job can be
 568  *   canceled.
 569  */
 570 static bool job_check_maxruntime(JCR *control_jcr, JCR *jcr)
 571 {
 572    bool cancel = false;
 573
 574    if (jcr->job->MaxRunTime == 0) {
 575       return false;
 576    }
 577    if ((watchdog_time - jcr->start_time) < jcr->job->MaxRunTime) {
 578       Dmsg3(200, "Job %p (%s) with MaxRunTime %d not expired\n",
 579             jcr, jcr->Job, jcr->job->MaxRunTime);
 580       return false;
 581    }
 582
 583    switch (jcr->JobStatus) {
 584    case JS_Created:
 585    case JS_Running:
 586    case JS_Blocked:
 587    case JS_WaitFD:
 588    case JS_WaitSD:
 589    case JS_WaitStoreRes:
 590    case JS_WaitClientRes:
 591    case JS_WaitJobRes:
 592    case JS_WaitPriority:
 593    case JS_WaitMaxJobs:
 594    case JS_WaitStartTime:
 595    case JS_Differences:
 596       cancel = true;
 597       break;
 598    case JS_Terminated:
 599    case JS_ErrorTerminated:
 600    case JS_Canceled:
 601    case JS_FatalError:
 602       cancel = false;
 603       break;
 604    default:
 605       Jmsg1(jcr, M_ERROR, 0, _("Unhandled job status code %d\n"),
 606             jcr->JobStatus);
 607    }
 608
 609    Dmsg3(200, "MaxRunTime result: %scancel JCR %p (%s)\n",
 610          cancel ? "" : "do not ", jcr, jcr->job);
 611
 612    return cancel;
 613 }
 614
 615
 616 /*
 617  * Get or create a Client record for this Job
 618  */
 619 bool get_or_create_client_record(JCR *jcr)
 620 {
 621    CLIENT_DBR cr;
 622
 623    memset(&cr, 0, sizeof(cr));
 624    bstrncpy(cr.Name, jcr->client->hdr.name, sizeof(cr.Name));
 625    cr.AutoPrune = jcr->client->AutoPrune;
 626    cr.FileRetention = jcr->client->FileRetention;
 627    cr.JobRetention = jcr->client->JobRetention;
 628    if (!jcr->client_name) {
 629       jcr->client_name = get_pool_memory(PM_NAME);
 630    }
 631    pm_strcpy(jcr->client_name, jcr->client->hdr.name);
 632    if (!db_create_client_record(jcr, jcr->db, &cr)) {
 633       Jmsg(jcr, M_FATAL, 0, _("Could not create Client record. ERR=%s\n"),
 634          db_strerror(jcr->db));
 635       return false;
 636    }
 637    jcr->jr.ClientId = cr.ClientId;
 638    if (cr.Uname[0]) {
 639       if (!jcr->client_uname) {
 640          jcr->client_uname = get_pool_memory(PM_NAME);
 641       }
 642       pm_strcpy(jcr->client_uname, cr.Uname);
 643    }
 644    Dmsg2(100, "Created Client %s record %d\n", jcr->client->hdr.name,
 645       jcr->jr.ClientId);
 646    return true;
 647 }
 648
 649 bool get_or_create_fileset_record(JCR *jcr)
 650 {
 651    FILESET_DBR fsr;
 652    /*
 653     * Get or Create FileSet record
 654     */
 655    memset(&fsr, 0, sizeof(FILESET_DBR));
 656    bstrncpy(fsr.FileSet, jcr->fileset->hdr.name, sizeof(fsr.FileSet));
 657    if (jcr->fileset->have_MD5) {
 658       struct MD5Context md5c;
 659       unsigned char signature[16];
 660       memcpy(&md5c, &jcr->fileset->md5c, sizeof(md5c));
 661       MD5Final(signature, &md5c);
 662       bin_to_base64(fsr.MD5, (char *)signature, 16); /* encode 16 bytes */
 663       bstrncpy(jcr->fileset->MD5, fsr.MD5, sizeof(jcr->fileset->MD5));
 664    } else {
 665       Jmsg(jcr, M_WARNING, 0, _("FileSet MD5 signature not found.\n"));
 666    }
 667    if (!jcr->fileset->ignore_fs_changes ||
 668        !db_get_fileset_record(jcr, jcr->db, &fsr)) {
 669       if (!db_create_fileset_record(jcr, jcr->db, &fsr)) {
 670          Jmsg(jcr, M_ERROR, 0, _("Could not create FileSet \"%s\" record. ERR=%s\n"),
 671             fsr.FileSet, db_strerror(jcr->db));
 672          return false;
 673       }
 674    }
 675    jcr->jr.FileSetId = fsr.FileSetId;
 676    bstrncpy(jcr->FSCreateTime, fsr.cCreateTime, sizeof(jcr->FSCreateTime));
 677    Dmsg2(119, "Created FileSet %s record %u\n", jcr->fileset->hdr.name,
 678       jcr->jr.FileSetId);
 679    return true;
 680 }
 681
 682 void init_jcr_job_record(JCR *jcr)
 683 {
 684    jcr->jr.SchedTime = jcr->sched_time;
 685    jcr->jr.StartTime = jcr->start_time;
 686    jcr->jr.EndTime = 0;               /* perhaps rescheduled, clear it */
 687    jcr->jr.JobType = jcr->JobType;
 688    jcr->jr.JobLevel = jcr->JobLevel;
 689    jcr->jr.JobStatus = jcr->JobStatus;
 690    jcr->jr.JobId = jcr->JobId;
 691    bstrncpy(jcr->jr.Name, jcr->job->hdr.name, sizeof(jcr->jr.Name));
 692    bstrncpy(jcr->jr.Job, jcr->Job, sizeof(jcr->jr.Job));
 693 }
 694
 695 /*
 696  * Write status and such in DB
 697  */
 698 void update_job_end_record(JCR *jcr)
 699 {
 700    jcr->jr.EndTime = time(NULL);
 701    jcr->end_time = jcr->jr.EndTime;
 702    jcr->jr.JobId = jcr->JobId;
 703    jcr->jr.JobStatus = jcr->JobStatus;
 704    jcr->jr.JobFiles = jcr->JobFiles;
 705    jcr->jr.JobBytes = jcr->JobBytes;
 706    jcr->jr.VolSessionId = jcr->VolSessionId;
 707    jcr->jr.VolSessionTime = jcr->VolSessionTime;
 708    if (!db_update_job_end_record(jcr, jcr->db, &jcr->jr)) {
 709       Jmsg(jcr, M_WARNING, 0, _("Error updating job record. %s"),
 710          db_strerror(jcr->db));
 711    }
 712 }
 713
 714 /*
 715  * Takes base_name and appends (unique) current
 716  *   date and time to form unique job name.
 717  *
 718  *  Returns: unique job name in jcr->Job
 719  *    date/time in jcr->start_time
 720  */
 721 void create_unique_job_name(JCR *jcr, const char *base_name)
 722 {
 723    /* Job start mutex */
 724    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 725    static time_t last_start_time = 0;
 726    time_t now;
 727    struct tm tm;
 728    char dt[MAX_TIME_LENGTH];
 729    char name[MAX_NAME_LENGTH];
 730    char *p;
 731
 732    /* Guarantee unique start time -- maximum one per second, and
 733     * thus unique Job Name
 734     */
 735    P(mutex);                          /* lock creation of jobs */
 736    now = time(NULL);
 737    while (now == last_start_time) {
 738       bmicrosleep(0, 500000);
 739       now = time(NULL);
 740    }
 741    last_start_time = now;
 742    V(mutex);                          /* allow creation of jobs */
 743    jcr->start_time = now;
 744    /* Form Unique JobName */
 745    localtime_r(&now, &tm);
 746    /* Use only characters that are permitted in Windows filenames */
 747    strftime(dt, sizeof(dt), "%Y-%m-%d_%H.%M.%S", &tm);
 748    bstrncpy(name, base_name, sizeof(name));
 749    name[sizeof(name)-22] = 0;          /* truncate if too long */
 750    bsnprintf(jcr->Job, sizeof(jcr->Job), "%s.%s", name, dt); /* add date & time */
 751    /* Convert spaces into underscores */
 752    for (p=jcr->Job; *p; p++) {
 753       if (*p == ' ') {
 754          *p = '_';
 755       }
 756    }
 757 }
 758
 759 /* Called directly from job rescheduling */
 760 void dird_free_jcr_pointers(JCR *jcr)
 761 {
 762    if (jcr->sd_auth_key) {
 763       free(jcr->sd_auth_key);
 764       jcr->sd_auth_key = NULL;
 765    }
 766    if (jcr->where) {
 767       free(jcr->where);
 768       jcr->where = NULL;
 769    }
 770    if (jcr->file_bsock) {
 771       Dmsg0(200, "Close File bsock\n");
 772       bnet_close(jcr->file_bsock);
 773       jcr->file_bsock = NULL;
 774    }
 775    if (jcr->store_bsock) {
 776       Dmsg0(200, "Close Store bsock\n");
 777       bnet_close(jcr->store_bsock);
 778       jcr->store_bsock = NULL;
 779    }
 780    if (jcr->fname) {
 781       Dmsg0(200, "Free JCR fname\n");
 782       free_pool_memory(jcr->fname);
 783       jcr->fname = NULL;
 784    }
 785    if (jcr->stime) {
 786       Dmsg0(200, "Free JCR stime\n");
 787       free_pool_memory(jcr->stime);
 788       jcr->stime = NULL;
 789    }
 790    if (jcr->RestoreBootstrap) {
 791       free(jcr->RestoreBootstrap);
 792       jcr->RestoreBootstrap = NULL;
 793    }
 794    if (jcr->client_uname) {
 795       free_pool_memory(jcr->client_uname);
 796       jcr->client_uname = NULL;
 797    }
 798    if (jcr->term_wait_inited) {
 799       pthread_cond_destroy(&jcr->term_wait);
 800       jcr->term_wait_inited = false;
 801    }
 802    if (jcr->attr) {
 803       free_pool_memory(jcr->attr);
 804       jcr->attr = NULL;
 805    }
 806    if (jcr->ar) {
 807       free(jcr->ar);
 808       jcr->ar = NULL;
 809    }
 810 }
 811
 812 /*
 813  * Free the Job Control Record if no one is still using it.
 814  *  Called from main free_jcr() routine in src/lib/jcr.c so
 815  *  that we can do our Director specific cleanup of the jcr.
 816  */
 817 void dird_free_jcr(JCR *jcr)
 818 {
 819    Dmsg0(200, "Start dird free_jcr\n");
 820
 821    dird_free_jcr_pointers(jcr);
 822
 823    /* Delete lists setup to hold storage pointers */
 824    if (jcr->storage) {
 825       delete jcr->storage;
 826    }
 827    jcr->job_end_push.destroy();
 828    Dmsg0(200, "End dird free_jcr\n");
 829 }
 830
 831 /*
 832  * Set some defaults in the JCR necessary to
 833  * run. These items are pulled from the job
 834  * definition as defaults, but can be overridden
 835  * later either by the Run record in the Schedule resource,
 836  * or by the Console program.
 837  */
 838 void set_jcr_defaults(JCR *jcr, JOB *job)
 839 {
 840    STORE *st;
 841    jcr->job = job;
 842    jcr->JobType = job->JobType;
 843    switch (jcr->JobType) {
 844    case JT_ADMIN:
 845    case JT_RESTORE:
 846       jcr->JobLevel = L_NONE;
 847       break;
 848    default:
 849       jcr->JobLevel = job->JobLevel;
 850       break;
 851    }
 852    jcr->JobPriority = job->Priority;
 853    /* Copy storage definitions -- deleted in dir_free_jcr above */
 854    if (job->storage) {
 855       if (jcr->storage) {
 856          delete jcr->storage;
 857       }
 858       jcr->storage = New(alist(10, not_owned_by_alist));
 859       foreach_alist(st, job->storage) {
 860          jcr->storage->append(st);
 861       }
 862    }
 863    if (jcr->storage) {
 864       jcr->store = (STORE *)jcr->storage->first();
 865    }
 866    jcr->client = job->client;
 867    if (!jcr->client_name) {
 868       jcr->client_name = get_pool_memory(PM_NAME);
 869    }
 870    pm_strcpy(jcr->client_name, jcr->client->hdr.name);
 871    jcr->pool = job->pool;
 872    jcr->full_pool = job->full_pool;
 873    jcr->inc_pool = job->inc_pool;
 874    jcr->dif_pool = job->dif_pool;
 875    jcr->catalog = job->client->catalog;
 876    jcr->fileset = job->fileset;
 877    jcr->messages = job->messages;
 878    jcr->spool_data = job->spool_data;
 879    jcr->write_part_after_job = job->write_part_after_job;
 880    if (jcr->RestoreBootstrap) {
 881       free(jcr->RestoreBootstrap);
 882       jcr->RestoreBootstrap = NULL;
 883    }
 884    /* This can be overridden by Console program */
 885    if (job->RestoreBootstrap) {
 886       jcr->RestoreBootstrap = bstrdup(job->RestoreBootstrap);
 887    }
 888    /* This can be overridden by Console program */
 889    jcr->verify_job = job->verify_job;
 890    /* If no default level given, set one */
 891    if (jcr->JobLevel == 0) {
 892       switch (jcr->JobType) {
 893       case JT_VERIFY:
 894          jcr->JobLevel = L_VERIFY_CATALOG;
 895          break;
 896       case JT_BACKUP:
 897          jcr->JobLevel = L_INCREMENTAL;
 898          break;
 899       case JT_RESTORE:
 900       case JT_ADMIN:
 901          jcr->JobLevel = L_NONE;
 902          break;
 903       default:
 904          break;
 905       }
 906    }
 907 }
 908
 909 /*
 910  * copy the storage definitions from an old JCR to a new one
 911  */
 912 void copy_storage(JCR *new_jcr, JCR *old_jcr)
 913 {
 914    if (old_jcr->storage) {
 915       STORE *st;
 916       if (new_jcr->storage) {
 917          delete new_jcr->storage;
 918       }
 919       new_jcr->storage = New(alist(10, not_owned_by_alist));
 920       foreach_alist(st, old_jcr->storage) {
 921          new_jcr->storage->append(st);
 922       }
 923    }
 924    if (old_jcr->store) {
 925       new_jcr->store = old_jcr->store;
 926    } else if (new_jcr->storage) {
 927       new_jcr->store = (STORE *)new_jcr->storage->first();
 928    }
 929 }
 930
 931 /* Set storage override */
 932 void set_storage(JCR *jcr, STORE *store)
 933 {
 934    STORE *storage;
 935
 936    jcr->store = store;
 937    foreach_alist(storage, jcr->storage) {
 938       if (store == storage) {
 939          return;
 940       }
 941    }
 942    /* Store not in list, so add it */
 943    jcr->storage->prepend(store);
 944 }