]> git.sur5r.net Git - bacula/bacula/blobdiff - bacula/src/dird/scheduler.c
Implement MaxVirtualFullInterval
[bacula/bacula] / bacula / src / dird / scheduler.c
index 498bef71f7f20c817ccbfd2b897a972b557aadc7..5108142a2d3a6b11e174c063588f7ebd40278225 100644 (file)
@@ -1,3 +1,21 @@
+/*
+   Bacula(R) - The Network Backup Solution
+
+   Copyright (C) 2000-2015 Kern Sibbald
+
+   The original author of Bacula is Kern Sibbald, with contributions
+   from many others, a complete list can be found in the file AUTHORS.
+
+   You may use this file and others of this release according to the
+   license defined in the LICENSE file, which includes the Affero General
+   Public License, v3.0 ("AGPLv3") and some additional permissions and
+   terms pursuant to its AGPLv3 Section 7.
+
+   This notice must be preserved when any source code is 
+   conveyed and/or propagated.
+
+   Bacula(R) is a registered trademark of Kern Sibbald.
+*/
 /*
  *
  *   Bacula scheduler
@@ -7,21 +25,6 @@
  *
  *     Kern Sibbald, May MM, major revision December MMIII
  *
- *   Version $Id$
- */
-/*
-   Copyright (C) 2000-2006 Kern Sibbald
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License
-   version 2 as amended with additional clauses defined in the
-   file LICENSE in the main source directory.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
-   the file LICENSE for additional details.
-
  */
 
 #include "bacula.h"
@@ -32,7 +35,7 @@
 #define DBGLVL 0
 #else
 #undef SCHED_DEBUG
-#define DBGLVL 200
+#define DBGLVL DT_SCHEDULER|200
 #endif
 
 const int dbglvl = DBGLVL;
@@ -61,7 +64,7 @@ static void dump_job(job_item *ji, const char *msg);
 
 /* Imported variables */
 
-/**
+/*
  * called by reload_config to tell us that the schedules
  * we may have based our next jobs to run queues have been
  * invalidated.  In fact the schedules may not have changed
@@ -69,7 +72,7 @@ static void dump_job(job_item *ji, const char *msg);
  * on are new and no longer have a valid last_run time which
  * causes us to double run schedules that get put into the list
  * because run_nh = 1.
- */   
+ */
 static bool schedules_invalidated = false;
 void invalidate_schedules(void) {
     schedules_invalidated = true;
@@ -105,6 +108,7 @@ JCR *wait_for_next_job(char *one_shot_job_to_run)
          return jcr;
       }
    }
+
    /* Wait until we have something in the
     * next hour or so.
     */
@@ -141,7 +145,7 @@ again:
       time_t twait;
       /** discard scheduled queue and rebuild with new schedule objects. **/
       lock_jobs();
-      if (schedules_invalidated) { 
+      if (schedules_invalidated) {
           dump_job(next_job, "Invalidated job");
           free(next_job);
           while (!jobs_to_run->empty()) {
@@ -162,22 +166,22 @@ again:
       }
       /* Recheck at least once per minute */
       bmicrosleep((next_check_secs < twait)?next_check_secs:twait, 0);
-      /* Attempt to handle clock shift from/to daylight savings time
+      /* Attempt to handle clock shift (but not daylight savings time changes)
        * we allow a skew of 10 seconds before invalidating everything.
        */
       now = time(NULL);
-      if (now < prev+10 || now > (prev+next_check_secs+10)) {
+      if (now < prev-10 || now > (prev+next_check_secs+10)) {
          schedules_invalidated = true;
       }
    }
    jcr = new_jcr(sizeof(JCR), dird_free_jcr);
    run = next_job->run;               /* pick up needed values */
    job = next_job->job;
-   if (job->enabled) {
-      dump_job(next_job, _("Run job"));
+   if (job->enabled && (!job->client || job->client->enabled)) {
+      dump_job(next_job, _("Run job"));  /* no client and job enabled */
    }
    free(next_job);
-   if (!job->enabled) {
+   if (!job->enabled || (job->client && !job->client->enabled)) {
       free_jcr(jcr);
       goto again;                     /* ignore this job */
    }
@@ -186,16 +190,24 @@ again:
    ASSERT(job);
    set_jcr_defaults(jcr, job);
    if (run->level) {
-      jcr->JobLevel = run->level;     /* override run level */
+      jcr->setJobLevel(run->level);  /* override run level */
    }
    if (run->pool) {
       jcr->pool = run->pool;          /* override pool */
       jcr->run_pool_override = true;
    }
+   if (run->next_pool) {
+      jcr->next_pool = run->next_pool; /* override next pool */
+      jcr->run_next_pool_override = true;
+   }
    if (run->full_pool) {
       jcr->full_pool = run->full_pool; /* override full pool */
       jcr->run_full_pool_override = true;
    }
+   if (run->vfull_pool) {
+      jcr->vfull_pool = run->vfull_pool; /* override virtual full pool */
+      jcr->run_vfull_pool_override = true;
+   }
    if (run->inc_pool) {
       jcr->inc_pool = run->inc_pool;  /* override inc pool */
       jcr->run_inc_pool_override = true;
@@ -205,7 +217,10 @@ again:
       jcr->run_diff_pool_override = true;
    }
    if (run->storage) {
-      set_storage(jcr, run->storage); /* override storage */
+      USTORE store;
+      store.store = run->storage;
+      pm_strcpy(store.store_source, _("run override"));
+      set_rwstorage(jcr, &store);     /* override storage */
    }
    if (run->msgs) {
       jcr->messages = run->msgs;      /* override messages */
@@ -216,9 +231,15 @@ again:
    if (run->spool_data_set) {
       jcr->spool_data = run->spool_data;
    }
+   if (run->accurate_set) {     /* overwrite accurate mode */
+      jcr->accurate = run->accurate;
+   }
    if (run->write_part_after_job_set) {
       jcr->write_part_after_job = run->write_part_after_job;
    }
+   if (run->MaxRunSchedTime_set) {
+      jcr->MaxRunSchedTime = run->MaxRunSchedTime;
+   }
    Dmsg0(dbglvl, "Leave wait_for_next_job()\n");
    return jcr;
 }
@@ -230,11 +251,6 @@ again:
 void term_scheduler()
 {
    if (jobs_to_run) {
-      job_item *je;
-      /* Release all queued job entries to be run */
-      foreach_dlist(je, jobs_to_run) {
-         free(je);
-      }
       delete jobs_to_run;
    }
 }
@@ -249,24 +265,25 @@ static void find_runs()
    JOB *job;
    SCHED *sched;
    struct tm tm;
-   int minute;
-   int hour, mday, wday, month, wom, woy;
+   int hour, mday, wday, month, wom, woy, ldom;
    /* Items corresponding to above at the next hour */
-   int nh_hour, nh_mday, nh_wday, nh_month, nh_wom, nh_woy, nh_year;
+   int nh_hour, nh_mday, nh_wday, nh_month, nh_wom, nh_woy, nh_ldom;
 
    Dmsg0(dbglvl, "enter find_runs()\n");
 
-
    /* compute values for time now */
    now = time(NULL);
-   localtime_r(&now, &tm);
+   (void)localtime_r(&now, &tm);
    hour = tm.tm_hour;
-   minute = tm.tm_min;
    mday = tm.tm_mday - 1;
    wday = tm.tm_wday;
    month = tm.tm_mon;
    wom = mday / 7;
    woy = tm_woy(now);                     /* get week of year */
+   ldom = tm_ldom(month, tm.tm_year + 1900);
+
+   Dmsg7(dbglvl, "now = %x: h=%d m=%d md=%d wd=%d wom=%d woy=%d\n",
+         now, hour, month, mday, wday, wom, woy);
 
    /*
     * Compute values for next hour from now.
@@ -274,20 +291,24 @@ static void find_runs()
     * sleeping.
     */
    next_hour = now + 3600;
-   localtime_r(&next_hour, &tm);
+   (void)localtime_r(&next_hour, &tm);
    nh_hour = tm.tm_hour;
    nh_mday = tm.tm_mday - 1;
    nh_wday = tm.tm_wday;
    nh_month = tm.tm_mon;
-   nh_year  = tm.tm_year;
    nh_wom = nh_mday / 7;
-   nh_woy = tm_woy(now);                     /* get week of year */
+   nh_woy = tm_woy(next_hour);              /* get week of year */
+   nh_ldom = tm_ldom(nh_month, tm.tm_year + 1900);
+
+   Dmsg7(dbglvl, "nh = %x: h=%d m=%d md=%d wd=%d wom=%d woy=%d\n",
+         next_hour, nh_hour, nh_month, nh_mday, nh_wday, nh_wom, nh_woy);
 
    /* Loop through all jobs */
    LockRes();
    foreach_res(job, R_JOB) {
       sched = job->schedule;
-      if (sched == NULL || !job->enabled) { /* scheduled? or enabled? */
+      if (!sched || !job->enabled || (sched && !sched->enabled) ||
+         (job->client && !job->client->enabled)) {
          continue;                    /* no, skip this job */
       }
       Dmsg1(dbglvl, "Got job: %s\n", job->hdr.name);
@@ -298,60 +319,63 @@ static void find_runs()
           */
 #ifdef xxxx
          Dmsg0(000, "\n");
-         Dmsg6(000, "run h=%d m=%d md=%d wd=%d wom=%d woy=%d\n",
-            hour, month, mday, wday, wom, woy);
-         Dmsg6(000, "bitset bsh=%d bsm=%d bsmd=%d bswd=%d bswom=%d bswoy=%d\n",
+         Dmsg7(000, "run h=%d m=%d md=%d wd=%d wom=%d woy=%d ldom=%d\n",
+            hour, month, mday, wday, wom, woy, ldom);
+         Dmsg7(000, "bitset bsh=%d bsm=%d bsmd=%d bswd=%d bswom=%d bswoy=%d bsldom=%d\n",
             bit_is_set(hour, run->hour),
             bit_is_set(month, run->month),
             bit_is_set(mday, run->mday),
             bit_is_set(wday, run->wday),
             bit_is_set(wom, run->wom),
-            bit_is_set(woy, run->woy));
+            bit_is_set(woy, run->woy),
+            bit_is_set(31, run->mday));
 
-         Dmsg6(000, "nh_run h=%d m=%d md=%d wd=%d wom=%d woy=%d\n",
-            nh_hour, nh_month, nh_mday, nh_wday, nh_wom, nh_woy);
-         Dmsg6(000, "nh_bitset bsh=%d bsm=%d bsmd=%d bswd=%d bswom=%d bswoy=%d\n",
+
+         Dmsg7(000, "nh_run h=%d m=%d md=%d wd=%d wom=%d woy=%d ldom=%d\n",
+            nh_hour, nh_month, nh_mday, nh_wday, nh_wom, nh_woy, nh_ldom);
+         Dmsg7(000, "nh_bitset bsh=%d bsm=%d bsmd=%d bswd=%d bswom=%d bswoy=%d bsldom=%d\n",
             bit_is_set(nh_hour, run->hour),
             bit_is_set(nh_month, run->month),
             bit_is_set(nh_mday, run->mday),
             bit_is_set(nh_wday, run->wday),
             bit_is_set(nh_wom, run->wom),
-            bit_is_set(nh_woy, run->woy));
+            bit_is_set(nh_woy, run->woy),
+            bit_is_set(31, run->mday));
 #endif
 
          run_now = bit_is_set(hour, run->hour) &&
-            bit_is_set(mday, run->mday) &&
-            bit_is_set(wday, run->wday) &&
-            bit_is_set(month, run->month) &&
-            bit_is_set(wom, run->wom) &&
-            bit_is_set(woy, run->woy);
+            ((bit_is_set(mday, run->mday) &&
+              bit_is_set(wday, run->wday) &&
+              bit_is_set(month, run->month) &&
+              bit_is_set(wom, run->wom) &&
+              bit_is_set(woy, run->woy)) ||
+             (bit_is_set(month, run->month) &&
+              bit_is_set(31, run->mday) && mday == ldom));
 
          run_nh = bit_is_set(nh_hour, run->hour) &&
-            bit_is_set(nh_mday, run->mday) &&
-            bit_is_set(nh_wday, run->wday) &&
-            bit_is_set(nh_month, run->month) &&
-            bit_is_set(nh_wom, run->wom) &&
-            bit_is_set(nh_woy, run->woy);
+            ((bit_is_set(nh_mday, run->mday) &&
+              bit_is_set(nh_wday, run->wday) &&
+              bit_is_set(nh_month, run->month) &&
+              bit_is_set(nh_wom, run->wom) &&
+              bit_is_set(nh_woy, run->woy)) ||
+             (bit_is_set(nh_month, run->month) &&
+              bit_is_set(31, run->mday) && nh_mday == nh_ldom));
 
          Dmsg3(dbglvl, "run@%p: run_now=%d run_nh=%d\n", run, run_now, run_nh);
 
-         /* find time (time_t) job is to be run */
-         localtime_r(&now, &tm);      /* reset tm structure */
-         tm.tm_min = run->minute;     /* set run minute */
-         tm.tm_sec = 0;               /* zero secs */
-         if (run_now) {
-            runtime = mktime(&tm);
-            add_job(job, run, now, runtime);
-         }
-         /* If job is to be run in the next hour schedule it */
-         if (run_nh) {
-            /* Set correct values */
-            tm.tm_hour = nh_hour;
-            tm.tm_mday = nh_mday + 1; /* fixup because we biased for tests above */
-            tm.tm_mon = nh_month;
-            tm.tm_year = nh_year;
-            runtime = mktime(&tm);
-            add_job(job, run, now, runtime);
+         if (run_now || run_nh) {
+           /* find time (time_t) job is to be run */
+           (void)localtime_r(&now, &tm);      /* reset tm structure */
+           tm.tm_min = run->minute;     /* set run minute */
+           tm.tm_sec = 0;               /* zero secs */
+           runtime = mktime(&tm);
+           if (run_now) {
+             add_job(job, run, now, runtime);
+           }
+           /* If job is to be run in the next hour schedule it */
+           if (run_nh) {
+             add_job(job, run, now, runtime + 3600);
+           }
          }
       }
    }
@@ -369,19 +393,15 @@ static void add_job(JOB *job, RUN *run, time_t now, time_t runtime)
     */
    if (((runtime - run->last_run) < 61) || ((runtime+59) < now)) {
 #ifdef SCHED_DEBUG
-      char dt[50], dt1[50], dt2[50];
-      bstrftime_nc(dt, sizeof(dt), runtime);
-      bstrftime_nc(dt1, sizeof(dt1), run->last_run);
-      bstrftime_nc(dt2, sizeof(dt2), now);
-      Dmsg7(000, "Drop: Job=\"%s\" run=%s(%x). last_run=%s(%x). now=%s(%x)\n", job->hdr.name, 
-            dt, runtime, dt1, run->last_run, dt2, now);
+      Dmsg4(000, "Drop: Job=\"%s\" run=%lld. last_run=%lld. now=%lld\n", job->hdr.name,
+            (utime_t)runtime, (utime_t)run->last_run, (utime_t)now);
       fflush(stdout);
 #endif
       return;
    }
 #ifdef SCHED_DEBUG
-   Dmsg4(000, "Add: Job=\"%s\" run=%x last_run=%x now=%x\n", job->hdr.name, 
-            runtime, run->last_run, now);
+   Dmsg4(000, "Add: Job=\"%s\" run=%lld last_run=%lld now=%lld\n", job->hdr.name,
+            (utime_t)runtime, (utime_t)run->last_run, (utime_t)now);
 #endif
    /* accept to run this job */
    job_item *je = (job_item *)malloc(sizeof(job_item));
@@ -421,12 +441,13 @@ static void dump_job(job_item *ji, const char *msg)
 {
 #ifdef SCHED_DEBUG
    char dt[MAX_TIME_LENGTH];
-   int save_debug = debug_level;
-   if (debug_level < dbglvl) {
+   int64_t save_debug = debug_level;
+
+   if (!chk_dbglvl(dbglvl)) {
       return;
    }
    bstrftime_nc(dt, sizeof(dt), ji->runtime);
-   Dmsg4(dbglvl, "%s: Job=%s priority=%d run %s\n", msg, ji->job->hdr.name, 
+   Dmsg4(dbglvl, "%s: Job=%s priority=%d run %s\n", msg, ji->job->hdr.name,
       ji->Priority, dt);
    fflush(stdout);
    debug_level = save_debug;