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