git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/vbackup.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2008-2009 Free Software Foundation Europe e.V.
   5
   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
  11    in the file LICENSE.
  12
  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.
  17
  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
  21    02110-1301, USA.
  22
  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.
  27 */
  28 /*
  29  *
  30  *   Bacula Director -- vbackup.c -- responsible for doing virtual
  31  *     backup jobs or in other words, consolidation or synthetic
  32  *     backups.
  33  *
  34  *     Kern Sibbald, July MMVIII
  35  *
  36  *  Basic tasks done here:
  37  *     Open DB and create records for this job.
  38  *     Figure out what Jobs to copy.
  39  *     Open Message Channel with Storage daemon to tell him a job will be starting.
  40  *     Open connection with File daemon and pass him commands
  41  *       to do the backup.
  42  *     When the File daemon finishes the job, update the DB.
  43  *
  44  *   Version $Id: $
  45  */
  46
  47 #include "bacula.h"
  48 #include "dird.h"
  49 #include "ua.h"
  50
  51 static const int dbglevel = 10;
  52
  53 static bool create_bootstrap_file(JCR *jcr, char *jobids);
  54 void vbackup_cleanup(JCR *jcr, int TermCode);
  55
  56 /*
  57  * Called here before the job is run to do the job
  58  *   specific setup.
  59  */
  60 bool do_vbackup_init(JCR *jcr)
  61 {
  62
  63    if (!get_or_create_fileset_record(jcr)) {
  64       Dmsg1(dbglevel, "JobId=%d no FileSet\n", (int)jcr->JobId);
  65       return false;
  66    }
  67
  68    apply_pool_overrides(jcr);
  69
  70    if (!allow_duplicate_job(jcr)) {
  71       return false;
  72    }
  73
  74    jcr->jr.PoolId = get_or_create_pool_record(jcr, jcr->pool->name());
  75    if (jcr->jr.PoolId == 0) {
  76       Dmsg1(dbglevel, "JobId=%d no PoolId\n", (int)jcr->JobId);
  77       Jmsg(jcr, M_FATAL, 0, _("Could not get or create a Pool record.\n"));
  78       return false;
  79    }
  80    /*
  81     * Note, at this point, pool is the pool for this job.  We
  82     *  transfer it to rpool (read pool), and a bit later,
  83     *  pool will be changed to point to the write pool,
  84     *  which comes from pool->NextPool.
  85     */
  86    jcr->rpool = jcr->pool;            /* save read pool */
  87    pm_strcpy(jcr->rpool_source, jcr->pool_source);
  88
  89    /* If pool storage specified, use it for restore */
  90    copy_rstorage(jcr, jcr->pool->storage, _("Pool resource"));
  91
  92    Dmsg2(dbglevel, "Read pool=%s (From %s)\n", jcr->rpool->name(), jcr->rpool_source);
  93
  94    jcr->start_time = time(NULL);
  95    jcr->jr.StartTime = jcr->start_time;
  96    jcr->jr.JobLevel = L_FULL;      /* we want this to appear as a Full backup */
  97    if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
  98       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
  99    }
 100
 101
 102    /*
 103     * If the original backup pool has a NextPool, make sure a
 104     *  record exists in the database. Note, in this case, we
 105     *  will be backing up from pool to pool->NextPool.
 106     */
 107    if (jcr->pool->NextPool) {
 108       jcr->jr.PoolId = get_or_create_pool_record(jcr, jcr->pool->NextPool->name());
 109       if (jcr->jr.PoolId == 0) {
 110          return false;
 111       }
 112    }
 113    if (!set_migration_wstorage(jcr, jcr->pool)) {
 114       return false;
 115    }
 116    jcr->pool = jcr->pool->NextPool;
 117    pm_strcpy(jcr->pool_source, _("Job Pool's NextPool resource"));
 118
 119    Dmsg2(dbglevel, "Write pool=%s read rpool=%s\n", jcr->pool->name(), jcr->rpool->name());
 120
 121 // create_clones(jcr);
 122
 123    return true;
 124 }
 125
 126 /*
 127  * Do a virtual backup, which consolidates all previous backups into
 128  *  a sort of synthetic Full.
 129  *
 130  *  Returns:  false on failure
 131  *            true  on success
 132  */
 133 bool do_vbackup(JCR *jcr)
 134 {
 135    char ed1[100];
 136    BSOCK *sd;
 137    char *p;
 138    db_list_ctx jobids;
 139
 140    Dmsg2(100, "rstorage=%p wstorage=%p\n", jcr->rstorage, jcr->wstorage);
 141    Dmsg2(100, "Read store=%s, write store=%s\n",
 142       ((STORE *)jcr->rstorage->first())->name(),
 143       ((STORE *)jcr->wstorage->first())->name());
 144
 145    /* Print Job Start message */
 146    Jmsg(jcr, M_INFO, 0, _("Start Virtual Backup JobId %s, Job=%s\n"),
 147         edit_uint64(jcr->JobId, ed1), jcr->Job);
 148    if (!jcr->accurate) {
 149       Jmsg(jcr, M_WARNING, 0,
 150 _("This Job is not an Accurate backup so is not equivalent to a Full backup.\n"));
 151    }
 152
 153    jcr->jr.JobLevel = L_VIRTUAL_FULL;
 154    db_accurate_get_jobids(jcr, jcr->db, &jcr->jr, &jobids);
 155    Dmsg1(10, "Accurate jobids=%s\n", jobids.list);
 156    if (jobids.count == 0) {
 157       Jmsg(jcr, M_FATAL, 0, _("No previous Jobs found.\n"));
 158       return false;
 159    }
 160
 161    jcr->jr.JobLevel = L_FULL;
 162
 163    /*
 164     * Now we find the last job that ran and store it's info in
 165     *  the previous_jr record.  We will set our times to the
 166     *  values from that job so that anything changed after that
 167     *  time will be picked up on the next backup.
 168     */
 169    p = strrchr(jobids.list, ',');           /* find last jobid */
 170    if (p != NULL) {
 171       p++;
 172    } else {
 173       p = jobids.list;
 174    }
 175    memset(&jcr->previous_jr, 0, sizeof(jcr->previous_jr));
 176    jcr->previous_jr.JobId = str_to_int64(p);
 177    Dmsg1(10, "Previous JobId=%s\n", p);
 178    if (!db_get_job_record(jcr, jcr->db, &jcr->previous_jr)) {
 179       Jmsg(jcr, M_FATAL, 0, _("Error getting Job record for previous Job: ERR=%s"),
 180                db_strerror(jcr->db));
 181       return false;
 182    }
 183
 184    if (!create_bootstrap_file(jcr, jobids.list)) {
 185       Jmsg(jcr, M_FATAL, 0, _("Could not get or create the FileSet record.\n"));
 186       return false;
 187    }
 188
 189    /*
 190     * Open a message channel connection with the Storage
 191     * daemon. This is to let him know that our client
 192     * will be contacting him for a backup  session.
 193     *
 194     */
 195    Dmsg0(110, "Open connection with storage daemon\n");
 196    set_jcr_job_status(jcr, JS_WaitSD);
 197    /*
 198     * Start conversation with Storage daemon
 199     */
 200    if (!connect_to_storage_daemon(jcr, 10, SDConnectTimeout, 1)) {
 201       return false;
 202    }
 203    sd = jcr->store_bsock;
 204
 205    /*
 206     * Now start a job with the Storage daemon
 207     */
 208    if (!start_storage_daemon_job(jcr, jcr->rstorage, jcr->wstorage, /*send_bsr*/true)) {
 209       return false;
 210    }
 211    Dmsg0(100, "Storage daemon connection OK\n");
 212
 213    /*
 214     * We re-update the job start record so that the start
 215     *  time is set after the run before job.  This avoids
 216     *  that any files created by the run before job will
 217     *  be saved twice.  They will be backed up in the current
 218     *  job, but not in the next one unless they are changed.
 219     *  Without this, they will be backed up in this job and
 220     *  in the next job run because in that case, their date
 221     *   is after the start of this run.
 222     */
 223    jcr->start_time = time(NULL);
 224    jcr->jr.StartTime = jcr->start_time;
 225    jcr->jr.JobTDate = jcr->start_time;
 226    set_jcr_job_status(jcr, JS_Running);
 227
 228    /* Update job start record */
 229    if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
 230       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 231       return false;
 232    }
 233
 234    /*
 235     * Start the job prior to starting the message thread below
 236     * to avoid two threads from using the BSOCK structure at
 237     * the same time.
 238     */
 239    if (!sd->fsend("run")) {
 240       return false;
 241    }
 242
 243    /*
 244     * Now start a Storage daemon message thread
 245     */
 246    if (!start_storage_daemon_message_thread(jcr)) {
 247       return false;
 248    }
 249
 250    set_jcr_job_status(jcr, JS_Running);
 251
 252    /* Pickup Job termination data */
 253    /* Note, the SD stores in jcr->JobFiles/ReadBytes/JobBytes/JobErrors */
 254    wait_for_storage_daemon_termination(jcr);
 255    set_jcr_job_status(jcr, jcr->SDJobStatus);
 256    db_write_batch_file_records(jcr);    /* used by bulk batch file insert */
 257    if (jcr->JobStatus != JS_Terminated) {
 258       return false;
 259    }
 260
 261    vbackup_cleanup(jcr, jcr->JobStatus);
 262    return true;
 263 }
 264
 265
 266 /*
 267  * Release resources allocated during backup.
 268  */
 269 void vbackup_cleanup(JCR *jcr, int TermCode)
 270 {
 271    char sdt[50], edt[50], schedt[50];
 272    char ec1[30], ec3[30], ec4[30], compress[50];
 273    char ec7[30], ec8[30], elapsed[50];
 274    char term_code[100], sd_term_msg[100];
 275    const char *term_msg;
 276    int msg_type = M_INFO;
 277    MEDIA_DBR mr;
 278    CLIENT_DBR cr;
 279    double kbps, compression;
 280    utime_t RunTime;
 281    POOL_MEM query(PM_MESSAGE);
 282
 283    Dmsg2(100, "Enter backup_cleanup %d %c\n", TermCode, TermCode);
 284    memset(&mr, 0, sizeof(mr));
 285    memset(&cr, 0, sizeof(cr));
 286
 287    jcr->set_JobLevel(L_FULL);         /* we want this to appear as a Full backup */
 288    jcr->jr.JobLevel = L_FULL;         /* we want this to appear as a Full backup */
 289    jcr->JobFiles = jcr->SDJobFiles;
 290    jcr->JobBytes = jcr->SDJobBytes;
 291    update_job_end(jcr, TermCode);
 292
 293    /* Update final items to set them to the previous job's values */
 294    Mmsg(query, "UPDATE Job SET StartTime='%s',EndTime='%s',"
 295                "JobTDate=%s WHERE JobId=%s",
 296       jcr->previous_jr.cStartTime, jcr->previous_jr.cEndTime,
 297       edit_uint64(jcr->previous_jr.JobTDate, ec1),
 298       edit_uint64(jcr->JobId, ec3));
 299    db_sql_query(jcr->db, query.c_str(), NULL, NULL);
 300
 301    /* Get the fully updated job record */
 302    if (!db_get_job_record(jcr, jcr->db, &jcr->jr)) {
 303       Jmsg(jcr, M_WARNING, 0, _("Error getting Job record for Job report: ERR=%s"),
 304          db_strerror(jcr->db));
 305       set_jcr_job_status(jcr, JS_ErrorTerminated);
 306    }
 307
 308    bstrncpy(cr.Name, jcr->client->name(), sizeof(cr.Name));
 309    if (!db_get_client_record(jcr, jcr->db, &cr)) {
 310       Jmsg(jcr, M_WARNING, 0, _("Error getting Client record for Job report: ERR=%s"),
 311          db_strerror(jcr->db));
 312    }
 313
 314    bstrncpy(mr.VolumeName, jcr->VolumeName, sizeof(mr.VolumeName));
 315    if (!db_get_media_record(jcr, jcr->db, &mr)) {
 316       Jmsg(jcr, M_WARNING, 0, _("Error getting Media record for Volume \"%s\": ERR=%s"),
 317          mr.VolumeName, db_strerror(jcr->db));
 318       set_jcr_job_status(jcr, JS_ErrorTerminated);
 319    }
 320
 321    update_bootstrap_file(jcr);
 322
 323    switch (jcr->JobStatus) {
 324       case JS_Terminated:
 325          if (jcr->JobErrors || jcr->SDErrors) {
 326             term_msg = _("Backup OK -- with warnings");
 327          } else {
 328             term_msg = _("Backup OK");
 329          }
 330          break;
 331       case JS_FatalError:
 332       case JS_ErrorTerminated:
 333          term_msg = _("*** Backup Error ***");
 334          msg_type = M_ERROR;          /* Generate error message */
 335          if (jcr->store_bsock) {
 336             jcr->store_bsock->signal(BNET_TERMINATE);
 337             if (jcr->SD_msg_chan) {
 338                pthread_cancel(jcr->SD_msg_chan);
 339             }
 340          }
 341          break;
 342       case JS_Canceled:
 343          term_msg = _("Backup Canceled");
 344          if (jcr->store_bsock) {
 345             jcr->store_bsock->signal(BNET_TERMINATE);
 346             if (jcr->SD_msg_chan) {
 347                pthread_cancel(jcr->SD_msg_chan);
 348             }
 349          }
 350          break;
 351       default:
 352          term_msg = term_code;
 353          sprintf(term_code, _("Inappropriate term code: %c\n"), jcr->JobStatus);
 354          break;
 355    }
 356    bstrftimes(schedt, sizeof(schedt), jcr->jr.SchedTime);
 357    bstrftimes(sdt, sizeof(sdt), jcr->jr.StartTime);
 358    bstrftimes(edt, sizeof(edt), jcr->jr.EndTime);
 359    RunTime = jcr->jr.EndTime - jcr->jr.StartTime;
 360    if (RunTime <= 0) {
 361       kbps = 0;
 362    } else {
 363       kbps = ((double)jcr->jr.JobBytes) / (1000.0 * (double)RunTime);
 364    }
 365    if (!db_get_job_volume_names(jcr, jcr->db, jcr->jr.JobId, &jcr->VolumeName)) {
 366       /*
 367        * Note, if the job has erred, most likely it did not write any
 368        *  tape, so suppress this "error" message since in that case
 369        *  it is normal.  Or look at it the other way, only for a
 370        *  normal exit should we complain about this error.
 371        */
 372       if (jcr->JobStatus == JS_Terminated && jcr->jr.JobBytes) {
 373          Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
 374       }
 375       jcr->VolumeName[0] = 0;         /* none */
 376    }
 377
 378    if (jcr->ReadBytes == 0) {
 379       bstrncpy(compress, "None", sizeof(compress));
 380    } else {
 381       compression = (double)100 - 100.0 * ((double)jcr->JobBytes / (double)jcr->ReadBytes);
 382       if (compression < 0.5) {
 383          bstrncpy(compress, "None", sizeof(compress));
 384       } else {
 385          bsnprintf(compress, sizeof(compress), "%.1f %%", compression);
 386       }
 387    }
 388    jobstatus_to_ascii(jcr->SDJobStatus, sd_term_msg, sizeof(sd_term_msg));
 389
 390    Jmsg(jcr, msg_type, 0, _("%s %s %s (%s):\n"
 391 "  Build OS:               %s %s %s\n"
 392 "  JobId:                  %d\n"
 393 "  Job:                    %s\n"
 394 "  Backup Level:           Virtual Full\n"
 395 "  Client:                 \"%s\" %s\n"
 396 "  FileSet:                \"%s\" %s\n"
 397 "  Pool:                   \"%s\" (From %s)\n"
 398 "  Catalog:                \"%s\" (From %s)\n"
 399 "  Storage:                \"%s\" (From %s)\n"
 400 "  Scheduled time:         %s\n"
 401 "  Start time:             %s\n"
 402 "  End time:               %s\n"
 403 "  Elapsed time:           %s\n"
 404 "  Priority:               %d\n"
 405 "  SD Files Written:       %s\n"
 406 "  SD Bytes Written:       %s (%sB)\n"
 407 "  Rate:                   %.1f KB/s\n"
 408 "  Volume name(s):         %s\n"
 409 "  Volume Session Id:      %d\n"
 410 "  Volume Session Time:    %d\n"
 411 "  Last Volume Bytes:      %s (%sB)\n"
 412 "  SD Errors:              %d\n"
 413 "  SD termination status:  %s\n"
 414 "  Termination:            %s\n\n"),
 415         BACULA, my_name, VERSION, LSMDATE,
 416         HOST_OS, DISTNAME, DISTVER,
 417         jcr->jr.JobId,
 418         jcr->jr.Job,
 419         jcr->client->name(), cr.Uname,
 420         jcr->fileset->name(), jcr->FSCreateTime,
 421         jcr->pool->name(), jcr->pool_source,
 422         jcr->catalog->name(), jcr->catalog_source,
 423         jcr->wstore->name(), jcr->wstore_source,
 424         schedt,
 425         sdt,
 426         edt,
 427         edit_utime(RunTime, elapsed, sizeof(elapsed)),
 428         jcr->JobPriority,
 429         edit_uint64_with_commas(jcr->jr.JobFiles, ec1),
 430         edit_uint64_with_commas(jcr->jr.JobBytes, ec3),
 431         edit_uint64_with_suffix(jcr->jr.JobBytes, ec4),
 432         kbps,
 433         jcr->VolumeName,
 434         jcr->VolSessionId,
 435         jcr->VolSessionTime,
 436         edit_uint64_with_commas(mr.VolBytes, ec7),
 437         edit_uint64_with_suffix(mr.VolBytes, ec8),
 438         jcr->SDErrors,
 439         sd_term_msg,
 440         term_msg);
 441
 442    Dmsg0(100, "Leave vbackup_cleanup()\n");
 443 }
 444
 445 /*
 446  * This callback routine is responsible for inserting the
 447  *  items it gets into the bootstrap structure. For each JobId selected
 448  *  this routine is called once for each file. We do not allow
 449  *  duplicate filenames, but instead keep the info from the most
 450  *  recent file entered (i.e. the JobIds are assumed to be sorted)
 451  *
 452  *   See uar_sel_files in sql_cmds.c for query that calls us.
 453  *      row[0]=Path, row[1]=Filename, row[2]=FileIndex
 454  *      row[3]=JobId row[4]=LStat
 455  */
 456 int insert_bootstrap_handler(void *ctx, int num_fields, char **row)
 457 {
 458    JobId_t JobId;
 459    int FileIndex;
 460    RBSR *bsr = (RBSR *)ctx;
 461
 462    JobId = str_to_int64(row[3]);
 463    FileIndex = str_to_int64(row[2]);
 464    add_findex(bsr, JobId, FileIndex);
 465    return 0;
 466 }
 467
 468
 469 static bool create_bootstrap_file(JCR *jcr, char *jobids)
 470 {
 471    RESTORE_CTX rx;
 472    UAContext *ua;
 473
 474    memset(&rx, 0, sizeof(rx));
 475    rx.bsr = new_bsr();
 476    ua = new_ua_context(jcr);
 477    rx.JobIds = jobids;
 478
 479 #define new_get_file_list
 480 #ifdef new_get_file_list
 481    if (!db_open_batch_connexion(jcr, jcr->db)) {
 482       Jmsg0(jcr, M_FATAL, 0, "Can't get batch sql connexion");
 483       return false;
 484    }
 485
 486    if (!db_get_file_list(jcr, jcr->db_batch, jobids, false /* don't use md5 */,
 487                          insert_bootstrap_handler, (void *)rx.bsr))
 488    {
 489       Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db_batch));
 490    }
 491 #else
 492    char *p;
 493    JobId_t JobId, last_JobId = 0;
 494    rx.query = get_pool_memory(PM_MESSAGE);
 495    for (p=rx.JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
 496       char ed1[50];
 497
 498       if (JobId == last_JobId) {
 499          continue;                    /* eliminate duplicate JobIds */
 500       }
 501       last_JobId = JobId;
 502       /*
 503        * Find files for this JobId and insert them in the tree
 504        */
 505       Mmsg(rx.query, uar_sel_files, edit_int64(JobId, ed1));
 506       Dmsg1(100, "uar_sel_files=%s\n", rx.query);
 507       if (!db_sql_query(ua->db, rx.query, insert_bootstrap_handler, (void *)rx.bsr)) {
 508          Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(ua->db));
 509       }
 510       free_pool_memory(rx.query);
 511       rx.query = NULL;
 512    }
 513 #endif
 514
 515    complete_bsr(ua, rx.bsr);
 516    jcr->ExpectedFiles = write_bsr_file(ua, rx);
 517    if (debug_level >= 10) {
 518       Dmsg1(000,  "Found %d files to consolidate.\n", jcr->ExpectedFiles);
 519    }
 520    if (jcr->ExpectedFiles == 0) {
 521       free_ua_context(ua);
 522       free_bsr(rx.bsr);
 523       return false;
 524    }
 525    free_ua_context(ua);
 526    free_bsr(rx.bsr);
 527    return true;
 528 }