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-2003 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) {
98 bmicrosleep(60, 0); /* recheck once per minute */
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 */
137 bmicrosleep(twait, 0);
139 run = runjobs[jobindex].run;
140 job = runjobs[jobindex].job;
141 runjobs[jobindex].runtime = 0; /* remove from list */
142 run->last_run = now; /* mark as run */
143 rem_runjobs--; /* decrement count of remaining jobs */
145 jcr = new_jcr(sizeof(JCR), dird_free_jcr);
147 set_jcr_defaults(jcr, job);
149 jcr->JobLevel = run->level; /* override run level */
152 jcr->pool = run->pool; /* override pool */
155 jcr->store = run->storage; /* override storage */
158 jcr->messages = run->msgs; /* override messages */
160 Dmsg0(200, "Leave wait_for_next_job()\n");
166 * Shutdown the scheduler
168 void term_scheduler()
170 if (runjobs) { /* free allocated memory */
179 * Find all jobs to be run this hour
182 static void find_runs()
189 int hour, next_hour, minute, mday, wday, month, wpos;
191 Dmsg0(200, "enter find_runs()\n");
195 localtime_r(&now, &tm);
198 next_hour = hour + 1;
202 mday = tm.tm_mday - 1;
205 wpos = (tm.tm_mday - 1) / 7;
207 /* Loop through all jobs */
209 for (job=NULL; (job=(JOB *)GetNextRes(R_JOB, (RES *)job)); ) {
210 sched = job->schedule;
211 if (sched == NULL) { /* scheduled? */
212 continue; /* no, skip this job */
214 for (run=sched->run; run; run=run->next) {
216 /* Find runs scheduled in this our or in the
217 * next hour (we may be one second before the next hour).
219 if ((bit_is_set(hour, run->hour) || bit_is_set(next_hour, run->hour)) &&
220 (bit_is_set(mday, run->mday) || bit_is_set(wday, run->wday)) &&
221 bit_is_set(month, run->month) && bit_is_set(wpos, run->wpos)) {
223 /* find time (time_t) job is to be run */
224 localtime_r(&now, &tm);
225 tm.tm_min = run->minute;
227 if (bit_is_set(hour, run->hour)) {
228 runtime = mktime(&tm);
229 add_job(job, run, now, runtime);
231 if (bit_is_set(next_hour, run->hour)) {
233 if (tm.tm_hour > 23) {
236 runtime = mktime(&tm);
237 add_job(job, run, now, runtime);
244 rem_runjobs = num_runjobs;
245 Dmsg0(200, "Leave find_runs()\n");
248 static void add_job(JOB *job, RUN *run, time_t now, time_t runtime)
251 * Don't run any job that ran less than a minute ago, but
252 * do run any job scheduled less than a minute ago.
254 if ((runtime - run->last_run < 61) || (runtime+59 < now)) {
258 /* Make sure array is big enough */
259 if (num_runjobs == max_runjobs) {
261 runjobs = (RUNJOB *)realloc(runjobs, sizeof(RUNJOB) * max_runjobs);
263 Emsg0(M_ABORT, 0, _("Out of memory\n"));
265 /* accept to run this job */
266 runjobs[num_runjobs].run = run;
267 runjobs[num_runjobs].job = job;
268 runjobs[num_runjobs++].runtime = runtime; /* when to run it */