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

   1 /*
   2  *
   3  *   Bacula scheduler
   4  *     It looks at what jobs are to be run and when
   5  *     and waits around until it is time to
   6  *     fire them up.
   7  *
   8  *     Kern Sibbald, May MM
   9  *
  10  *   Version $Id$
  11  */
  12 /*
  13    Copyright (C) 2000-2003 Kern Sibbald and John Walker
  14
  15    This program is free software; you can redistribute it and/or
  16    modify it under the terms of the GNU General Public License as
  17    published by the Free Software Foundation; either version 2 of
  18    the License, or (at your option) any later version.
  19
  20    This program is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  23    General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public
  26    License along with this program; if not, write to the Free
  27    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  28    MA 02111-1307, USA.
  29
  30  */
  31
  32 #include "bacula.h"
  33 #include "dird.h"
  34
  35
  36 /* Forward referenced subroutines */
  37 static void find_runs();
  38 static void add_job(JOB *job, RUN *run, time_t now, time_t runtime);
  39
  40 /* Imported subroutines */
  41
  42 /* Imported variables */
  43
  44 /* Local variables */
  45 typedef struct {
  46    RUN *run;
  47    JOB *job;
  48    time_t runtime;
  49 } RUNJOB;
  50
  51 static int num_runjobs;               /* total jobs found by find_runs() */
  52 static int rem_runjobs;               /* jobs remaining to be processed */
  53 static int max_runjobs;               /* max jobs in runjobs array */
  54 static RUNJOB *runjobs;               /* array of jobs to be run */
  55
  56
  57 /*********************************************************************
  58  *
  59  *         Main Bacula Scheduler
  60  *
  61  */
  62 JCR *wait_for_next_job(char *job_to_run)
  63 {
  64    JCR *jcr;
  65    JOB *job;
  66    RUN *run;
  67    time_t now, runtime, nexttime;
  68    int jobindex, i;
  69    static int first = TRUE;
  70    char dt[MAX_TIME_LENGTH];
  71
  72    Dmsg0(200, "Enter wait_for_next_job\n");
  73    if (first) {
  74       first = FALSE;
  75       max_runjobs = 10;
  76       runjobs = (RUNJOB *) malloc(sizeof(RUNJOB) * max_runjobs);
  77       num_runjobs = 0;
  78       rem_runjobs = 0;
  79       if (job_to_run) {               /* one shot */
  80          job = (JOB *)GetResWithName(R_JOB, job_to_run);
  81          if (!job) {
  82             Emsg1(M_ABORT, 0, _("Job %s not found\n"), job_to_run);
  83          }
  84          Dmsg1(5, "Found job_to_run %s\n", job_to_run);
  85          jcr = new_jcr(sizeof(JCR), dird_free_jcr);
  86          set_jcr_defaults(jcr, job);
  87          return jcr;
  88       }
  89    }
  90    /* Wait until we have something in the
  91     * next hour or so.
  92     */
  93    while (rem_runjobs == 0) {
  94       find_runs();
  95       if (rem_runjobs > 0) {
  96          break;
  97       }
  98       sleep(60);
  99    }
 100
 101    /*
 102     * Sort through what is to be run in the next
 103     * two hours to find the first job to be run,
 104     * then wait around until it is time.
 105     *
 106     */
 107    time(&now);
 108    nexttime = now + 60 * 60 * 24;     /* a much later time */
 109    jobindex = -1;
 110    bstrftime(dt, sizeof(dt), now);
 111    Dmsg2(400, "jobs=%d. Now is %s\n", rem_runjobs, dt);
 112    for (i=0; i<num_runjobs; i++) {
 113       runtime = runjobs[i].runtime;
 114       if (runtime > 0 && runtime < nexttime) { /* find minimum time job */
 115          nexttime = runtime;
 116          jobindex = i;
 117       }
 118 #ifdef xxxx_debug
 119       if (runtime > 0) {
 120          bstrftime(dt, sizeof(dt), runjobs[i].runtime);
 121          Dmsg2(000, "    %s run %s\n", dt, runjobs[i].job->hdr.name);
 122       }
 123 #endif
 124    }
 125    if (jobindex < 0) {                /* we really should have something now */
 126       Emsg0(M_ABORT, 0, _("Scheduler logic error\n"));
 127    }
 128
 129    /* Now wait for the time to run the job */
 130    for (;;) {
 131       int twait;
 132       time(&now);
 133       twait = nexttime - now;
 134       if (twait <= 0)                 /* time to run it */
 135          break;
 136       if (twait > 1)                  /* sleep max 20 seconds */
 137          twait--;
 138       sleep(twait);
 139    }
 140    run = runjobs[jobindex].run;
 141    job = runjobs[jobindex].job;
 142    runjobs[jobindex].runtime = 0;     /* remove from list */
 143    run->last_run = now;               /* mark as run */
 144    rem_runjobs--;                     /* decrement count of remaining jobs */
 145
 146    jcr = new_jcr(sizeof(JCR), dird_free_jcr);
 147    ASSERT(job);
 148    set_jcr_defaults(jcr, job);
 149    if (run->level) {
 150       jcr->JobLevel = run->level;        /* override run level */
 151    }
 152    if (run->pool) {
 153       jcr->pool = run->pool;          /* override pool */
 154    }
 155    if (run->storage) {
 156       jcr->store = run->storage;      /* override storage */
 157    }
 158    if (run->msgs) {
 159       jcr->messages = run->msgs;      /* override messages */
 160    }
 161    Dmsg0(200, "Leave wait_for_next_job()\n");
 162    return jcr;
 163 }
 164
 165
 166 /*
 167  * Shutdown the scheduler
 168  */
 169 void term_scheduler()
 170 {
 171    if (runjobs) {                     /* free allocated memory */
 172       free(runjobs);
 173       runjobs = NULL;
 174       max_runjobs = 0;
 175    }
 176 }
 177
 178
 179 /*
 180  * Find all jobs to be run this hour
 181  * and the next hour.
 182  */
 183 static void find_runs()
 184 {
 185    time_t now, runtime;
 186    RUN *run;
 187    JOB *job;
 188    SCHED *sched;
 189    struct tm tm;
 190    int hour, next_hour, minute, mday, wday, month, wpos;
 191
 192    Dmsg0(200, "enter find_runs()\n");
 193    num_runjobs = 0;
 194
 195    now = time(NULL);
 196    localtime_r(&now, &tm);
 197
 198    hour = tm.tm_hour;
 199    next_hour = hour + 1;
 200    if (next_hour > 23)
 201       next_hour -= 24;
 202    minute = tm.tm_min;
 203    mday = tm.tm_mday - 1;
 204    wday = tm.tm_wday;
 205    month = tm.tm_mon;
 206    wpos = (tm.tm_mday - 1) / 7;
 207
 208    /* Loop through all jobs */
 209    LockRes();
 210    for (job=NULL; (job=(JOB *)GetNextRes(R_JOB, (RES *)job)); ) {
 211       sched = job->schedule;
 212       if (sched == NULL) {            /* scheduled? */
 213          continue;                    /* no, skip this job */
 214       }
 215       for (run=sched->run; run; run=run->next) {
 216
 217          /* Find runs scheduled in this our or in the
 218           * next hour (we may be one second before the next hour).
 219           */
 220          if ((bit_is_set(hour, run->hour) || bit_is_set(next_hour, run->hour)) &&
 221              (bit_is_set(mday, run->mday) || bit_is_set(wday, run->wday)) &&
 222              bit_is_set(month, run->month) && bit_is_set(wpos, run->wpos)) {
 223
 224             /* find time (time_t) job is to be run */
 225             localtime_r(&now, &tm);
 226             tm.tm_min = run->minute;
 227             tm.tm_sec = 0;
 228             if (bit_is_set(hour, run->hour)) {
 229                runtime = mktime(&tm);
 230                add_job(job, run, now, runtime);
 231             }
 232             if (bit_is_set(next_hour, run->hour)) {
 233                tm.tm_hour++;
 234                if (tm.tm_hour > 23) {
 235                   tm.tm_hour = 0;
 236                }
 237                runtime = mktime(&tm);
 238                add_job(job, run, now, runtime);
 239             }
 240          }
 241       }
 242    }
 243
 244    UnlockRes();
 245    rem_runjobs = num_runjobs;
 246    Dmsg0(200, "Leave find_runs()\n");
 247 }
 248
 249 static void add_job(JOB *job, RUN *run, time_t now, time_t runtime)
 250 {
 251    /*
 252     * Don't run any job that ran less than a minute ago, but
 253     *  do run any job scheduled less than a minute ago.
 254     */
 255    if ((runtime - run->last_run < 61) || (runtime+59 < now)) {
 256       return;
 257    }
 258
 259    /* Make sure array is big enough */
 260    if (num_runjobs == max_runjobs) {
 261       max_runjobs += 10;
 262       runjobs = (RUNJOB *) realloc(runjobs, sizeof(RUNJOB) * max_runjobs);
 263       if (!runjobs)
 264          Emsg0(M_ABORT, 0, _("Out of memory\n"));
 265    }
 266    /* accept to run this job */
 267    runjobs[num_runjobs].run = run;
 268    runjobs[num_runjobs].job = job;
 269    runjobs[num_runjobs++].runtime = runtime; /* when to run it */
 270 }