]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/restore.c
Final variable expansion fixes + misc
[bacula/bacula] / bacula / src / dird / restore.c
1 /*
2  *   Bacula Director -- restore.c -- responsible for restoring files
3  *
4  *     Kern Sibbald, November MM
5  *
6  *    This routine is run as a separate thread.  
7  * 
8  * Current implementation is Catalog verification only (i.e. no
9  *  verification versus tape).
10  *
11  *  Basic tasks done here:
12  *     Open DB
13  *     Open Message Channel with Storage daemon to tell him a job will be starting.
14  *     Open connection with File daemon and pass him commands
15  *       to do the restore.
16  *     Update the DB according to what files where restored????
17  *
18  *   Version $Id$
19  */
20
21 /*
22    Copyright (C) 2000-2003 Kern Sibbald and John Walker
23
24    This program is free software; you can redistribute it and/or
25    modify it under the terms of the GNU General Public License as
26    published by the Free Software Foundation; either version 2 of
27    the License, or (at your option) any later version.
28
29    This program is distributed in the hope that it will be useful,
30    but WITHOUT ANY WARRANTY; without even the implied warranty of
31    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
32    General Public License for more details.
33
34    You should have received a copy of the GNU General Public
35    License along with this program; if not, write to the Free
36    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
37    MA 02111-1307, USA.
38
39  */
40
41 #include "bacula.h"
42 #include "dird.h"
43
44 /* Commands sent to File daemon */
45 static char restorecmd[]   = "restore replace=%c prelinks=%d where=%s\n";
46 static char storaddr[]     = "storage address=%s port=%d ssl=0\n";
47 static char sessioncmd[]   = "session %s %ld %ld %ld %ld %ld %ld\n";  
48
49 /* Responses received from File daemon */
50 static char OKrestore[]   = "2000 OK restore\n";
51 static char OKstore[]     = "2000 OK storage\n";
52 static char OKsession[]   = "2000 OK session\n";
53
54 /* Forward referenced functions */
55 static void restore_cleanup(JCR *jcr, int status);
56
57 /* External functions */
58
59 /* 
60  * Do a restore of the specified files
61  *    
62  *  Returns:  0 on failure
63  *            1 on success
64  */
65 int do_restore(JCR *jcr) 
66 {
67    BSOCK   *fd;
68    JOB_DBR rjr;                       /* restore job record */
69
70    if (!get_or_create_client_record(jcr)) {
71       restore_cleanup(jcr, JS_ErrorTerminated);
72       return 0;
73    }
74
75    memset(&rjr, 0, sizeof(rjr));
76    jcr->jr.Level = 'F';            /* Full restore */
77    jcr->jr.StartTime = jcr->start_time;
78    if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
79       Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
80       restore_cleanup(jcr, JS_ErrorTerminated);
81       return 0;
82    }
83    Dmsg0(20, "Updated job start record\n");
84    jcr->fname = (char *) get_pool_memory(PM_FNAME);
85
86    Dmsg1(20, "RestoreJobId=%d\n", jcr->job->RestoreJobId);
87
88    /* 
89     * The following code is kept temporarily for compatibility.
90     * It is the predecessor to the Bootstrap file.
91     */
92    if (!jcr->RestoreBootstrap) {
93       /*
94        * Find Job Record for Files to be restored
95        */
96       if (jcr->RestoreJobId != 0) {
97          rjr.JobId = jcr->RestoreJobId;     /* specified by UA */
98       } else {
99          rjr.JobId = jcr->job->RestoreJobId; /* specified by Job Resource */
100       }
101       if (!db_get_job_record(jcr, jcr->db, &rjr)) {
102          Jmsg2(jcr, M_FATAL, 0, _("Cannot get job record id=%d %s"), rjr.JobId,
103             db_strerror(jcr->db));
104          restore_cleanup(jcr, JS_ErrorTerminated);
105          return 0;
106       }
107
108       /*
109        * Now find the Volumes we will need for the Restore
110        */
111       jcr->VolumeName[0] = 0;
112       if (!db_get_job_volume_names(jcr, jcr->db, rjr.JobId, &jcr->VolumeName) ||
113            jcr->VolumeName[0] == 0) {
114          Jmsg(jcr, M_FATAL, 0, _("Cannot find Volume Name for restore Job %d. %s"), 
115             rjr.JobId, db_strerror(jcr->db));
116          restore_cleanup(jcr, JS_ErrorTerminated);
117          return 0;
118       }
119       Dmsg1(20, "Got job Volume Names: %s\n", jcr->VolumeName);
120    }
121       
122
123    /* Print Job Start message */
124    Jmsg(jcr, M_INFO, 0, _("Start Restore Job %s\n"), jcr->Job);
125
126    /*
127     * Open a message channel connection with the Storage
128     * daemon. This is to let him know that our client
129     * will be contacting him for a backup  session.
130     *
131     */
132    Dmsg0(10, "Open connection with storage daemon\n");
133    set_jcr_job_status(jcr, JS_WaitSD);
134    /*
135     * Start conversation with Storage daemon  
136     */
137    if (!connect_to_storage_daemon(jcr, 10, SDConnectTimeout, 1)) {
138       restore_cleanup(jcr, JS_ErrorTerminated);
139       return 0;
140    }
141    /*
142     * Now start a job with the Storage daemon
143     */
144    if (!start_storage_daemon_job(jcr)) {
145       restore_cleanup(jcr, JS_ErrorTerminated);
146       return 0;
147    }
148    /*
149     * Now start a Storage daemon message thread
150     */
151    if (!start_storage_daemon_message_thread(jcr)) {
152       restore_cleanup(jcr, JS_ErrorTerminated);
153       return 0;
154    }
155    Dmsg0(50, "Storage daemon connection OK\n");
156
157    /* 
158     * Start conversation with File daemon  
159     */
160    set_jcr_job_status(jcr, JS_WaitFD);
161    if (!connect_to_file_daemon(jcr, 10, FDConnectTimeout, 1)) {
162       restore_cleanup(jcr, JS_ErrorTerminated);
163       return 0;
164    }
165
166    fd = jcr->file_bsock;
167    set_jcr_job_status(jcr, JS_Running);
168
169    if (!send_include_list(jcr)) {
170       restore_cleanup(jcr, JS_ErrorTerminated);
171       return 0;
172    }
173
174    if (!send_exclude_list(jcr)) {
175       restore_cleanup(jcr, JS_ErrorTerminated);
176       return 0;
177    }
178
179    /* 
180     * send Storage daemon address to the File daemon,
181     *   then wait for File daemon to make connection
182     *   with Storage daemon.
183     */
184    if (jcr->store->SDDport == 0) {
185       jcr->store->SDDport = jcr->store->SDport;
186    }
187    bnet_fsend(fd, storaddr, jcr->store->address, jcr->store->SDDport);
188    Dmsg1(6, "dird>filed: %s\n", fd->msg);
189    if (!response(jcr, fd, OKstore, "Storage", DISPLAY_ERROR)) {
190       restore_cleanup(jcr, JS_ErrorTerminated);
191       return 0;
192    }
193
194    /* 
195     * Send the bootstrap file -- what Volumes/files to restore
196     */
197    if (!send_bootstrap_file(jcr)) {
198       restore_cleanup(jcr, JS_ErrorTerminated);
199       return 0;
200    }
201
202    /* 
203     * The following code is deprecated   
204     */
205    if (!jcr->RestoreBootstrap) {
206       /*
207        * Pass the VolSessionId, VolSessionTime, Start and
208        * end File and Blocks on the session command.
209        */
210       bnet_fsend(fd, sessioncmd, 
211                 jcr->VolumeName,
212                 rjr.VolSessionId, rjr.VolSessionTime, 
213                 rjr.StartFile, rjr.EndFile, rjr.StartBlock, 
214                 rjr.EndBlock);
215       if (!response(jcr, fd, OKsession, "Session", DISPLAY_ERROR)) {
216          restore_cleanup(jcr, JS_ErrorTerminated);
217          return 0;
218       }
219    }
220
221    if (!send_run_before_and_after_commands(jcr)) {
222       restore_cleanup(jcr, JS_ErrorTerminated);
223       return 0;
224    }
225
226    /* Send restore command */
227    char replace, *where;
228
229    if (jcr->replace != 0) {
230       replace = jcr->replace;
231    } else if (jcr->job->replace != 0) {
232       replace = jcr->job->replace;
233    } else {
234       replace = REPLACE_ALWAYS;       /* always replace */
235    }
236    if (jcr->where) {
237       where = jcr->where;             /* override */
238    } else if (jcr->job->RestoreWhere) {
239       where = jcr->job->RestoreWhere; /* no override take from job */
240    } else {
241       where = "";                     /* None */
242    }
243    jcr->prefix_links = jcr->job->PrefixLinks;
244    bash_spaces(where);
245    bnet_fsend(fd, restorecmd, replace, jcr->prefix_links, where);
246    unbash_spaces(where);
247
248    if (!response(jcr, fd, OKrestore, "Restore", DISPLAY_ERROR)) {
249       restore_cleanup(jcr, JS_ErrorTerminated);
250       return 0;
251    }
252
253    /* Wait for Job Termination */
254    int stat = wait_for_job_termination(jcr);
255    restore_cleanup(jcr, stat);
256
257    return 1;
258 }
259
260 /*
261  * Release resources allocated during restore.
262  *
263  */
264 static void restore_cleanup(JCR *jcr, int TermCode)
265 {
266    char sdt[MAX_TIME_LENGTH], edt[MAX_TIME_LENGTH];
267    char ec1[30], ec2[30];
268    char term_code[100], fd_term_msg[100], sd_term_msg[100];
269    char *term_msg;
270    int msg_type;
271    double kbps;
272
273    Dmsg0(20, "In restore_cleanup\n");
274    set_jcr_job_status(jcr, TermCode);
275
276    update_job_end_record(jcr);
277
278    msg_type = M_INFO;                 /* by default INFO message */
279    switch (TermCode) {
280    case JS_Terminated:
281       term_msg = _("Restore OK");
282       break;
283    case JS_FatalError:
284    case JS_ErrorTerminated:
285       term_msg = _("*** Restore Error ***"); 
286       msg_type = M_ERROR;          /* Generate error message */
287       if (jcr->store_bsock) {
288          bnet_sig(jcr->store_bsock, BNET_TERMINATE);
289          pthread_cancel(jcr->SD_msg_chan);
290       }
291       break;
292    case JS_Canceled:
293       term_msg = _("Restore Canceled");
294       if (jcr->store_bsock) {
295          bnet_sig(jcr->store_bsock, BNET_TERMINATE);
296          pthread_cancel(jcr->SD_msg_chan);
297       }
298       break;
299    default:
300       term_msg = term_code;
301       sprintf(term_code, _("Inappropriate term code: %c\n"), TermCode);
302       break;
303    }
304    bstrftime(sdt, sizeof(sdt), jcr->jr.StartTime);
305    bstrftime(edt, sizeof(edt), jcr->jr.EndTime);
306    if (jcr->jr.EndTime - jcr->jr.StartTime > 0) {
307       kbps = (double)jcr->jr.JobBytes / (1000 * (jcr->jr.EndTime - jcr->jr.StartTime));
308    } else {
309       kbps = 0;
310    }
311    if (kbps < 0.05) {
312       kbps = 0;
313    }
314
315    jobstatus_to_ascii(jcr->FDJobStatus, fd_term_msg, sizeof(fd_term_msg));
316    jobstatus_to_ascii(jcr->SDJobStatus, sd_term_msg, sizeof(sd_term_msg));
317
318    Jmsg(jcr, msg_type, 0, _("Bacula " VERSION " (" LSMDATE "): %s\n\
319 JobId:                  %d\n\
320 Job:                    %s\n\
321 Client:                 %s\n\
322 Start time:             %s\n\
323 End time:               %s\n\
324 Files Restored:         %s\n\
325 Bytes Restored:         %s\n\
326 Rate:                   %.1f KB/s\n\
327 Non-fatal FD Errors:    %d\n\
328 FD termination status:  %s\n\
329 SD termination status:  %s\n\
330 Termination:            %s\n\n"),
331         edt,
332         jcr->jr.JobId,
333         jcr->jr.Job,
334         jcr->client->hdr.name,
335         sdt,
336         edt,
337         edit_uint64_with_commas((uint64_t)jcr->jr.JobFiles, ec1),
338         edit_uint64_with_commas(jcr->jr.JobBytes, ec2),
339         (float)kbps,
340         jcr->Errors,
341         fd_term_msg,
342         sd_term_msg,
343         term_msg);
344
345    Dmsg0(20, "Leaving restore_cleanup\n");
346 }