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, 2001, 2002 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    sm_check(__FILE__, __LINE__, False);
 149    set_jcr_defaults(jcr, job);
 150    if (run->level) {
 151       jcr->JobLevel = run->level;        /* override run level */
 152    }
 153    if (run->pool) {
 154       jcr->pool = run->pool;          /* override pool */
 155    }
 156    if (run->storage) {
 157       jcr->store = run->storage;      /* override storage */
 158    }
 159    if (run->msgs) {
 160       jcr->messages = run->msgs;      /* override messages */
 161    }
 162    Dmsg0(200, "Leave wait_for_next_job()\n");
 163    return jcr;
 164 }
 165
 166
 167 /*
 168  * Shutdown the scheduler
 169  */
 170 void term_scheduler()
 171 {
 172    if (runjobs) {                     /* free allocated memory */
 173       free(runjobs);
 174       runjobs = NULL;
 175       max_runjobs = 0;
 176    }
 177 }
 178
 179
 180 /*
 181  * Find all jobs to be run this hour
 182  * and the next hour.
 183  */
 184 static void find_runs()
 185 {
 186    time_t now, runtime;
 187    RUN *run;
 188    JOB *job;
 189    SCHED *sched;
 190    struct tm tm;
 191    int hour, next_hour, minute, mday, wday, month, wpos;
 192
 193    Dmsg0(200, "enter find_runs()\n");
 194    num_runjobs = 0;
 195
 196    now = time(NULL);
 197    localtime_r(&now, &tm);
 198
 199    hour = tm.tm_hour;
 200    next_hour = hour + 1;
 201    if (next_hour > 23)
 202       next_hour -= 24;
 203    minute = tm.tm_min;
 204    mday = tm.tm_mday - 1;
 205    wday = tm.tm_wday;
 206    month = tm.tm_mon;
 207    wpos = (tm.tm_mday - 1) / 7;
 208
 209    /* Loop through all jobs */
 210    LockRes();
 211    for (job=NULL; (job=(JOB *)GetNextRes(R_JOB, (RES *)job)); ) {
 212       sched = job->schedule;
 213       if (sched == NULL) {            /* scheduled? */
 214          continue;                    /* no, skip this job */
 215       }
 216       for (run=sched->run; run; run=run->next) {
 217
 218          /* Find runs scheduled in this our or in the
 219           * next hour (we may be one second before the next hour).
 220           */
 221          if ((bit_is_set(hour, run->hour) || bit_is_set(next_hour, run->hour)) &&
 222              (bit_is_set(mday, run->mday) || bit_is_set(wday, run->wday)) &&
 223              bit_is_set(month, run->month) && bit_is_set(wpos, run->wpos)) {
 224
 225             /* find time (time_t) job is to be run */
 226             localtime_r(&now, &tm);
 227             tm.tm_min = run->minute;
 228             tm.tm_sec = 0;
 229             if (bit_is_set(hour, run->hour)) {
 230                runtime = mktime(&tm);
 231                add_job(job, run, now, runtime);
 232             }
 233             if (bit_is_set(next_hour, run->hour)) {
 234                tm.tm_hour++;
 235                if (tm.tm_hour > 23) {
 236                   tm.tm_hour = 0;
 237                }
 238                runtime = mktime(&tm);
 239                add_job(job, run, now, runtime);
 240             }
 241          }
 242       }
 243    }
 244
 245    UnlockRes();
 246    rem_runjobs = num_runjobs;
 247    Dmsg0(200, "Leave find_runs()\n");
 248 }
 249
 250 static void add_job(JOB *job, RUN *run, time_t now, time_t runtime)
 251 {
 252    /*
 253     * Don't run any job that ran less than a minute ago, but
 254     *  do run any job scheduled less than a minute ago.
 255     */
 256    if ((runtime - run->last_run < 61) || (runtime+59 < now)) {
 257       return;
 258    }
 259
 260    /* Make sure array is big enough */
 261    if (num_runjobs == max_runjobs) {
 262       max_runjobs += 10;
 263       runjobs = (RUNJOB *) realloc(runjobs, sizeof(RUNJOB) * max_runjobs);
 264       if (!runjobs)
 265          Emsg0(M_ABORT, 0, _("Out of memory\n"));
 266    }
 267    /* accept to run this job */
 268    runjobs[num_runjobs].run = run;
 269    runjobs[num_runjobs].job = job;
 270    runjobs[num_runjobs++].runtime = runtime; /* when to run it */
 271 }