X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fdird%2Fbackup.c;h=029dfa0c89179ab8bb34bb8068062310be01394b;hb=a88224a3ce120783d72e770ff9a04fcac635333a;hp=dc889976ecfd6c2b49da117abd4cd0a78a7a9468;hpb=70d023b17bb36e8ca4331b9900a199350ea7ed08;p=bacula%2Fbacula diff --git a/bacula/src/dird/backup.c b/bacula/src/dird/backup.c index dc889976ec..029dfa0c89 100644 --- a/bacula/src/dird/backup.c +++ b/bacula/src/dird/backup.c @@ -1,3 +1,30 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2000-2009 Free Software Foundation Europe e.V. + + The main author of Bacula is Kern Sibbald, with contributions from + many others, a complete list can be found in the file AUTHORS. + This program is Free Software; you can redistribute it and/or + modify it under the terms of version two of the GNU General Public + License as published by the Free Software Foundation and included + in the file LICENSE. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. + + Bacula® is a registered trademark of Kern Sibbald. + The licensor of Bacula is the Free Software Foundation Europe + (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, + Switzerland, email:ftf@fsfeurope.org. +*/ /* * * Bacula Director -- backup.c -- responsible for doing backup jobs @@ -13,20 +40,6 @@ * * Version $Id$ */ -/* - Copyright (C) 2000-2006 Kern Sibbald - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - version 2 as amended with additional clauses defined in the - file LICENSE in the main source directory. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - the file LICENSE for additional details. - - */ #include "bacula.h" #include "dird.h" @@ -40,15 +53,22 @@ static char storaddr[] = "storage address=%s port=%d ssl=%d\n"; static char OKbackup[] = "2000 OK backup\n"; static char OKstore[] = "2000 OK storage\n"; static char EndJob[] = "2800 End Job TermCode=%d JobFiles=%u " - "ReadBytes=%lld JobBytes=%lld Errors=%u\n"; - + "ReadBytes=%llu JobBytes=%llu Errors=%u " + "VSS=%d Encrypt=%d\n"; +/* Pre 1.39.29 (04Dec06) EndJob */ +static char OldEndJob[] = "2800 End Job TermCode=%d JobFiles=%u " + "ReadBytes=%llu JobBytes=%llu Errors=%u\n"; /* * Called here before the job is run to do the job * specific setup. */ bool do_backup_init(JCR *jcr) { - POOL_DBR pr; + + if (jcr->get_JobLevel() == L_VIRTUAL_FULL) { + return do_vbackup_init(jcr); + } + free_rstorage(jcr); /* we don't read so release */ if (!get_or_create_fileset_record(jcr)) { return false; @@ -59,50 +79,21 @@ bool do_backup_init(JCR *jcr) */ get_level_since_time(jcr, jcr->since, sizeof(jcr->since)); - /* - * Apply any level related Pool selections - */ - switch (jcr->JobLevel) { - case L_FULL: - if (jcr->full_pool) { - jcr->pool = jcr->full_pool; - } - break; - case L_INCREMENTAL: - if (jcr->inc_pool) { - jcr->pool = jcr->inc_pool; - } - break; - case L_DIFFERENTIAL: - if (jcr->dif_pool) { - jcr->pool = jcr->dif_pool; - } - break; + apply_pool_overrides(jcr); + + if (!allow_duplicate_job(jcr)) { + return false; } - memset(&pr, 0, sizeof(pr)); - bstrncpy(pr.Name, jcr->pool->hdr.name, sizeof(pr.Name)); - if (!db_get_pool_record(jcr, jcr->db, &pr)) { /* get by Name */ - /* Try to create the pool */ - if (create_pool(jcr, jcr->db, jcr->pool, POOL_OP_CREATE) < 0) { - Jmsg(jcr, M_FATAL, 0, _("Pool %s not in database. %s"), pr.Name, - db_strerror(jcr->db)); - return false; - } else { - Jmsg(jcr, M_INFO, 0, _("Pool %s created in database.\n"), pr.Name); - if (!db_get_pool_record(jcr, jcr->db, &pr)) { /* get by Name */ - Jmsg(jcr, M_FATAL, 0, _("Pool %s not in database. %s"), pr.Name, - db_strerror(jcr->db)); - return false; - } - } + jcr->jr.PoolId = get_or_create_pool_record(jcr, jcr->pool->name()); + if (jcr->jr.PoolId == 0) { + return false; } - jcr->jr.PoolId = pr.PoolId; /* If pool storage specified, use it instead of job storage */ - copy_storage(jcr, jcr->pool->storage); + copy_wstorage(jcr, jcr->pool->storage, _("Pool resource")); - if (!jcr->storage) { + if (!jcr->wstorage) { Jmsg(jcr, M_FATAL, 0, _("No Storage specification found in Job or Pool.\n")); return false; } @@ -112,6 +103,75 @@ bool do_backup_init(JCR *jcr) return true; } +/* + * Foreach files in currrent list, send "/path/fname\0LStat" to FD + */ +static int accurate_list_handler(void *ctx, int num_fields, char **row) +{ + JCR *jcr = (JCR *)ctx; + + if (job_canceled(jcr)) { + return 1; + } + + if (row[2] > 0) { /* discard when file_index == 0 */ + jcr->file_bsock->fsend("%s%s%c%s", row[0], row[1], 0, row[4]); + } + return 0; +} + +/* + * Send current file list to FD + * DIR -> FD : accurate files=xxxx + * DIR -> FD : /path/to/file\0Lstat + * DIR -> FD : /path/to/dir/\0Lstat + * ... + * DIR -> FD : EOD + */ +bool send_accurate_current_files(JCR *jcr) +{ + POOL_MEM buf; + + if (!jcr->accurate || job_canceled(jcr) || jcr->get_JobLevel()==L_FULL) { + return true; + } + POOLMEM *jobids = get_pool_memory(PM_FNAME); + + db_accurate_get_jobids(jcr, jcr->db, &jcr->jr, jobids); + + if (*jobids == 0) { + free_pool_memory(jobids); + Jmsg(jcr, M_FATAL, 0, _("Cannot find previous jobids.\n")); + return false; + } + if (jcr->JobId) { /* display the message only for real jobs */ + Jmsg(jcr, M_INFO, 0, _("Sending Accurate information.\n")); + } + /* to be able to allocate the right size for htable */ + POOLMEM *nb = get_pool_memory(PM_FNAME); + *nb = 0; /* clear buffer */ + Mmsg(buf, "SELECT sum(JobFiles) FROM Job WHERE JobId IN (%s)",jobids); + db_sql_query(jcr->db, buf.c_str(), db_get_int_handler, nb); + Dmsg2(200, "jobids=%s nb=%s\n", jobids, nb); + jcr->file_bsock->fsend("accurate files=%s\n", nb); + + if (!db_open_batch_connexion(jcr, jcr->db)) { + Jmsg0(jcr, M_FATAL, 0, "Can't get dedicate sql connexion"); + return false; + } + + db_get_file_list(jcr, jcr->db_batch, jobids, accurate_list_handler, (void *)jcr); + + /* TODO: close the batch connexion ? (can be used very soon) */ + + free_pool_memory(jobids); + free_pool_memory(nb); + + jcr->file_bsock->signal(BNET_EOD); + + return true; +} + /* * Do a backup of the specified FileSet * @@ -126,6 +186,9 @@ bool do_backup(JCR *jcr) STORE *store; char ed1[100]; + if (jcr->get_JobLevel() == L_VIRTUAL_FULL) { + return do_vbackup(jcr); + } /* Print Job Start message */ Jmsg(jcr, M_INFO, 0, _("Start Backup JobId %s, Job=%s\n"), @@ -155,7 +218,7 @@ bool do_backup(JCR *jcr) /* * Now start a job with the Storage daemon */ - if (!start_storage_daemon_job(jcr, NULL, jcr->storage)) { + if (!start_storage_daemon_job(jcr, NULL, jcr->wstorage)) { return false; } @@ -202,7 +265,7 @@ bool do_backup(JCR *jcr) /* * send Storage daemon address to the File daemon */ - store = jcr->store; + store = jcr->wstore; if (store->SDDport == 0) { store->SDDport = store->SDport; } @@ -216,13 +279,12 @@ bool do_backup(JCR *jcr) } } - bnet_fsend(fd, storaddr, store->address, store->SDDport, tls_need); + fd->fsend(storaddr, store->address, store->SDDport, tls_need); if (!response(jcr, fd, OKstore, "Storage", DISPLAY_ERROR)) { goto bail_out; } - - if (!send_run_before_and_after_commands(jcr)) { + if (!send_runscripts_commands(jcr)) { goto bail_out; } @@ -242,14 +304,23 @@ bool do_backup(JCR *jcr) Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); } + /* + * If backup is in accurate mode, we send the list of + * all files to FD. + */ + if (!send_accurate_current_files(jcr)) { + goto bail_out; + } + /* Send backup command */ - bnet_fsend(fd, backupcmd); + fd->fsend(backupcmd); if (!response(jcr, fd, OKbackup, "backup", DISPLAY_ERROR)) { goto bail_out; } /* Pickup Job termination data */ stat = wait_for_job_termination(jcr); + db_write_batch_file_records(jcr); /* used by bulk batch file insert */ if (stat == JS_Terminated) { backup_cleanup(jcr, stat); return true; @@ -260,7 +331,8 @@ bool do_backup(JCR *jcr) bail_out: set_jcr_job_status(jcr, JS_ErrorTerminated); Dmsg1(400, "wait for sd. use=%d\n", jcr->use_count()); - wait_for_storage_daemon_termination(jcr); + /* Cancel SD */ + wait_for_job_termination(jcr, FDConnectTimeout); Dmsg1(400, "after wait for sd. use=%d\n", jcr->use_count()); return false; } @@ -272,46 +344,71 @@ bail_out: * are done, we return the job status. * Also used by restore.c */ -int wait_for_job_termination(JCR *jcr) +int wait_for_job_termination(JCR *jcr, int timeout) { int32_t n = 0; BSOCK *fd = jcr->file_bsock; bool fd_ok = false; - uint32_t JobFiles, Errors; - uint64_t ReadBytes, JobBytes; + uint32_t JobFiles, JobErrors; + uint32_t JobWarnings = 0; + uint64_t ReadBytes = 0; + uint64_t JobBytes = 0; + int VSS = 0; + int Encrypt = 0; + btimer_t *tid=NULL; set_jcr_job_status(jcr, JS_Running); - /* Wait for Client to terminate */ - while ((n = bget_dirmsg(fd)) >= 0) { - if (!fd_ok && sscanf(fd->msg, EndJob, &jcr->FDJobStatus, &JobFiles, - &ReadBytes, &JobBytes, &Errors) == 5) { - fd_ok = true; - set_jcr_job_status(jcr, jcr->FDJobStatus); - Dmsg1(100, "FDStatus=%c\n", (char)jcr->JobStatus); - } else { - Jmsg(jcr, M_WARNING, 0, _("Unexpected Client Job message: %s\n"), - fd->msg); + + if (fd) { + if (timeout) { + tid = start_bsock_timer(fd, timeout); /* TODO: New timeout directive??? */ } - if (job_canceled(jcr)) { - break; + /* Wait for Client to terminate */ + while ((n = bget_dirmsg(fd)) >= 0) { + if (!fd_ok && + (sscanf(fd->msg, EndJob, &jcr->FDJobStatus, &JobFiles, + &ReadBytes, &JobBytes, &JobErrors, &VSS, &Encrypt) == 7 || + sscanf(fd->msg, OldEndJob, &jcr->FDJobStatus, &JobFiles, + &ReadBytes, &JobBytes, &JobErrors) == 5)) { + fd_ok = true; + set_jcr_job_status(jcr, jcr->FDJobStatus); + Dmsg1(100, "FDStatus=%c\n", (char)jcr->JobStatus); + } else { + Jmsg(jcr, M_WARNING, 0, _("Unexpected Client Job message: %s\n"), + fd->msg); + } + if (job_canceled(jcr)) { + break; + } + } + if (tid) { + stop_bsock_timer(tid); + } + + if (is_bnet_error(fd)) { + Jmsg(jcr, M_FATAL, 0, _("Network error with FD during %s: ERR=%s\n"), + job_type_to_str(jcr->get_JobType()), fd->bstrerror()); } + fd->signal(BNET_TERMINATE); /* tell Client we are terminating */ } - if (is_bnet_error(fd)) { - Jmsg(jcr, M_FATAL, 0, _("Network error with FD during %s: ERR=%s\n"), - job_type_to_str(jcr->JobType), bnet_strerror(fd)); + + /* Force cancel in SD if failing */ + if (job_canceled(jcr) || !fd_ok) { + cancel_storage_daemon_job(jcr); } - bnet_sig(fd, BNET_TERMINATE); /* tell Client we are terminating */ - /* Note, the SD stores in jcr->JobFiles/ReadBytes/JobBytes/Errors */ + /* Note, the SD stores in jcr->JobFiles/ReadBytes/JobBytes/JobErrors */ wait_for_storage_daemon_termination(jcr); - /* Return values from FD */ if (fd_ok) { jcr->JobFiles = JobFiles; - jcr->Errors = Errors; + jcr->JobErrors += JobErrors; /* Keep total errors */ jcr->ReadBytes = ReadBytes; jcr->JobBytes = JobBytes; + jcr->JobWarnings = JobWarnings; + jcr->VSS = VSS; + jcr->Encrypt = Encrypt; } else { Jmsg(jcr, M_FATAL, 0, _("No Job status returned from FD.\n")); } @@ -320,7 +417,7 @@ int wait_for_job_termination(JCR *jcr) // jcr->JobStatus, jcr->SDJobStatus); /* Return the first error status we find Dir, FD, or SD */ - if (!fd_ok || is_bnet_error(fd)) { + if (!fd_ok || is_bnet_error(fd)) { /* if fd not set, that use !fd_ok */ jcr->FDJobStatus = JS_ErrorTerminated; } if (jcr->JobStatus != JS_Terminated) { @@ -342,29 +439,32 @@ void backup_cleanup(JCR *jcr, int TermCode) char ec6[30], ec7[30], ec8[30], elapsed[50]; char term_code[100], fd_term_msg[100], sd_term_msg[100]; const char *term_msg; - int msg_type; + int msg_type = M_INFO; MEDIA_DBR mr; CLIENT_DBR cr; double kbps, compression; utime_t RunTime; + if (jcr->get_JobLevel() == L_VIRTUAL_FULL) { + vbackup_cleanup(jcr, TermCode); + return; + } + Dmsg2(100, "Enter backup_cleanup %d %c\n", TermCode, TermCode); - dequeue_messages(jcr); /* display any queued messages */ memset(&mr, 0, sizeof(mr)); memset(&cr, 0, sizeof(cr)); - set_jcr_job_status(jcr, TermCode); - update_job_end_record(jcr); /* update database */ + update_job_end(jcr, TermCode); if (!db_get_job_record(jcr, jcr->db, &jcr->jr)) { - Jmsg(jcr, M_WARNING, 0, _("Error getting job record for stats: %s"), + Jmsg(jcr, M_WARNING, 0, _("Error getting Job record for Job report: ERR=%s"), db_strerror(jcr->db)); set_jcr_job_status(jcr, JS_ErrorTerminated); } - bstrncpy(cr.Name, jcr->client->hdr.name, sizeof(cr.Name)); + bstrncpy(cr.Name, jcr->client->name(), sizeof(cr.Name)); if (!db_get_client_record(jcr, jcr->db, &cr)) { - Jmsg(jcr, M_WARNING, 0, _("Error getting client record for stats: %s"), + Jmsg(jcr, M_WARNING, 0, _("Error getting Client record for Job report: ERR=%s"), db_strerror(jcr->db)); } @@ -377,21 +477,23 @@ void backup_cleanup(JCR *jcr, int TermCode) update_bootstrap_file(jcr); - msg_type = M_INFO; /* by default INFO message */ switch (jcr->JobStatus) { case JS_Terminated: - if (jcr->Errors || jcr->SDErrors) { + if (jcr->JobErrors || jcr->SDErrors) { term_msg = _("Backup OK -- with warnings"); } else { term_msg = _("Backup OK"); } break; + case JS_Warnings: + term_msg = _("Backup OK -- with warnings"); + break; case JS_FatalError: case JS_ErrorTerminated: term_msg = _("*** Backup Error ***"); msg_type = M_ERROR; /* Generate error message */ if (jcr->store_bsock) { - bnet_sig(jcr->store_bsock, BNET_TERMINATE); + jcr->store_bsock->signal(BNET_TERMINATE); if (jcr->SD_msg_chan) { pthread_cancel(jcr->SD_msg_chan); } @@ -400,7 +502,7 @@ void backup_cleanup(JCR *jcr, int TermCode) case JS_Canceled: term_msg = _("Backup Canceled"); if (jcr->store_bsock) { - bnet_sig(jcr->store_bsock, BNET_TERMINATE); + jcr->store_bsock->signal(BNET_TERMINATE); if (jcr->SD_msg_chan) { pthread_cancel(jcr->SD_msg_chan); } @@ -418,7 +520,7 @@ void backup_cleanup(JCR *jcr, int TermCode) if (RunTime <= 0) { kbps = 0; } else { - kbps = (double)jcr->jr.JobBytes / (1000 * RunTime); + kbps = ((double)jcr->jr.JobBytes) / (1000.0 * (double)RunTime); } if (!db_get_job_volume_names(jcr, jcr->db, jcr->jr.JobId, &jcr->VolumeName)) { /* @@ -440,7 +542,7 @@ void backup_cleanup(JCR *jcr, int TermCode) if (compression < 0.5) { bstrncpy(compress, "None", sizeof(compress)); } else { - bsnprintf(compress, sizeof(compress), "%.1f %%", (float)compression); + bsnprintf(compress, sizeof(compress), "%.1f %%", compression); } } jobstatus_to_ascii(jcr->FDJobStatus, fd_term_msg, sizeof(fd_term_msg)); @@ -448,14 +550,16 @@ void backup_cleanup(JCR *jcr, int TermCode) // bmicrosleep(15, 0); /* for debugging SIGHUP */ - Jmsg(jcr, msg_type, 0, _("Bacula %s (%s): %s\n" + Jmsg(jcr, msg_type, 0, _("%s %s %s (%s): %s\n" +" Build OS: %s %s %s\n" " JobId: %d\n" " Job: %s\n" " Backup Level: %s%s\n" " Client: \"%s\" %s\n" " FileSet: \"%s\" %s\n" -" Pool: \"%s\"\n" -" Storage: \"%s\"\n" +" Pool: \"%s\" (From %s)\n" +" Catalog: \"%s\" (From %s)\n" +" Storage: \"%s\" (From %s)\n" " Scheduled time: %s\n" " Start time: %s\n" " End time: %s\n" @@ -467,6 +571,9 @@ void backup_cleanup(JCR *jcr, int TermCode) " SD Bytes Written: %s (%sB)\n" " Rate: %.1f KB/s\n" " Software Compression: %s\n" +" VSS: %s\n" +" Encryption: %s\n" +" Accurate: %s\n" " Volume name(s): %s\n" " Volume Session Id: %d\n" " Volume Session Time: %d\n" @@ -476,16 +583,16 @@ void backup_cleanup(JCR *jcr, int TermCode) " FD termination status: %s\n" " SD termination status: %s\n" " Termination: %s\n\n"), - VERSION, - LSMDATE, - edt, + BACULA, my_name, VERSION, LSMDATE, edt, + HOST_OS, DISTNAME, DISTVER, jcr->jr.JobId, jcr->jr.Job, - level_to_str(jcr->JobLevel), jcr->since, - jcr->client->hdr.name, cr.Uname, - jcr->fileset->hdr.name, jcr->FSCreateTime, - jcr->pool->hdr.name, - jcr->store->hdr.name, + level_to_str(jcr->get_JobLevel()), jcr->since, + jcr->client->name(), cr.Uname, + jcr->fileset->name(), jcr->FSCreateTime, + jcr->pool->name(), jcr->pool_source, + jcr->catalog->name(), jcr->catalog_source, + jcr->wstore->name(), jcr->wstore_source, schedt, sdt, edt, @@ -497,14 +604,17 @@ void backup_cleanup(JCR *jcr, int TermCode) edit_uint64_with_suffix(jcr->jr.JobBytes, ec4), edit_uint64_with_commas(jcr->SDJobBytes, ec5), edit_uint64_with_suffix(jcr->SDJobBytes, ec6), - (float)kbps, + kbps, compress, + jcr->VSS?_("yes"):_("no"), + jcr->Encrypt?_("yes"):_("no"), + jcr->accurate?_("yes"):_("no"), jcr->VolumeName, jcr->VolSessionId, jcr->VolSessionTime, edit_uint64_with_commas(mr.VolBytes, ec7), edit_uint64_with_suffix(mr.VolBytes, ec8), - jcr->Errors, + jcr->JobErrors, jcr->SDErrors, fd_term_msg, sd_term_msg, @@ -521,19 +631,20 @@ void update_bootstrap_file(JCR *jcr) FILE *fd; BPIPE *bpipe = NULL; int got_pipe = 0; - char *fname = jcr->job->WriteBootstrap; + POOLMEM *fname = get_pool_memory(PM_FNAME); + fname = edit_job_codes(jcr, fname, jcr->job->WriteBootstrap, ""); + VOL_PARAMS *VolParams = NULL; int VolCount; - char edt[50]; + char edt[50], ed1[50], ed2[50]; if (*fname == '|') { - fname++; got_pipe = 1; - bpipe = open_bpipe(fname, 0, "w"); + bpipe = open_bpipe(fname+1, 0, "w"); /* skip first char "|" */ fd = bpipe ? bpipe->wfd : NULL; } else { /* ***FIXME*** handle BASE */ - fd = fopen(fname, jcr->JobLevel==L_FULL?"w+":"a+"); + fd = fopen(fname, jcr->get_JobLevel()==L_FULL?"w+b":"a+b"); } if (fd) { VolCount = db_get_job_volume_parameters(jcr, jcr->db, jcr->JobId, @@ -549,17 +660,19 @@ void update_bootstrap_file(JCR *jcr) /* Start output with when and who wrote it */ bstrftimes(edt, sizeof(edt), time(NULL)); fprintf(fd, "# %s - %s - %s%s\n", edt, jcr->jr.Job, - level_to_str(jcr->JobLevel), jcr->since); + level_to_str(jcr->get_JobLevel()), jcr->since); for (int i=0; i < VolCount; i++) { /* Write the record */ fprintf(fd, "Volume=\"%s\"\n", VolParams[i].VolumeName); fprintf(fd, "MediaType=\"%s\"\n", VolParams[i].MediaType); + if (VolParams[i].Slot > 0) { + fprintf(fd, "Slot=%d\n", VolParams[i].Slot); + } fprintf(fd, "VolSessionId=%u\n", jcr->VolSessionId); fprintf(fd, "VolSessionTime=%u\n", jcr->VolSessionTime); - fprintf(fd, "VolFile=%u-%u\n", VolParams[i].StartFile, - VolParams[i].EndFile); - fprintf(fd, "VolBlock=%u-%u\n", VolParams[i].StartBlock, - VolParams[i].EndBlock); + fprintf(fd, "VolAddr=%s-%s\n", + edit_uint64(VolParams[i].StartAddr, ed1), + edit_uint64(VolParams[i].EndAddr, ed2)); fprintf(fd, "FileIndex=%d-%d\n", VolParams[i].FirstIndex, VolParams[i].LastIndex); } @@ -574,8 +687,9 @@ void update_bootstrap_file(JCR *jcr) } else { berrno be; Jmsg(jcr, M_ERROR, 0, _("Could not open WriteBootstrap file:\n" - "%s: ERR=%s\n"), fname, be.strerror()); + "%s: ERR=%s\n"), fname, be.bstrerror()); set_jcr_job_status(jcr, JS_ErrorTerminated); } + free_pool_memory(fname); } }