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-2003 Kern Sibbald and John Walker
  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 as
  14    published by the Free Software Foundation; either version 2 of
  15    the License, or (at your option) any later version.
  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 GNU
  20    General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public
  23    License along with this program; if not, write to the Free
  24    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25    MA 02111-1307, USA.
  26
  27  */
  28
  29 #include "bacula.h"
  30 #include "dird.h"
  31
  32 /* Forward referenced subroutines */
  33 static void *job_thread(void *arg);
  34 static char *edit_run_codes(JCR *jcr, char *omsg, char *imsg);
  35 static void release_resource_locks(JCR *jcr);
  36 static int acquire_resource_locks(JCR *jcr);
  37 #ifdef USE_SEMAPHORE
  38 static void backoff_resource_locks(JCR *jcr, int count);
  39 #endif
  40
  41 /* Exported subroutines */
  42 void run_job(JCR *jcr);
  43
  44
  45 /* Imported subroutines */
  46 extern void term_scheduler();
  47 extern void term_ua_server();
  48 extern int do_backup(JCR *jcr);
  49 extern int do_admin(JCR *jcr);
  50 extern int do_restore(JCR *jcr);
  51 extern int do_verify(JCR *jcr);
  52
  53 #ifdef USE_SEMAPHORE
  54 static semlock_t job_lock;
  55 static pthread_mutex_t mutex;
  56 static pthread_cond_t  resource_wait;
  57 static int waiting = 0;               /* count of waiting threads */
  58 #else
  59 #ifdef JOB_QUEUE
  60 jobq_t  job_queue;
  61 #else
  62 /* Queue of jobs to be run */
  63 workq_t job_wq;                   /* our job work queue */
  64 #endif
  65 #endif
  66
  67 void init_job_server(int max_workers)
  68 {
  69    int stat;
  70 #ifdef USE_SEMAPHORE
  71    if ((stat = sem_init(&job_lock, max_workers)) != 0) {
  72       Emsg1(M_ABORT, 0, _("Could not init job lock: ERR=%s\n"), strerror(stat));
  73    }
  74    if ((stat = pthread_mutex_init(&mutex, NULL)) != 0) {
  75       Emsg1(M_ABORT, 0, _("Could not init resource mutex: ERR=%s\n"), strerror(stat));
  76    }
  77    if ((stat = pthread_cond_init(&resource_wait, NULL)) != 0) {
  78       Emsg1(M_ABORT, 0, _("Could not init resource wait: ERR=%s\n"), strerror(stat));
  79    }
  80
  81 #else
  82 #ifdef JOB_QUEUE
  83    if ((stat = job_init(&job_queue, max_workers, job_thread)) != 0) {
  84       Emsg1(M_ABORT, 0, _("Could not init job queue: ERR=%s\n"), strerror(stat));
  85    }
  86 #else
  87    /* This is the OLD work queue code to go away */
  88    if ((stat = workq_init(&job_wq, max_workers, job_thread)) != 0) {
  89       Emsg1(M_ABORT, 0, _("Could not init job work queue: ERR=%s\n"), strerror(stat));
  90    }
  91 #endif
  92 #endif
  93    return;
  94 }
  95
  96 /*
  97  * Run a job -- typically called by the scheduler, but may also
  98  *              be called by the UA (Console program).
  99  *
 100  */
 101 void run_job(JCR *jcr)
 102 {
 103    int stat, errstat;
 104 #ifdef USE_SEMAPHORE
 105    pthread_t tid;
 106 #else
 107 #ifndef JOB_QUEUE
 108    workq_ele_t *work_item;
 109 #endif
 110 #endif
 111
 112    sm_check(__FILE__, __LINE__, True);
 113    init_msg(jcr, jcr->messages);
 114    create_unique_job_name(jcr, jcr->job->hdr.name);
 115    set_jcr_job_status(jcr, JS_Created);
 116    jcr->jr.SchedTime = jcr->sched_time;
 117    jcr->jr.StartTime = jcr->start_time;
 118    jcr->jr.Type = jcr->JobType;
 119    jcr->jr.Level = jcr->JobLevel;
 120    jcr->jr.JobStatus = jcr->JobStatus;
 121    bstrncpy(jcr->jr.Name, jcr->job->hdr.name, sizeof(jcr->jr.Name));
 122    bstrncpy(jcr->jr.Job, jcr->Job, sizeof(jcr->jr.Job));
 123
 124    /* Initialize termination condition variable */
 125    if ((errstat = pthread_cond_init(&jcr->term_wait, NULL)) != 0) {
 126       Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), strerror(errstat));
 127       set_jcr_job_status(jcr, JS_ErrorTerminated);
 128       free_jcr(jcr);
 129       return;
 130    }
 131
 132    /*
 133     * Open database
 134     */
 135    Dmsg0(50, "Open database\n");
 136    jcr->db=db_init_database(jcr, jcr->catalog->db_name, jcr->catalog->db_user,
 137                             jcr->catalog->db_password, jcr->catalog->db_address,
 138                             jcr->catalog->db_port, jcr->catalog->db_socket);
 139    if (!db_open_database(jcr, jcr->db)) {
 140       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 141       set_jcr_job_status(jcr, JS_ErrorTerminated);
 142       free_jcr(jcr);
 143       return;
 144    }
 145    Dmsg0(50, "DB opened\n");
 146
 147    /*
 148     * Create Job record
 149     */
 150    jcr->jr.JobStatus = jcr->JobStatus;
 151    if (!db_create_job_record(jcr, jcr->db, &jcr->jr)) {
 152       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 153       set_jcr_job_status(jcr, JS_ErrorTerminated);
 154       free_jcr(jcr);
 155       return;
 156    }
 157    jcr->JobId = jcr->jr.JobId;
 158    ASSERT(jcr->jr.JobId > 0);
 159
 160    Dmsg4(30, "Created job record JobId=%d Name=%s Type=%c Level=%c\n",
 161        jcr->JobId, jcr->Job, jcr->jr.Type, jcr->jr.Level);
 162    Dmsg0(200, "Add jrc to work queue\n");
 163
 164 #ifdef USE_SEMAPHORE
 165   if ((stat = pthread_create(&tid, NULL, job_thread, (void *)jcr)) != 0) {
 166       Emsg1(M_ABORT, 0, _("Unable to create job thread: ERR=%s\n"), strerror(stat));
 167    }
 168 #else
 169 #ifdef JOB_QUEUE
 170    /* Queue the job to be run */
 171    if ((stat = jobq_add(&job_queue, jcr)) != 0) {
 172       Emsg1(M_ABORT, 0, _("Could not add job queue: ERR=%s\n"), strerror(stat));
 173    }
 174 #else
 175    /* Queue the job to be run */
 176    if ((stat = workq_add(&job_wq, (void *)jcr, &work_item, 0)) != 0) {
 177       Emsg1(M_ABORT, 0, _("Could not add job to work queue: ERR=%s\n"), strerror(stat));
 178    }
 179    jcr->work_item = work_item;
 180 #endif
 181 #endif
 182    Dmsg0(200, "Done run_job()\n");
 183 }
 184
 185 /*
 186  * This is the engine called by workq_add() when we were pulled
 187  *  from the work queue.
 188  *  At this point, we are running in our own thread
 189  */
 190 static void *job_thread(void *arg)
 191 {
 192    JCR *jcr = (JCR *)arg;
 193
 194    pthread_detach(pthread_self());
 195    sm_check(__FILE__, __LINE__, True);
 196
 197    for ( ;; ) {
 198       if (!acquire_resource_locks(jcr)) {
 199          set_jcr_job_status(jcr, JS_Canceled);
 200       }
 201
 202       Dmsg0(200, "=====Start Job=========\n");
 203       jcr->start_time = time(NULL);      /* set the real start time */
 204       set_jcr_job_status(jcr, JS_Running);
 205
 206       if (job_canceled(jcr)) {
 207          update_job_end_record(jcr);
 208       } else if (jcr->job->MaxStartDelay != 0 && jcr->job->MaxStartDelay <
 209           (utime_t)(jcr->start_time - jcr->sched_time)) {
 210          Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n"));
 211          set_jcr_job_status(jcr, JS_Canceled);
 212          update_job_end_record(jcr);
 213       } else {
 214
 215          /* Run Job */
 216          if (jcr->job->RunBeforeJob) {
 217             POOLMEM *before = get_pool_memory(PM_FNAME);
 218             int status;
 219             BPIPE *bpipe;
 220             char line[MAXSTRING];
 221
 222             before = edit_run_codes(jcr, before, jcr->job->RunBeforeJob);
 223             bpipe = open_bpipe(before, 0, "r");
 224             free_pool_memory(before);
 225             while (fgets(line, sizeof(line), bpipe->rfd)) {
 226                Jmsg(jcr, M_INFO, 0, _("RunBefore: %s"), line);
 227             }
 228             status = close_bpipe(bpipe);
 229             if (status != 0) {
 230                Jmsg(jcr, M_FATAL, 0, _("RunBeforeJob returned non-zero status=%d\n"),
 231                   status);
 232                set_jcr_job_status(jcr, JS_FatalError);
 233                update_job_end_record(jcr);
 234                goto bail_out;
 235             }
 236          }
 237          switch (jcr->JobType) {
 238          case JT_BACKUP:
 239             do_backup(jcr);
 240             if (jcr->JobStatus == JS_Terminated) {
 241                do_autoprune(jcr);
 242             }
 243             break;
 244          case JT_VERIFY:
 245             do_verify(jcr);
 246             if (jcr->JobStatus == JS_Terminated) {
 247                do_autoprune(jcr);
 248             }
 249             break;
 250          case JT_RESTORE:
 251             do_restore(jcr);
 252             if (jcr->JobStatus == JS_Terminated) {
 253                do_autoprune(jcr);
 254             }
 255             break;
 256          case JT_ADMIN:
 257             do_admin(jcr);
 258             if (jcr->JobStatus == JS_Terminated) {
 259                do_autoprune(jcr);
 260             }
 261             break;
 262          default:
 263             Pmsg1(0, "Unimplemented job type: %d\n", jcr->JobType);
 264             break;
 265          }
 266          if (jcr->job->RunAfterJob) {
 267             POOLMEM *after = get_pool_memory(PM_FNAME);
 268             int status;
 269             BPIPE *bpipe;
 270             char line[MAXSTRING];
 271
 272             after = edit_run_codes(jcr, after, jcr->job->RunAfterJob);
 273             bpipe = open_bpipe(after, 0, "r");
 274             free_pool_memory(after);
 275             while (fgets(line, sizeof(line), bpipe->rfd)) {
 276                Jmsg(jcr, M_INFO, 0, _("RunAfter: %s"), line);
 277             }
 278             status = close_bpipe(bpipe);
 279             if (status != 0) {
 280                Jmsg(jcr, M_FATAL, 0, _("RunAfterJob returned non-zero status=%d\n"),
 281                   status);
 282                set_jcr_job_status(jcr, JS_FatalError);
 283                update_job_end_record(jcr);
 284             }
 285          }
 286       }
 287 bail_out:
 288       release_resource_locks(jcr);
 289       if (jcr->job->RescheduleOnError &&
 290           jcr->JobStatus != JS_Terminated &&
 291           jcr->JobStatus != JS_Canceled &&
 292           jcr->job->RescheduleTimes > 0 &&
 293           jcr->reschedule_count < jcr->job->RescheduleTimes) {
 294
 295           /*
 296            * Reschedule this job by cleaning it up, but
 297            *  reuse the same JobId if possible.
 298            */
 299          jcr->reschedule_count++;
 300          jcr->sched_time = time(NULL) + jcr->job->RescheduleInterval;
 301          Dmsg2(100, "Rescheduled Job %s to re-run in %d seconds.\n", jcr->Job,
 302             (int)jcr->job->RescheduleInterval);
 303          jcr->JobStatus = JS_Created; /* force new status */
 304          dird_free_jcr(jcr);          /* partial cleanup old stuff */
 305          if (jcr->JobBytes == 0) {
 306             continue;                    /* reschedule the job */
 307          }
 308          /*
 309           * Something was actually backed up, so we cannot reuse
 310           *   the old JobId or there will be database record
 311           *   conflicts.  We now create a new job, copying the
 312           *   appropriate fields.
 313           */
 314          JCR *njcr = new_jcr(sizeof(JCR), dird_free_jcr);
 315          set_jcr_defaults(njcr, jcr->job);
 316          njcr->reschedule_count = jcr->reschedule_count;
 317          njcr->JobLevel = jcr->JobLevel;
 318          njcr->JobStatus = jcr->JobStatus;
 319          njcr->pool = jcr->pool;
 320          njcr->store = jcr->store;
 321          njcr->messages = jcr->messages;
 322          run_job(njcr);
 323       }
 324       break;
 325    }
 326
 327    if (jcr->db) {
 328       Dmsg0(200, "Close DB\n");
 329       db_close_database(jcr, jcr->db);
 330       jcr->db = NULL;
 331    }
 332    free_jcr(jcr);
 333    Dmsg0(50, "======== End Job ==========\n");
 334    sm_check(__FILE__, __LINE__, True);
 335    return NULL;
 336 }
 337
 338 /*
 339  * Acquire the resources needed. These locks limit the
 340  *  number of jobs by each resource. We have limits on
 341  *  Jobs, Clients, Storage, and total jobs.
 342  */
 343 static int acquire_resource_locks(JCR *jcr)
 344 {
 345    time_t now = time(NULL);
 346    time_t wtime = jcr->sched_time - now;
 347
 348    /* Wait until scheduled time arrives */
 349    if (wtime > 0 && verbose) {
 350       Jmsg(jcr, M_INFO, 0, _("Job %s waiting %d seconds for scheduled start time.\n"),
 351          jcr->Job, wtime);
 352       set_jcr_job_status(jcr, JS_WaitStartTime);
 353    }
 354    /* Check every 30 seconds if canceled */
 355    while (wtime > 0) {
 356       Dmsg2(100, "Waiting on sched time, jobid=%d secs=%d\n", jcr->JobId, wtime);
 357       if (wtime > 30) {
 358          wtime = 30;
 359       }
 360       bmicrosleep(wtime, 0);
 361       if (job_canceled(jcr)) {
 362          return 0;
 363       }
 364       wtime = jcr->sched_time - time(NULL);
 365    }
 366
 367
 368 #ifdef USE_SEMAPHORE
 369    int stat;
 370
 371    /* Initialize semaphores */
 372    if (jcr->store->sem.valid != SEMLOCK_VALID) {
 373       if ((stat = sem_init(&jcr->store->sem, jcr->store->MaxConcurrentJobs)) != 0) {
 374          Emsg1(M_ABORT, 0, _("Could not init Storage semaphore: ERR=%s\n"), strerror(stat));
 375       }
 376    }
 377    if (jcr->client->sem.valid != SEMLOCK_VALID) {
 378       if ((stat = sem_init(&jcr->client->sem, jcr->client->MaxConcurrentJobs)) != 0) {
 379          Emsg1(M_ABORT, 0, _("Could not init Client semaphore: ERR=%s\n"), strerror(stat));
 380       }
 381    }
 382    if (jcr->job->sem.valid != SEMLOCK_VALID) {
 383       if ((stat = sem_init(&jcr->job->sem, jcr->job->MaxConcurrentJobs)) != 0) {
 384          Emsg1(M_ABORT, 0, _("Could not init Job semaphore: ERR=%s\n"), strerror(stat));
 385       }
 386    }
 387
 388    for ( ;; ) {
 389       /* Acquire semaphore */
 390       set_jcr_job_status(jcr, JS_WaitJobRes);
 391       if ((stat = sem_lock(&jcr->job->sem)) != 0) {
 392          Emsg1(M_ABORT, 0, _("Could not acquire Job max jobs lock: ERR=%s\n"), strerror(stat));
 393       }
 394       set_jcr_job_status(jcr, JS_WaitClientRes);
 395       if ((stat = sem_trylock(&jcr->client->sem)) != 0) {
 396          if (stat == EBUSY) {
 397             backoff_resource_locks(jcr, 1);
 398             goto wait;
 399          } else {
 400             Emsg1(M_ABORT, 0, _("Could not acquire Client max jobs lock: ERR=%s\n"), strerror(stat));
 401          }
 402       }
 403       set_jcr_job_status(jcr, JS_WaitStoreRes);
 404       if ((stat = sem_trylock(&jcr->store->sem)) != 0) {
 405          if (stat == EBUSY) {
 406             backoff_resource_locks(jcr, 2);
 407             goto wait;
 408          } else {
 409             Emsg1(M_ABORT, 0, _("Could not acquire Storage max jobs lock: ERR=%s\n"), strerror(stat));
 410          }
 411       }
 412       set_jcr_job_status(jcr, JS_WaitMaxJobs);
 413       if ((stat = sem_trylock(&job_lock)) != 0) {
 414          if (stat == EBUSY) {
 415             backoff_resource_locks(jcr, 3);
 416             goto wait;
 417          } else {
 418             Emsg1(M_ABORT, 0, _("Could not acquire max jobs lock: ERR=%s\n"), strerror(stat));
 419          }
 420       }
 421       break;
 422
 423 wait:
 424       if (job_canceled(jcr)) {
 425          return 0;
 426       }
 427       P(mutex);
 428       /*
 429        * Wait for a resource to be released either by backoff or
 430        *  by a job terminating.
 431        */
 432       waiting++;
 433       pthread_cond_wait(&resource_wait, &mutex);
 434       waiting--;
 435       V(mutex);
 436       /* Try again */
 437    }
 438    jcr->acquired_resource_locks = true;
 439 #endif
 440    return 1;
 441 }
 442
 443 #ifdef USE_SEMAPHORE
 444 /*
 445  * We could not get all the resource locks because
 446  *  too many jobs are running, so release any locks
 447  *  we did acquire, giving others a chance to use them
 448  *  while we wait.
 449  */
 450 static void backoff_resource_locks(JCR *jcr, int count)
 451 {
 452    P(mutex);
 453    switch (count) {
 454    case 3:
 455       sem_unlock(&jcr->store->sem);
 456       /* Fall through wanted */
 457    case 2:
 458       sem_unlock(&jcr->client->sem);
 459       /* Fall through wanted */
 460    case 1:
 461       sem_unlock(&jcr->job->sem);
 462       break;
 463    }
 464    /*
 465     * Since we released a lock, if there are any threads
 466     *  waiting, wake them up so that they can try again.
 467     */
 468    if (waiting > 0) {
 469       pthread_cond_broadcast(&resource_wait);
 470    }
 471    V(mutex);
 472 }
 473 #endif
 474
 475 /*
 476  * This is called at the end of the job to release
 477  *   any resource limits on the number of jobs. If
 478  *   there are any other jobs waiting, we wake them
 479  *   up so that they can try again.
 480  */
 481 static void release_resource_locks(JCR *jcr)
 482 {
 483    if (!jcr->acquired_resource_locks) {
 484       return;                         /* Job canceled, no locks acquired */
 485    }
 486 #ifdef USE_SEMAPHORE
 487    P(mutex);
 488    sem_unlock(&jcr->store->sem);
 489    sem_unlock(&jcr->client->sem);
 490    sem_unlock(&jcr->job->sem);
 491    sem_unlock(&job_lock);
 492    if (waiting > 0) {
 493       pthread_cond_broadcast(&resource_wait);
 494    }
 495    jcr->acquired_resource_locks = false;
 496    V(mutex);
 497 #endif
 498 }
 499
 500 /*
 501  * Get or create a Client record for this Job
 502  */
 503 int get_or_create_client_record(JCR *jcr)
 504 {
 505    CLIENT_DBR cr;
 506
 507    memset(&cr, 0, sizeof(cr));
 508    bstrncpy(cr.Name, jcr->client->hdr.name, sizeof(cr.Name));
 509    cr.AutoPrune = jcr->client->AutoPrune;
 510    cr.FileRetention = jcr->client->FileRetention;
 511    cr.JobRetention = jcr->client->JobRetention;
 512    if (!jcr->client_name) {
 513       jcr->client_name = get_pool_memory(PM_NAME);
 514    }
 515    pm_strcpy(&jcr->client_name, jcr->client->hdr.name);
 516    if (!db_create_client_record(jcr, jcr->db, &cr)) {
 517       Jmsg(jcr, M_FATAL, 0, _("Could not create Client record. ERR=%s\n"),
 518          db_strerror(jcr->db));
 519       return 0;
 520    }
 521    jcr->jr.ClientId = cr.ClientId;
 522    if (cr.Uname[0]) {
 523       if (!jcr->client_uname) {
 524          jcr->client_uname = get_pool_memory(PM_NAME);
 525       }
 526       pm_strcpy(&jcr->client_uname, cr.Uname);
 527    }
 528    Dmsg2(100, "Created Client %s record %d\n", jcr->client->hdr.name,
 529       jcr->jr.ClientId);
 530    return 1;
 531 }
 532
 533
 534 /*
 535  * Write status and such in DB
 536  */
 537 void update_job_end_record(JCR *jcr)
 538 {
 539    if (jcr->jr.EndTime == 0) {
 540       jcr->jr.EndTime = time(NULL);
 541    }
 542    jcr->end_time = jcr->jr.EndTime;
 543    jcr->jr.JobId = jcr->JobId;
 544    jcr->jr.JobStatus = jcr->JobStatus;
 545    jcr->jr.JobFiles = jcr->JobFiles;
 546    jcr->jr.JobBytes = jcr->JobBytes;
 547    jcr->jr.VolSessionId = jcr->VolSessionId;
 548    jcr->jr.VolSessionTime = jcr->VolSessionTime;
 549    if (!db_update_job_end_record(jcr, jcr->db, &jcr->jr)) {
 550       Jmsg(jcr, M_WARNING, 0, _("Error updating job record. %s"),
 551          db_strerror(jcr->db));
 552    }
 553 }
 554
 555 /*
 556  * Takes base_name and appends (unique) current
 557  *   date and time to form unique job name.
 558  *
 559  *  Returns: unique job name in jcr->Job
 560  *    date/time in jcr->start_time
 561  */
 562 void create_unique_job_name(JCR *jcr, char *base_name)
 563 {
 564    /* Job start mutex */
 565    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 566    static time_t last_start_time = 0;
 567    time_t now;
 568    struct tm tm;
 569    char dt[MAX_TIME_LENGTH];
 570    char name[MAX_NAME_LENGTH];
 571    char *p;
 572
 573    /* Guarantee unique start time -- maximum one per second, and
 574     * thus unique Job Name
 575     */
 576    P(mutex);                          /* lock creation of jobs */
 577    now = time(NULL);
 578    while (now == last_start_time) {
 579       bmicrosleep(0, 500000);
 580       now = time(NULL);
 581    }
 582    last_start_time = now;
 583    V(mutex);                          /* allow creation of jobs */
 584    jcr->start_time = now;
 585    /* Form Unique JobName */
 586    localtime_r(&now, &tm);
 587    /* Use only characters that are permitted in Windows filenames */
 588    strftime(dt, sizeof(dt), "%Y-%m-%d_%H.%M.%S", &tm);
 589    bstrncpy(name, base_name, sizeof(name));
 590    name[sizeof(name)-22] = 0;          /* truncate if too long */
 591    bsnprintf(jcr->Job, sizeof(jcr->Job), "%s.%s", name, dt); /* add date & time */
 592    /* Convert spaces into underscores */
 593    for (p=jcr->Job; *p; p++) {
 594       if (*p == ' ') {
 595          *p = '_';
 596       }
 597    }
 598 }
 599
 600 /*
 601  * Free the Job Control Record if no one is still using it.
 602  *  Called from main free_jcr() routine in src/lib/jcr.c so
 603  *  that we can do our Director specific cleanup of the jcr.
 604  */
 605 void dird_free_jcr(JCR *jcr)
 606 {
 607    Dmsg0(200, "Start dird free_jcr\n");
 608
 609    if (jcr->sd_auth_key) {
 610       free(jcr->sd_auth_key);
 611       jcr->sd_auth_key = NULL;
 612    }
 613    if (jcr->where) {
 614       free(jcr->where);
 615       jcr->where = NULL;
 616    }
 617    if (jcr->file_bsock) {
 618       Dmsg0(200, "Close File bsock\n");
 619       bnet_close(jcr->file_bsock);
 620       jcr->file_bsock = NULL;
 621    }
 622    if (jcr->store_bsock) {
 623       Dmsg0(200, "Close Store bsock\n");
 624       bnet_close(jcr->store_bsock);
 625       jcr->store_bsock = NULL;
 626    }
 627    if (jcr->fname) {
 628       Dmsg0(200, "Free JCR fname\n");
 629       free_pool_memory(jcr->fname);
 630       jcr->fname = NULL;
 631    }
 632    if (jcr->stime) {
 633       Dmsg0(200, "Free JCR stime\n");
 634       free_pool_memory(jcr->stime);
 635       jcr->stime = NULL;
 636    }
 637    if (jcr->RestoreBootstrap) {
 638       free(jcr->RestoreBootstrap);
 639       jcr->RestoreBootstrap = NULL;
 640    }
 641    if (jcr->client_uname) {
 642       free_pool_memory(jcr->client_uname);
 643       jcr->client_uname = NULL;
 644    }
 645    Dmsg0(200, "End dird free_jcr\n");
 646 }
 647
 648 /*
 649  * Set some defaults in the JCR necessary to
 650  * run. These items are pulled from the job
 651  * definition as defaults, but can be overridden
 652  * later either by the Run record in the Schedule resource,
 653  * or by the Console program.
 654  */
 655 void set_jcr_defaults(JCR *jcr, JOB *job)
 656 {
 657    jcr->job = job;
 658    jcr->JobType = job->JobType;
 659    jcr->JobLevel = job->level;
 660    jcr->store = job->storage;
 661    jcr->client = job->client;
 662    if (!jcr->client_name) {
 663       jcr->client_name = get_pool_memory(PM_NAME);
 664    }
 665    pm_strcpy(&jcr->client_name, jcr->client->hdr.name);
 666    jcr->pool = job->pool;
 667    jcr->catalog = job->client->catalog;
 668    jcr->fileset = job->fileset;
 669    jcr->messages = job->messages;
 670    if (jcr->RestoreBootstrap) {
 671       free(jcr->RestoreBootstrap);
 672    }
 673    /* This can be overridden by Console program */
 674    if (job->RestoreBootstrap) {
 675       jcr->RestoreBootstrap = bstrdup(job->RestoreBootstrap);
 676    }
 677    /* If no default level given, set one */
 678    if (jcr->JobLevel == 0) {
 679       switch (jcr->JobType) {
 680       case JT_VERIFY:
 681          jcr->JobLevel = L_VERIFY_CATALOG;
 682          break;
 683       case JT_BACKUP:
 684          jcr->JobLevel = L_INCREMENTAL;
 685          break;
 686       case JT_RESTORE:
 687       case JT_ADMIN:
 688          jcr->JobLevel = L_FULL;
 689          break;
 690       default:
 691          break;
 692       }
 693    }
 694 }
 695
 696 /*
 697  * Edit codes into Run command
 698  *  %% = %
 699  *  %c = Client's name
 700  *  %d = Director's name
 701  *  %i = JobId
 702  *  %e = Job Exit
 703  *  %j = Job
 704  *  %l = Job Level
 705  *  %n = Job name
 706  *  %t = Job type
 707  *
 708  *  omsg = edited output message
 709  *  imsg = input string containing edit codes (%x)
 710  *
 711  */
 712 static char *edit_run_codes(JCR *jcr, char *omsg, char *imsg)
 713 {
 714    char *p;
 715    const char *str;
 716    char add[20];
 717
 718    *omsg = 0;
 719    Dmsg1(200, "edit_run_codes: %s\n", imsg);
 720    for (p=imsg; *p; p++) {
 721       if (*p == '%') {
 722          switch (*++p) {
 723          case '%':
 724             str = "%";
 725             break;
 726          case 'c':
 727             str = jcr->client_name;
 728             if (!str) {
 729                str = "";
 730             }
 731             break;
 732          case 'd':
 733             str = my_name;
 734             break;
 735          case 'e':
 736             str = job_status_to_str(jcr->JobStatus);
 737             break;
 738          case 'i':
 739             sprintf(add, "%d", jcr->JobId);
 740             str = add;
 741             break;
 742          case 'j':                    /* Job */
 743             str = jcr->Job;
 744             break;
 745          case 'l':
 746             str = job_level_to_str(jcr->JobLevel);
 747             break;
 748          case 'n':
 749             str = jcr->job->hdr.name;
 750             break;
 751          case 't':
 752             str = job_type_to_str(jcr->JobType);
 753             break;
 754          default:
 755             add[0] = '%';
 756             add[1] = *p;
 757             add[2] = 0;
 758             str = add;
 759             break;
 760          }
 761       } else {
 762          add[0] = *p;
 763          add[1] = 0;
 764          str = add;
 765       }
 766       Dmsg1(200, "add_str %s\n", str);
 767       pm_strcat(&omsg, (char *)str);
 768       Dmsg1(200, "omsg=%s\n", omsg);
 769    }
 770    return omsg;
 771 }