4 * It looks at what jobs are to be run and when
5 * and waits around until it is time to
13 Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
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.
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.
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,
36 /* Forward referenced subroutines */
37 static void find_runs();
38 static void add_job(JOB *job, RUN *run, time_t now, time_t runtime);
40 /* Imported subroutines */
42 /* Imported variables */
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 */
57 /*********************************************************************
59 * Main Bacula Scheduler
62 JCR *wait_for_next_job(char *job_to_run)
67 time_t now, runtime, nexttime;
69 static int first = TRUE;
70 char dt[MAX_TIME_LENGTH];
72 Dmsg0(200, "Enter wait_for_next_job\n");
76 runjobs = (RUNJOB *) malloc(sizeof(RUNJOB) * max_runjobs);
79 if (job_to_run) { /* one shot */
80 job = (JOB *)GetResWithName(R_JOB, job_to_run);
82 Emsg1(M_ABORT, 0, _("Job %s not found\n"), job_to_run);
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);
90 /* Wait until we have something in the
93 while (rem_runjobs == 0) {
95 if (rem_runjobs > 0) {
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.
108 nexttime = now + 60 * 60 * 24; /* a much later time */
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 */
120 bstrftime(dt, sizeof(dt), runjobs[i].runtime);
121 Dmsg2(000, " %s run %s\n", dt, runjobs[i].job->hdr.name);
125 if (jobindex < 0) { /* we really should have something now */
126 Emsg0(M_ABORT, 0, _("Scheduler logic error\n"));
129 /* Now wait for the time to run the job */
133 twait = nexttime - now;
134 if (twait <= 0) /* time to run it */
136 if (twait > 1) /* sleep max 20 seconds */
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 */
146 jcr = new_jcr(sizeof(JCR), dird_free_jcr);
148 sm_check(__FILE__, __LINE__, False);
149 set_jcr_defaults(jcr, job);
151 jcr->JobLevel = run->level; /* override run level */
154 jcr->pool = run->pool; /* override pool */
157 jcr->store = run->storage; /* override storage */
160 jcr->messages = run->msgs; /* override messages */
162 Dmsg0(200, "Leave wait_for_next_job()\n");
168 * Shutdown the scheduler
170 void term_scheduler()
172 if (runjobs) { /* free allocated memory */
181 * Find all jobs to be run this hour
184 static void find_runs()
191 int hour, next_hour, minute, mday, wday, month;
193 Dmsg0(200, "enter find_runs()\n");
197 localtime_r(&now, &tm);
200 next_hour = hour + 1;
204 mday = tm.tm_mday - 1;
208 /* Loop through all jobs */
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 */
215 for (run=sched->run; run; run=run->next) {
217 /* Find runs scheduled in this our or in the
218 * next hour (we may be one second before the next hour).
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)) {
224 /* find time (time_t) job is to be run */
225 localtime_r(&now, &tm);
226 tm.tm_min = run->minute;
228 if (bit_is_set(hour, run->hour)) {
229 runtime = mktime(&tm);
230 add_job(job, run, now, runtime);
232 if (bit_is_set(next_hour, run->hour)) {
234 if (tm.tm_hour > 23) {
237 runtime = mktime(&tm);
238 add_job(job, run, now, runtime);
245 rem_runjobs = num_runjobs;
246 Dmsg0(200, "Leave find_runs()\n");
249 static void add_job(JOB *job, RUN *run, time_t now, time_t runtime)
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.
255 if ((runtime - run->last_run < 61) || (runtime+59 < now)) {
259 /* Make sure array is big enough */
260 if (num_runjobs == max_runjobs) {
262 runjobs = (RUNJOB *) realloc(runjobs, sizeof(RUNJOB) * max_runjobs);
264 Emsg0(M_ABORT, 0, _("Out of memory\n"));
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 */