2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2011 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version three of the GNU Affero General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU Affero General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of Kern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
30 * Bacula Director -- backup.c -- responsible for doing backup jobs
32 * Kern Sibbald, March MM
34 * Basic tasks done here:
35 * Open DB and create records for this job.
36 * Open Message Channel with Storage daemon to tell him a job will be starting.
37 * Open connection with File daemon and pass him commands
39 * When the File daemon finishes the job, update the DB.
47 /* Commands sent to File daemon */
48 static char backupcmd[] = "backup FileIndex=%ld\n";
49 static char storaddr[] = "storage address=%s port=%d ssl=%d\n";
51 /* Responses received from File daemon */
52 static char OKbackup[] = "2000 OK backup\n";
53 static char OKstore[] = "2000 OK storage\n";
54 static char EndJob[] = "2800 End Job TermCode=%d JobFiles=%u "
55 "ReadBytes=%llu JobBytes=%llu Errors=%u "
56 "VSS=%d Encrypt=%d\n";
57 /* Pre 1.39.29 (04Dec06) EndJob */
58 static char OldEndJob[] = "2800 End Job TermCode=%d JobFiles=%u "
59 "ReadBytes=%llu JobBytes=%llu Errors=%u\n";
61 * Called here before the job is run to do the job
64 bool do_backup_init(JCR *jcr)
67 if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
68 return do_vbackup_init(jcr);
70 free_rstorage(jcr); /* we don't read so release */
72 if (!get_or_create_fileset_record(jcr)) {
77 * Get definitive Job level and since time
79 get_level_since_time(jcr, jcr->since, sizeof(jcr->since));
81 apply_pool_overrides(jcr);
83 if (!allow_duplicate_job(jcr)) {
87 jcr->jr.PoolId = get_or_create_pool_record(jcr, jcr->pool->name());
88 if (jcr->jr.PoolId == 0) {
92 /* If pool storage specified, use it instead of job storage */
93 copy_wstorage(jcr, jcr->pool->storage, _("Pool resource"));
96 Jmsg(jcr, M_FATAL, 0, _("No Storage specification found in Job or Pool.\n"));
100 create_clones(jcr); /* run any clone jobs */
105 /* Take all base jobs from job resource and find the
108 static bool get_base_jobids(JCR *jcr, db_list_ctx *jobids)
115 if (!jcr->job->base) {
116 return false; /* no base job, stop accurate */
119 memset(&jr, 0, sizeof(JOB_DBR));
120 jr.StartTime = jcr->jr.StartTime;
122 foreach_alist(job, jcr->job->base) {
123 bstrncpy(jr.Name, job->name(), sizeof(jr.Name));
124 db_get_base_jobid(jcr, jcr->db, &jr, &id);
128 pm_strcat(jobids->list, ",");
130 pm_strcat(jobids->list, edit_uint64(id, str_jobid));
135 return jobids->count > 0;
139 * Foreach files in currrent list, send "/path/fname\0LStat\0MD5\0Delta" to FD
140 * row[0]=Path, row[1]=Filename, row[2]=FileIndex
141 * row[3]=JobId row[4]=LStat row[5]=MarkId row[6]=MD5
143 static int accurate_list_handler(void *ctx, int num_fields, char **row)
145 JCR *jcr = (JCR *)ctx;
147 if (job_canceled(jcr)) {
151 if (row[2][0] == '0') { /* discard when file_index == 0 */
155 /* sending with checksum */
156 if (jcr->use_accurate_chksum
158 && row[6][0] /* skip checksum = '0' */
161 jcr->file_bsock->fsend("%s%s%c%s%c%s%c%s",
162 row[0], row[1], 0, row[4], 0, row[6], 0, row[5]);
164 jcr->file_bsock->fsend("%s%s%c%s%c%c%s",
165 row[0], row[1], 0, row[4], 0, 0, row[5]);
170 /* In this procedure, we check if the current fileset is using checksum
171 * FileSet-> Include-> Options-> Accurate/Verify/BaseJob=checksum
172 * This procedure uses jcr->HasBase, so it must be call after the initialization
174 static bool is_checksum_needed_by_fileset(JCR *jcr)
180 bool have_basejob_option=false;
181 if (!jcr->job || !jcr->job->fileset) {
185 f = jcr->job->fileset;
187 for (int i=0; i < f->num_includes; i++) { /* Parse all Include {} */
188 inc = f->include_items[i];
190 for (int j=0; j < inc->num_opts; j++) { /* Parse all Options {} */
191 fopts = inc->opts_list[j];
193 for (char *k=fopts->opts; *k ; k++) { /* Try to find one request */
195 case 'V': /* verify */
196 in_block = (jcr->getJobType() == JT_VERIFY); /* not used now */
198 case 'J': /* Basejob keyword */
199 have_basejob_option = in_block = jcr->HasBase;
201 case 'C': /* Accurate keyword */
202 in_block = !jcr->is_JobLevel(L_FULL);
204 case ':': /* End of keyword */
210 Dmsg0(50, "Checksum will be sent to FD\n");
221 /* By default for BaseJobs, we send the checksum */
222 if (!have_basejob_option && jcr->HasBase) {
226 Dmsg0(50, "Checksum will be sent to FD\n");
231 * Send current file list to FD
232 * DIR -> FD : accurate files=xxxx
233 * DIR -> FD : /path/to/file\0Lstat\0MD5\0Delta
234 * DIR -> FD : /path/to/dir/\0Lstat\0MD5\0Delta
238 bool send_accurate_current_files(JCR *jcr)
245 /* For incomplete Jobs, we add our own id */
246 if (jcr->incomplete) {
247 edit_int64(jcr->JobId, ed1);
250 if (!jcr->accurate || job_canceled(jcr)) {
253 /* In base level, no previous job is used */
254 if (jcr->is_JobLevel(L_BASE)) {
258 if (jcr->is_JobLevel(L_FULL)) {
259 /* On Full mode, if no previous base job, no accurate things */
260 if (!get_base_jobids(jcr, &jobids)) {
264 Jmsg(jcr, M_INFO, 0, _("Using BaseJobId(s): %s\n"), jobids.list);
267 /* For Incr/Diff level, we search for older jobs */
268 db_accurate_get_jobids(jcr, jcr->db, &jcr->jr, &jobids);
270 /* We are in Incr/Diff, but no Full to build the accurate list... */
271 if (jobids.count == 0) {
272 Jmsg(jcr, M_FATAL, 0, _("Cannot find previous jobids.\n"));
273 return false; /* fail */
278 /* Don't send and store the checksum if fileset doesn't require it */
279 jcr->use_accurate_chksum = is_checksum_needed_by_fileset(jcr);
281 if (jcr->JobId) { /* display the message only for real jobs */
282 Jmsg(jcr, M_INFO, 0, _("Sending Accurate information.\n"));
285 /* to be able to allocate the right size for htable */
286 Mmsg(buf, "SELECT sum(JobFiles) FROM Job WHERE JobId IN (%s)", jobids.list);
287 db_sql_query(jcr->db, buf.c_str(), db_list_handler, &nb);
288 Dmsg2(200, "jobids=%s nb=%s\n", jobids.list, nb.list);
289 jcr->file_bsock->fsend("accurate files=%s\n", nb.list);
291 if (!db_open_batch_connexion(jcr, jcr->db)) {
292 Jmsg0(jcr, M_FATAL, 0, "Can't get batch sql connexion");
293 return false; /* Fail */
297 jcr->nb_base_files = str_to_int64(nb.list);
298 db_create_base_file_list(jcr, jcr->db, jobids.list);
299 db_get_base_file_list(jcr, jcr->db, jcr->use_accurate_chksum,
300 accurate_list_handler, (void *)jcr);
303 db_get_file_list(jcr, jcr->db_batch,
304 jobids.list, jcr->use_accurate_chksum, false /* no delta */,
305 accurate_list_handler, (void *)jcr);
308 /* TODO: close the batch connection ? (can be used very soon) */
310 jcr->file_bsock->signal(BNET_EOD);
315 * Do a backup of the specified FileSet
317 * Returns: false on failure
320 bool do_backup(JCR *jcr)
323 int tls_need = BNET_TLS_NONE;
330 if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
331 return do_vbackup(jcr);
334 /* Print Job Start message */
335 Jmsg(jcr, M_INFO, 0, _("Start Backup JobId %s, Job=%s\n"),
336 edit_uint64(jcr->JobId, ed1), jcr->Job);
338 jcr->setJobStatus(JS_Running);
339 Dmsg2(100, "JobId=%d JobLevel=%c\n", jcr->jr.JobId, jcr->jr.JobLevel);
340 if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
341 Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
345 /* For incomplete Jobs, we add our own id */
346 if (jcr->incomplete) {
347 edit_int64(jcr->JobId, ed1);
348 Mmsg(buf, "SELECT max(FileIndex) FROM File WHERE JobId=%s", ed1);
349 if (!db_sql_query(jcr->db, buf.c_str(), db_int64_handler, &job)) {
350 Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
353 jcr->JobFiles = job.value;
354 Dmsg1(100, "==== FI=%ld\n", jcr->JobFiles);
355 Mmsg(buf, "SELECT VolSessionId FROM Job WHERE JobId=%s", ed1);
356 if (!db_sql_query(jcr->db, buf.c_str(), db_int64_handler, &job)) {
357 Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
360 jcr->VolSessionId = job.value;
361 Mmsg(buf, "SELECT VolSessionTime FROM Job WHERE JobId=%s", ed1);
362 if (!db_sql_query(jcr->db, buf.c_str(), db_int64_handler, &job)) {
363 Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
366 jcr->VolSessionTime = job.value;
367 Dmsg4(100, "JobId=%s JobFiles=%ld VolSessionId=%ld VolSessionTime=%ld\n", ed1,
368 jcr->JobFiles, jcr->VolSessionId, jcr->VolSessionTime);
372 * Open a message channel connection with the Storage
373 * daemon. This is to let him know that our client
374 * will be contacting him for a backup session.
377 Dmsg0(110, "Open connection with storage daemon\n");
378 jcr->setJobStatus(JS_WaitSD);
380 * Start conversation with Storage daemon
382 if (!connect_to_storage_daemon(jcr, 10, SDConnectTimeout, 1)) {
386 * Now start a job with the Storage daemon
388 if (!start_storage_daemon_job(jcr, NULL, jcr->wstorage)) {
393 * Start the job prior to starting the message thread below
394 * to avoid two threads from using the BSOCK structure at
397 if (!jcr->store_bsock->fsend("run")) {
402 * Now start a Storage daemon message thread. Note,
403 * this thread is used to provide the catalog services
404 * for the backup job, including inserting the attributes
405 * into the catalog. See catalog_update() in catreq.c
407 if (!start_storage_daemon_message_thread(jcr)) {
410 Dmsg0(150, "Storage daemon connection OK\n");
412 jcr->setJobStatus(JS_WaitFD);
413 if (!connect_to_file_daemon(jcr, 10, FDConnectTimeout, 1)) {
417 jcr->setJobStatus(JS_Running);
418 fd = jcr->file_bsock;
420 if (!send_include_list(jcr)) {
424 if (!send_exclude_list(jcr)) {
428 if (!send_level_command(jcr)) {
432 /* TODO: See priority with bandwidth parameter */
433 if (jcr->job->max_bandwidth > 0) {
434 jcr->max_bandwidth = jcr->job->max_bandwidth;
435 } else if (jcr->client->max_bandwidth > 0) {
436 jcr->max_bandwidth = jcr->client->max_bandwidth;
439 if (jcr->max_bandwidth > 0) {
440 send_bwlimit(jcr, jcr->Job); /* Old clients don't have this command */
444 * send Storage daemon address to the File daemon
447 if (store->SDDport == 0) {
448 store->SDDport = store->SDport;
451 /* TLS Requirement */
452 if (store->tls_enable) {
453 if (store->tls_require) {
454 tls_need = BNET_TLS_REQUIRED;
456 tls_need = BNET_TLS_OK;
460 fd->fsend(storaddr, store->address, store->SDDport, tls_need);
461 if (!response(jcr, fd, OKstore, "Storage", DISPLAY_ERROR)) {
465 if (!send_runscripts_commands(jcr)) {
470 * We re-update the job start record so that the start
471 * time is set after the run before job. This avoids
472 * that any files created by the run before job will
473 * be saved twice. They will be backed up in the current
474 * job, but not in the next one unless they are changed.
475 * Without this, they will be backed up in this job and
476 * in the next job run because in that case, their date
477 * is after the start of this run.
479 jcr->start_time = time(NULL);
480 jcr->jr.StartTime = jcr->start_time;
481 if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
482 Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
486 * If backup is in accurate mode, we send the list of
489 if (!send_accurate_current_files(jcr)) {
490 goto bail_out; /* error */
493 /* Send backup command */
494 fd->fsend(backupcmd, jcr->JobFiles);
495 Dmsg1(100, ">filed: %s", fd->msg);
496 if (!response(jcr, fd, OKbackup, "backup", DISPLAY_ERROR)) {
500 /* Pickup Job termination data */
501 stat = wait_for_job_termination(jcr);
502 db_write_batch_file_records(jcr); /* used by bulk batch file insert */
504 if (jcr->HasBase && !db_commit_base_file_attributes_record(jcr, jcr->db)) {
505 Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
508 if (stat == JS_Terminated) {
509 backup_cleanup(jcr, stat);
514 /* Come here only after starting SD thread */
516 jcr->setJobStatus(JS_ErrorTerminated);
517 Dmsg1(400, "wait for sd. use=%d\n", jcr->use_count());
519 wait_for_job_termination(jcr, FDConnectTimeout);
520 Dmsg1(400, "after wait for sd. use=%d\n", jcr->use_count());
526 * Here we wait for the File daemon to signal termination,
527 * then we wait for the Storage daemon. When both
528 * are done, we return the job status.
529 * Also used by restore.c
531 int wait_for_job_termination(JCR *jcr, int timeout)
534 BSOCK *fd = jcr->file_bsock;
536 uint32_t JobFiles, JobErrors;
537 uint32_t JobWarnings = 0;
538 uint64_t ReadBytes = 0;
539 uint64_t JobBytes = 0;
544 jcr->setJobStatus(JS_Running);
548 tid = start_bsock_timer(fd, timeout); /* TODO: New timeout directive??? */
550 /* Wait for Client to terminate */
551 while ((n = bget_dirmsg(fd)) >= 0) {
553 (sscanf(fd->msg, EndJob, &jcr->FDJobStatus, &JobFiles,
554 &ReadBytes, &JobBytes, &JobErrors, &VSS, &Encrypt) == 7 ||
555 sscanf(fd->msg, OldEndJob, &jcr->FDJobStatus, &JobFiles,
556 &ReadBytes, &JobBytes, &JobErrors) == 5)) {
558 jcr->setJobStatus(jcr->FDJobStatus);
559 Dmsg1(100, "FDStatus=%c\n", (char)jcr->JobStatus);
561 Jmsg(jcr, M_WARNING, 0, _("Unexpected Client Job message: %s\n"),
564 if (job_canceled(jcr)) {
569 stop_bsock_timer(tid);
572 if (is_bnet_error(fd)) {
574 Jmsg(jcr, M_FATAL, 0, _("Network error with FD during %s: ERR=%s\n"),
575 job_type_to_str(jcr->getJobType()), fd->bstrerror());
576 while (i++ < 10 && jcr->job->RescheduleIncompleteJobs && jcr->is_canceled()) {
581 fd->signal(BNET_TERMINATE); /* tell Client we are terminating */
585 * Force cancel in SD if failing, but not for Incomplete jobs
586 * so that we let the SD despool.
588 Dmsg5(100, "cancel=%d fd_ok=%d FDJS=%d JS=%d SDJS=%d\n", jcr->is_canceled(), fd_ok, jcr->FDJobStatus,
589 jcr->JobStatus, jcr->SDJobStatus);
590 if (jcr->is_canceled() || (!jcr->job->RescheduleIncompleteJobs && !fd_ok)) {
591 Dmsg4(100, "fd_ok=%d FDJS=%d JS=%d SDJS=%d\n", fd_ok, jcr->FDJobStatus,
592 jcr->JobStatus, jcr->SDJobStatus);
593 cancel_storage_daemon_job(jcr);
596 /* Note, the SD stores in jcr->JobFiles/ReadBytes/JobBytes/JobErrors */
597 wait_for_storage_daemon_termination(jcr);
599 /* Return values from FD */
601 jcr->JobFiles = JobFiles;
602 jcr->JobErrors += JobErrors; /* Keep total errors */
603 jcr->ReadBytes = ReadBytes;
604 jcr->JobBytes = JobBytes;
605 jcr->JobWarnings = JobWarnings;
607 jcr->Encrypt = Encrypt;
609 Jmsg(jcr, M_FATAL, 0, _("No Job status returned from FD.\n"));
612 // Dmsg4(100, "fd_ok=%d FDJS=%d JS=%d SDJS=%d\n", fd_ok, jcr->FDJobStatus,
613 // jcr->JobStatus, jcr->SDJobStatus);
615 /* Return the first error status we find Dir, FD, or SD */
616 if (!fd_ok || is_bnet_error(fd)) { /* if fd not set, that use !fd_ok */
617 jcr->FDJobStatus = JS_ErrorTerminated;
619 if (jcr->JobStatus != JS_Terminated) {
620 return jcr->JobStatus;
622 if (jcr->FDJobStatus != JS_Terminated) {
623 return jcr->FDJobStatus;
625 return jcr->SDJobStatus;
629 * Release resources allocated during backup.
631 void backup_cleanup(JCR *jcr, int TermCode)
633 char sdt[50], edt[50], schedt[50];
634 char ec1[30], ec2[30], ec3[30], ec4[30], ec5[30], compress[50];
635 char ec6[30], ec7[30], ec8[30], elapsed[50];
636 char term_code[100], fd_term_msg[100], sd_term_msg[100];
637 const char *term_msg;
638 int msg_type = M_INFO;
641 double kbps, compression;
645 if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
646 vbackup_cleanup(jcr, TermCode);
650 Dmsg2(100, "Enter backup_cleanup %d %c\n", TermCode, TermCode);
651 memset(&mr, 0, sizeof(mr));
652 memset(&cr, 0, sizeof(cr));
655 if (jcr->getJobStatus() == JS_Terminated &&
656 (jcr->JobErrors || jcr->SDErrors || jcr->JobWarnings)) {
657 TermCode = JS_Warnings;
661 update_job_end(jcr, TermCode);
663 if (!db_get_job_record(jcr, jcr->db, &jcr->jr)) {
664 Jmsg(jcr, M_WARNING, 0, _("Error getting Job record for Job report: ERR=%s"),
665 db_strerror(jcr->db));
666 jcr->setJobStatus(JS_ErrorTerminated);
669 bstrncpy(cr.Name, jcr->client->name(), sizeof(cr.Name));
670 if (!db_get_client_record(jcr, jcr->db, &cr)) {
671 Jmsg(jcr, M_WARNING, 0, _("Error getting Client record for Job report: ERR=%s"),
672 db_strerror(jcr->db));
675 bstrncpy(mr.VolumeName, jcr->VolumeName, sizeof(mr.VolumeName));
676 if (!db_get_media_record(jcr, jcr->db, &mr)) {
677 Jmsg(jcr, M_WARNING, 0, _("Error getting Media record for Volume \"%s\": ERR=%s"),
678 mr.VolumeName, db_strerror(jcr->db));
679 jcr->setJobStatus(JS_ErrorTerminated);
682 update_bootstrap_file(jcr);
684 switch (jcr->JobStatus) {
686 if (jcr->JobErrors || jcr->SDErrors) {
687 term_msg = _("Backup OK -- with warnings");
689 term_msg = _("Backup OK");
693 term_msg = _("Backup failed -- incomplete");
696 term_msg = _("Backup OK -- with warnings");
699 case JS_ErrorTerminated:
700 term_msg = _("*** Backup Error ***");
701 msg_type = M_ERROR; /* Generate error message */
702 if (jcr->store_bsock) {
703 jcr->store_bsock->signal(BNET_TERMINATE);
704 if (jcr->SD_msg_chan) {
705 pthread_cancel(jcr->SD_msg_chan);
710 term_msg = _("Backup Canceled");
711 if (jcr->store_bsock) {
712 jcr->store_bsock->signal(BNET_TERMINATE);
713 if (jcr->SD_msg_chan) {
714 pthread_cancel(jcr->SD_msg_chan);
719 term_msg = term_code;
720 sprintf(term_code, _("Inappropriate term code: %c\n"), jcr->JobStatus);
723 bstrftimes(schedt, sizeof(schedt), jcr->jr.SchedTime);
724 bstrftimes(sdt, sizeof(sdt), jcr->jr.StartTime);
725 bstrftimes(edt, sizeof(edt), jcr->jr.EndTime);
726 RunTime = jcr->jr.EndTime - jcr->jr.StartTime;
730 kbps = ((double)jcr->jr.JobBytes) / (1000.0 * (double)RunTime);
732 if (!db_get_job_volume_names(jcr, jcr->db, jcr->jr.JobId, &jcr->VolumeName)) {
734 * Note, if the job has erred, most likely it did not write any
735 * tape, so suppress this "error" message since in that case
736 * it is normal. Or look at it the other way, only for a
737 * normal exit should we complain about this error.
739 if (jcr->JobStatus == JS_Terminated && jcr->jr.JobBytes) {
740 Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
742 jcr->VolumeName[0] = 0; /* none */
745 if (jcr->ReadBytes == 0) {
746 bstrncpy(compress, "None", sizeof(compress));
748 compression = (double)100 - 100.0 * ((double)jcr->JobBytes / (double)jcr->ReadBytes);
749 if (compression < 0.5) {
750 bstrncpy(compress, "None", sizeof(compress));
752 bsnprintf(compress, sizeof(compress), "%.1f %%", compression);
755 jobstatus_to_ascii(jcr->FDJobStatus, fd_term_msg, sizeof(fd_term_msg));
756 jobstatus_to_ascii(jcr->SDJobStatus, sd_term_msg, sizeof(sd_term_msg));
759 Mmsg(base_info, " Base files/Used files: %lld/%lld (%.2f%%)\n",
761 jcr->nb_base_files_used,
762 jcr->nb_base_files_used*100.0/jcr->nb_base_files);
764 // bmicrosleep(15, 0); /* for debugging SIGHUP */
766 Jmsg(jcr, msg_type, 0, _("%s %s %s (%s):\n"
767 " Build OS: %s %s %s\n"
770 " Backup Level: %s%s\n"
771 " Client: \"%s\" %s\n"
772 " FileSet: \"%s\" %s\n"
773 " Pool: \"%s\" (From %s)\n"
774 " Catalog: \"%s\" (From %s)\n"
775 " Storage: \"%s\" (From %s)\n"
776 " Scheduled time: %s\n"
779 " Elapsed time: %s\n"
781 " FD Files Written: %s\n"
782 " SD Files Written: %s\n"
783 " FD Bytes Written: %s (%sB)\n"
784 " SD Bytes Written: %s (%sB)\n"
786 " Software Compression: %s\n"
787 "%s" /* Basefile info */
791 " Volume name(s): %s\n"
792 " Volume Session Id: %d\n"
793 " Volume Session Time: %d\n"
794 " Last Volume Bytes: %s (%sB)\n"
795 " Non-fatal FD errors: %d\n"
797 " FD termination status: %s\n"
798 " SD termination status: %s\n"
799 " Termination: %s\n\n"),
800 BACULA, my_name, VERSION, LSMDATE,
801 HOST_OS, DISTNAME, DISTVER,
804 level_to_str(jcr->getJobLevel()), jcr->since,
805 jcr->client->name(), cr.Uname,
806 jcr->fileset->name(), jcr->FSCreateTime,
807 jcr->pool->name(), jcr->pool_source,
808 jcr->catalog->name(), jcr->catalog_source,
809 jcr->wstore->name(), jcr->wstore_source,
813 edit_utime(RunTime, elapsed, sizeof(elapsed)),
815 edit_uint64_with_commas(jcr->jr.JobFiles, ec1),
816 edit_uint64_with_commas(jcr->SDJobFiles, ec2),
817 edit_uint64_with_commas(jcr->jr.JobBytes, ec3),
818 edit_uint64_with_suffix(jcr->jr.JobBytes, ec4),
819 edit_uint64_with_commas(jcr->SDJobBytes, ec5),
820 edit_uint64_with_suffix(jcr->SDJobBytes, ec6),
824 jcr->VSS?_("yes"):_("no"),
825 jcr->Encrypt?_("yes"):_("no"),
826 jcr->accurate?_("yes"):_("no"),
830 edit_uint64_with_commas(mr.VolBytes, ec7),
831 edit_uint64_with_suffix(mr.VolBytes, ec8),
838 Dmsg0(100, "Leave backup_cleanup()\n");
841 void update_bootstrap_file(JCR *jcr)
843 /* Now update the bootstrap file if any */
844 if (jcr->JobStatus == JS_Terminated && jcr->jr.JobBytes &&
845 jcr->job->WriteBootstrap) {
849 POOLMEM *fname = get_pool_memory(PM_FNAME);
850 fname = edit_job_codes(jcr, fname, jcr->job->WriteBootstrap, "");
852 VOL_PARAMS *VolParams = NULL;
854 char edt[50], ed1[50], ed2[50];
858 bpipe = open_bpipe(fname+1, 0, "w"); /* skip first char "|" */
859 fd = bpipe ? bpipe->wfd : NULL;
861 /* ***FIXME*** handle BASE */
862 fd = fopen(fname, jcr->is_JobLevel(L_FULL)?"w+b":"a+b");
865 VolCount = db_get_job_volume_parameters(jcr, jcr->db, jcr->JobId,
868 Jmsg(jcr, M_ERROR, 0, _("Could not get Job Volume Parameters to "
869 "update Bootstrap file. ERR=%s\n"), db_strerror(jcr->db));
870 if (jcr->SDJobFiles != 0) {
871 jcr->setJobStatus(JS_ErrorTerminated);
875 /* Start output with when and who wrote it */
876 bstrftimes(edt, sizeof(edt), time(NULL));
877 fprintf(fd, "# %s - %s - %s%s\n", edt, jcr->jr.Job,
878 level_to_str(jcr->getJobLevel()), jcr->since);
879 for (int i=0; i < VolCount; i++) {
880 /* Write the record */
881 fprintf(fd, "Volume=\"%s\"\n", VolParams[i].VolumeName);
882 fprintf(fd, "MediaType=\"%s\"\n", VolParams[i].MediaType);
883 if (VolParams[i].Slot > 0) {
884 fprintf(fd, "Slot=%d\n", VolParams[i].Slot);
886 fprintf(fd, "VolSessionId=%u\n", jcr->VolSessionId);
887 fprintf(fd, "VolSessionTime=%u\n", jcr->VolSessionTime);
888 fprintf(fd, "VolAddr=%s-%s\n",
889 edit_uint64(VolParams[i].StartAddr, ed1),
890 edit_uint64(VolParams[i].EndAddr, ed2));
891 fprintf(fd, "FileIndex=%d-%d\n", VolParams[i].FirstIndex,
892 VolParams[i].LastIndex);
904 Jmsg(jcr, M_ERROR, 0, _("Could not open WriteBootstrap file:\n"
905 "%s: ERR=%s\n"), fname, be.bstrerror());
906 jcr->setJobStatus(JS_ErrorTerminated);
908 free_pool_memory(fname);