]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/scheduler.c
Lots of cleanup for restore -- kes11Aug02
[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, 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;
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
208    /* Loop through all jobs */
209    LockRes();
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 */
214       }
215       for (run=sched->run; run; run=run->next) {
216
217          /* Find runs scheduled in this our or in the
218           * next hour (we may be one second before the next hour).
219           */
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)) {
223
224             /* find time (time_t) job is to be run */
225             localtime_r(&now, &tm);
226             tm.tm_min = run->minute;
227             tm.tm_sec = 0;
228             if (bit_is_set(hour, run->hour)) {
229                runtime = mktime(&tm);
230                add_job(job, run, now, runtime);
231             }
232             if (bit_is_set(next_hour, run->hour)) {
233                tm.tm_hour++;
234                if (tm.tm_hour > 23) {
235                   tm.tm_hour = 0;
236                }
237                runtime = mktime(&tm);
238                add_job(job, run, now, runtime);
239             }
240          }
241       }  
242    }
243
244    UnlockRes();
245    rem_runjobs = num_runjobs;
246    Dmsg0(200, "Leave find_runs()\n");
247 }
248
249 static void add_job(JOB *job, RUN *run, time_t now, time_t runtime)
250 {
251    /*
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.
254     */
255    if ((runtime - run->last_run < 61) || (runtime+59 < now)) {
256       return;
257    }
258
259    /* Make sure array is big enough */
260    if (num_runjobs == max_runjobs) {
261       max_runjobs += 10;
262       runjobs = (RUNJOB *) realloc(runjobs, sizeof(RUNJOB) * max_runjobs);
263       if (!runjobs)
264          Emsg0(M_ABORT, 0, _("Out of memory\n"));
265    } 
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 */
270 }