]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/scheduler.c
Implement bmicrosleep and run when
[bacula/bacula] / 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       bmicrosleep(60, 0);             /* recheck once per minute */
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       time_t twait;
132       now = time(NULL);
133       twait = nexttime - now;
134       if (twait <= 0) {               /* time to run it */
135          break;
136       }
137       bmicrosleep(twait, 0);
138    }
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 */
144
145    jcr = new_jcr(sizeof(JCR), dird_free_jcr);
146    ASSERT(job);
147    set_jcr_defaults(jcr, job);
148    if (run->level) {
149       jcr->JobLevel = run->level;        /* override run level */
150    }
151    if (run->pool) {
152       jcr->pool = run->pool;          /* override pool */
153    }
154    if (run->storage) {
155       jcr->store = run->storage;      /* override storage */
156    }
157    if (run->msgs) {
158       jcr->messages = run->msgs;      /* override messages */
159    }
160    Dmsg0(200, "Leave wait_for_next_job()\n");
161    return jcr;
162 }
163
164
165 /*
166  * Shutdown the scheduler  
167  */
168 void term_scheduler()
169 {
170    if (runjobs) {                     /* free allocated memory */
171       free(runjobs);
172       runjobs = NULL;
173       max_runjobs = 0;
174    }
175 }
176
177
178 /*          
179  * Find all jobs to be run this hour
180  * and the next hour.
181  */
182 static void find_runs()
183 {
184    time_t now, runtime;
185    RUN *run;
186    JOB *job;
187    SCHED *sched;
188    struct tm tm;
189    int hour, next_hour, minute, mday, wday, month, wpos;
190
191    Dmsg0(200, "enter find_runs()\n");
192    num_runjobs = 0;
193
194    now = time(NULL);
195    localtime_r(&now, &tm);
196    
197    hour = tm.tm_hour;
198    next_hour = hour + 1;
199    if (next_hour > 23)
200       next_hour -= 24;
201    minute = tm.tm_min;
202    mday = tm.tm_mday - 1;
203    wday = tm.tm_wday;
204    month = tm.tm_mon;
205    wpos = (tm.tm_mday - 1) / 7; 
206
207    /* Loop through all jobs */
208    LockRes();
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 */
213       }
214       for (run=sched->run; run; run=run->next) {
215
216          /* Find runs scheduled in this our or in the
217           * next hour (we may be one second before the next hour).
218           */
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)) {
222
223             /* find time (time_t) job is to be run */
224             localtime_r(&now, &tm);
225             tm.tm_min = run->minute;
226             tm.tm_sec = 0;
227             if (bit_is_set(hour, run->hour)) {
228                runtime = mktime(&tm);
229                add_job(job, run, now, runtime);
230             }
231             if (bit_is_set(next_hour, run->hour)) {
232                tm.tm_hour++;
233                if (tm.tm_hour > 23) {
234                   tm.tm_hour = 0;
235                }
236                runtime = mktime(&tm);
237                add_job(job, run, now, runtime);
238             }
239          }
240       }  
241    }
242
243    UnlockRes();
244    rem_runjobs = num_runjobs;
245    Dmsg0(200, "Leave find_runs()\n");
246 }
247
248 static void add_job(JOB *job, RUN *run, time_t now, time_t runtime)
249 {
250    /*
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.
253     */
254    if ((runtime - run->last_run < 61) || (runtime+59 < now)) {
255       return;
256    }
257
258    /* Make sure array is big enough */
259    if (num_runjobs == max_runjobs) {
260       max_runjobs += 10;
261       runjobs = (RUNJOB *)realloc(runjobs, sizeof(RUNJOB) * max_runjobs);
262       if (!runjobs)
263          Emsg0(M_ABORT, 0, _("Out of memory\n"));
264    } 
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 */
269 }