/*
* Run a NDMP restore session.
*/
bool do_ndmp_restore(JCR *jcr)
{
JOB_DBR rjr; /* restore job record */
int status;
memset(&rjr, 0, sizeof(rjr));
jcr->jr.JobLevel = L_FULL; /* Full restore */
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
goto bail_out;
}
Dmsg0(20, "Updated job start record\n");
Dmsg1(20, "RestoreJobId=%d\n", jcr->res.job->RestoreJobId);
/*
* Validate the Job to have a NDMP client.
*/
if (!ndmp_validate_client(jcr)) {
return false;
}
if (!jcr->RestoreBootstrap) {
Jmsg(jcr, M_FATAL, 0, _("Cannot restore without a bootstrap file.\n"
"You probably ran a restore job directly. All restore jobs must\n"
"be run using the restore command.\n"));
goto bail_out;
}
/*
* Print Job Start message
*/
Jmsg(jcr, M_INFO, 0, _("Start Restore Job %s\n"), jcr->Job);
/*
* Read the bootstrap file and do the restore
*/
if (!do_ndmp_restore_bootstrap(jcr)) {
goto bail_out;
}
/*
* Wait for Job Termination
*/
status = ndmp_wait_for_job_termination(jcr);
ndmp_restore_cleanup(jcr, status);
return true;
bail_out:
return false;
}
/*
* Called here before the job is run to do the job
* specific setup.
*/
bool do_native_vbackup_init(JCR *jcr)
{
const char *storage_source;
if (!get_or_create_fileset_record(jcr)) {
Dmsg1(dbglevel, "JobId=%d no FileSet\n", (int)jcr->JobId);
return false;
}
apply_pool_overrides(jcr);
if (!allow_duplicate_job(jcr)) {
return false;
}
jcr->jr.PoolId = get_or_create_pool_record(jcr, jcr->res.pool->name());
if (jcr->jr.PoolId == 0) {
Dmsg1(dbglevel, "JobId=%d no PoolId\n", (int)jcr->JobId);
Jmsg(jcr, M_FATAL, 0, _("Could not get or create a Pool record.\n"));
return false;
}
/*
* Note, at this point, pool is the pool for this job. We
* transfer it to rpool (read pool), and a bit later,
* pool will be changed to point to the write pool,
* which comes from pool->NextPool.
*/
jcr->res.rpool = jcr->res.pool; /* save read pool */
pm_strcpy(jcr->res.rpool_source, jcr->res.pool_source);
/* If pool storage specified, use it for restore */
copy_rstorage(jcr, jcr->res.pool->storage, _("Pool resource"));
Dmsg2(dbglevel, "Read pool=%s (From %s)\n", jcr->res.rpool->name(), jcr->res.rpool_source);
jcr->start_time = time(NULL);
jcr->jr.StartTime = jcr->start_time;
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
/*
* See if there is a next pool override.
*/
if (jcr->res.run_next_pool_override) {
pm_strcpy(jcr->res.npool_source, _("Run NextPool override"));
pm_strcpy(jcr->res.pool_source, _("Run NextPool override"));
storage_source = _("Storage from Run NextPool override");
} else {
/*
* See if there is a next pool override in the Job definition.
*/
if (jcr->res.job->next_pool) {
jcr->res.next_pool = jcr->res.job->next_pool;
pm_strcpy(jcr->res.npool_source, _("Job's NextPool resource"));
pm_strcpy(jcr->res.pool_source, _("Job's NextPool resource"));
storage_source = _("Storage from Job's NextPool resource");
} else {
/*
* Fall back to the pool's NextPool definition.
*/
jcr->res.next_pool = jcr->res.pool->NextPool;
pm_strcpy(jcr->res.npool_source, _("Job Pool's NextPool resource"));
pm_strcpy(jcr->res.pool_source, _("Job Pool's NextPool resource"));
storage_source = _("Storage from Pool's NextPool resource");
}
}
/*
* If the original backup pool has a NextPool, make sure a
* record exists in the database. Note, in this case, we
* will be migrating from pool to pool->NextPool.
*/
if (jcr->res.next_pool) {
jcr->jr.PoolId = get_or_create_pool_record(jcr, jcr->res.next_pool->name());
if (jcr->jr.PoolId == 0) {
return false;
}
}
if (!set_migration_wstorage(jcr, jcr->res.pool, jcr->res.next_pool, storage_source)) {
return false;
}
jcr->res.pool = jcr->res.next_pool;
Dmsg2(dbglevel, "Write pool=%s read rpool=%s\n", jcr->res.pool->name(), jcr->res.rpool->name());
// create_clones(jcr);
return true;
}
/*
* Do a virtual backup, which consolidates all previous backups into
* a sort of synthetic Full.
*
* Returns: false on failure
* true on success
*/
bool do_native_vbackup(JCR *jcr)
{
char ed1[100];
BSOCK *sd;
char *p;
db_list_ctx jobids;
if (!jcr->res.rstorage) {
Jmsg(jcr, M_FATAL, 0, _("No storage for reading given.\n"));
return false;
}
if (!jcr->res.wstorage) {
Jmsg(jcr, M_FATAL, 0, _("No storage for writing given.\n"));
return false;
}
Dmsg2(100, "rstorage=%p wstorage=%p\n", jcr->res.rstorage, jcr->res.wstorage);
Dmsg2(100, "Read store=%s, write store=%s\n",
((STORERES *)jcr->res.rstorage->first())->name(),
((STORERES *)jcr->res.wstorage->first())->name());
/*
* Print Job Start message
*/
Jmsg(jcr, M_INFO, 0, _("Start Virtual Backup JobId %s, Job=%s\n"),
edit_uint64(jcr->JobId, ed1), jcr->Job);
if (!jcr->accurate) {
Jmsg(jcr, M_WARNING, 0,
_("This Job is not an Accurate backup so is not equivalent to a Full backup.\n"));
}
db_accurate_get_jobids(jcr, jcr->db, &jcr->jr, &jobids);
Dmsg1(10, "Accurate jobids=%s\n", jobids.list);
if (jobids.count == 0) {
Jmsg(jcr, M_FATAL, 0, _("No previous Jobs found.\n"));
return false;
}
/*
* Now we find the last job that ran and store it's info in
* the previous_jr record. We will set our times to the
* values from that job so that anything changed after that
* time will be picked up on the next backup.
*/
p = strrchr(jobids.list, ','); /* find last jobid */
if (p != NULL) {
p++;
} else {
p = jobids.list;
}
memset(&jcr->previous_jr, 0, sizeof(jcr->previous_jr));
jcr->previous_jr.JobId = str_to_int64(p);
Dmsg1(10, "Previous JobId=%s\n", p);
if (!db_get_job_record(jcr, jcr->db, &jcr->previous_jr)) {
Jmsg(jcr, M_FATAL, 0, _("Error getting Job record for previous Job: ERR=%s"),
db_strerror(jcr->db));
return false;
}
if (!create_bootstrap_file(jcr, jobids.list)) {
Jmsg(jcr, M_FATAL, 0, _("Could not get or create the FileSet record.\n"));
return false;
}
/*
* Open a message channel connection with the Storage
* daemon. This is to let him know that our client
* will be contacting him for a backup session.
*
*/
Dmsg0(110, "Open connection with storage daemon\n");
jcr->setJobStatus(JS_WaitSD);
/*
* Start conversation with Storage daemon
*/
if (!connect_to_storage_daemon(jcr, 10, me->SDConnectTimeout, true)) {
return false;
}
sd = jcr->store_bsock;
/*
* Now start a job with the Storage daemon
*/
if (!start_storage_daemon_job(jcr, jcr->res.rstorage, jcr->res.wstorage, /* send_bsr */ true)) {
return false;
}
Dmsg0(100, "Storage daemon connection OK\n");
/*
* We re-update the job start record so that the start
* time is set after the run before job. This avoids
* that any files created by the run before job will
* be saved twice. They will be backed up in the current
* job, but not in the next one unless they are changed.
* Without this, they will be backed up in this job and
* in the next job run because in that case, their date
* is after the start of this run.
*/
jcr->start_time = time(NULL);
jcr->jr.StartTime = jcr->start_time;
jcr->jr.JobTDate = jcr->start_time;
jcr->setJobStatus(JS_Running);
/*
* Update job start record
*/
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
return false;
}
/*
* Declare the job started to start the MaxRunTime check
*/
jcr->setJobStarted();
/*
* Start the job prior to starting the message thread below
* to avoid two threads from using the BSOCK structure at
* the same time.
*/
if (!sd->fsend("run")) {
return false;
}
/*
* Now start a Storage daemon message thread
*/
if (!start_storage_daemon_message_thread(jcr)) {
return false;
}
jcr->setJobStatus(JS_Running);
/*
* Pickup Job termination data
* Note, the SD stores in jcr->JobFiles/ReadBytes/JobBytes/JobErrors
*/
wait_for_storage_daemon_termination(jcr);
jcr->setJobStatus(jcr->SDJobStatus);
db_write_batch_file_records(jcr); /* used by bulk batch file insert */
if (!jcr->is_JobStatus(JS_Terminated)) {
return false;
}
native_vbackup_cleanup(jcr, jcr->JobStatus);
return true;
}
/*
* Do a verification of the specified files against the Catlaog
*
* Returns: false on failure
* true on success
*/
bool do_verify(JCR *jcr)
{
const char *level;
BSOCK *fd, *sd;
int stat;
char ed1[100];
JOB_DBR jr;
JobId_t verify_jobid = 0;
char *store_address;
uint32_t store_port;
const char *Name;
free_wstorage(jcr); /* we don't write */
memset(&jcr->previous_jr, 0, sizeof(jcr->previous_jr));
/*
* Find JobId of last job that ran. Note, we do this when
* the job actually starts running, not at schedule time,
* so that we find the last job that terminated before
* this job runs rather than before it is scheduled. This
* permits scheduling a Backup and Verify at the same time,
* but with the Verify at a lower priority.
*
* For VERIFY_CATALOG we want the JobId of the last INIT.
* For VERIFY_VOLUME_TO_CATALOG, we want the JobId of the
* last backup Job.
*/
if (jcr->getJobLevel() == L_VERIFY_CATALOG ||
jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DISK_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DATA) {
memcpy(&jr, &jcr->jr, sizeof(jr));
if (jcr->verify_job &&
(jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DISK_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DATA)) {
Name = jcr->verify_job->name();
} else {
Name = NULL;
}
Dmsg1(100, "find last jobid for: %s\n", NPRT(Name));
/* see if user supplied a jobid= as run argument or from menu */
if (jcr->RestoreJobId) {
verify_jobid = jcr->RestoreJobId;
Dmsg1(100, "Supplied jobid=%d\n", verify_jobid);
} else {
if (!db_find_last_jobid(jcr, jcr->db, Name, &jr)) {
if (jcr->getJobLevel() == L_VERIFY_CATALOG) {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous InitCatalog Job.\n"
"Please run a Verify with Level=InitCatalog before\n"
"running the current Job.\n"));
} else {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous Job for this client.\n"));
}
return false;
}
verify_jobid = jr.JobId;
}
Dmsg1(100, "Last full jobid=%d\n", verify_jobid);
}
/*
* Now get the job record for the previous backup that interests
* us. We use the verify_jobid that we found above.
*/
if (jcr->getJobLevel() == L_VERIFY_CATALOG ||
jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DISK_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DATA) {
jcr->previous_jr.JobId = verify_jobid;
if (!db_get_job_record(jcr, jcr->db, &jcr->previous_jr)) {
Jmsg(jcr, M_FATAL, 0, _("Could not get job record for previous Job. ERR=%s"),
db_strerror(jcr->db));
return false;
}
if (!(jcr->previous_jr.JobStatus == JS_Terminated ||
jcr->previous_jr.JobStatus == JS_Warnings)) {
Jmsg(jcr, M_FATAL, 0, _("Last Job %d did not terminate normally. JobStatus=%c\n"),
verify_jobid, jcr->previous_jr.JobStatus);
return false;
}
Jmsg(jcr, M_INFO, 0, _("Verifying against JobId=%d Job=%s\n"),
jcr->previous_jr.JobId, jcr->previous_jr.Job);
}
/*
* If we are verifying a Volume, we need the Storage
* daemon, so open a connection, otherwise, just
* create a dummy authorization key (passed to
* File daemon but not used).
*/
if (jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG || jcr->getJobLevel() == L_VERIFY_DATA) {
int stat;
/*
* Note: negative status is an error, zero status, means
* no files were backed up, so skip calling SD and
* client.
*/
stat = create_restore_bootstrap_file(jcr);
if (stat < 0) { /* error */
return false;
} else if (stat == 0) { /* No files, nothing to do */
verify_cleanup(jcr, JS_Terminated); /* clean up */
return true; /* get out */
}
} else {
jcr->sd_auth_key = bstrdup("dummy"); /* dummy Storage daemon key */
}
/* Pass the original fileset to the client */
if (jcr->getJobLevel() == L_VERIFY_DATA) {
FILESET_DBR fdbr;
memset(&fdbr, 0, sizeof(fdbr));
fdbr.FileSetId = jcr->previous_jr.FileSetId;
if (!db_get_fileset_record(jcr, jcr->db, &fdbr)) {
Jmsg(jcr, M_FATAL, 0,
_("Could not get fileset record from previous Job. ERR=%s"),
db_strerror(jcr->db));
return false;
}
jcr->fileset = (FILESET *)GetResWithName(R_FILESET, fdbr.FileSet);
if (!jcr->fileset) {
if (jcr->verify_job) {
jcr->fileset = jcr->verify_job->fileset;
Jmsg(jcr, M_WARNING, 0,
_("Could not find FileSet resource \"%s\" from previous Job\n"),
fdbr.FileSet);
Jmsg(jcr, M_INFO, 0,
_("Using FileSet \"%\"\n"), jcr->fileset->name());
} else {
Jmsg(jcr, M_FATAL, 0,
_("Could not get FileSet resource for verify Job."));
return false;
}
}
Dmsg1(50, "FileSet = %s\n", jcr->fileset->name());
}
/* Pass the current fileset to the client */
if (jcr->getJobLevel() == L_VERIFY_DISK_TO_CATALOG && jcr->verify_job) {
jcr->fileset = jcr->verify_job->fileset;
}
Dmsg2(100, "ClientId=%u JobLevel=%c\n",
jcr->previous_jr.ClientId, jcr->getJobLevel());
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
return false;
}
/* Print Job Start message */
Jmsg(jcr, M_INFO, 0, _("Start Verify JobId=%s Level=%s Job=%s\n"),
edit_uint64(jcr->JobId, ed1), level_to_str(jcr->getJobLevel()), jcr->Job);
if (jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DATA)
{
/*
* Start conversation with Storage daemon
*/
jcr->setJobStatus(JS_Blocked);
if (!connect_to_storage_daemon(jcr, 10, SDConnectTimeout, 1)) {
return false;
}
/*
* Now start a job with the Storage daemon
*/
if (!start_storage_daemon_job(jcr, jcr->rstorage, NULL)) {
return false;
}
sd = jcr->store_bsock;
jcr->sd_calls_client = jcr->client->sd_calls_client;
/*
* Send the bootstrap file -- what Volumes/files to restore
*/
if (!send_bootstrap_file(jcr, sd) ||
!response(jcr, sd, OKbootstrap, "Bootstrap", DISPLAY_ERROR)) {
goto bail_out;
}
if (!jcr->sd_calls_client) {
if (!run_storage_and_start_message_thread(jcr, sd)) {
return false;
}
}
}
/*
* OK, now connect to the File daemon
* and ask him for the files.
*/
jcr->setJobStatus(JS_Blocked);
if (!connect_to_file_daemon(jcr, 10, FDConnectTimeout, 1)) {
goto bail_out;
}
jcr->setJobStatus(JS_Running);
fd = jcr->file_bsock;
Dmsg0(30, ">filed: Send include list\n");
if (!send_include_list(jcr)) {
goto bail_out;
}
Dmsg0(30, ">filed: Send exclude list\n");
if (!send_exclude_list(jcr)) {
goto bail_out;
}
/*
* Send Level command to File daemon, as well
* as the Storage address if appropriate.
*/
switch (jcr->getJobLevel()) {
case L_VERIFY_INIT:
level = "init";
break;
case L_VERIFY_CATALOG:
level = "catalog";
break;
case L_VERIFY_DATA:
case L_VERIFY_VOLUME_TO_CATALOG:
if (jcr->sd_calls_client) {
if (jcr->FDVersion < 10) {
Jmsg(jcr, M_FATAL, 0, _("The File daemon does not support SDCallsClient.\n"));
goto bail_out;
}
if (!send_client_addr_to_sd(jcr)) {
goto bail_out;
}
if (!run_storage_and_start_message_thread(jcr, jcr->store_bsock)) {
return false;
}
store_address = jcr->rstore->address; /* dummy */
store_port = 0; /* flag that SD calls FD */
} else {
/*
* send Storage daemon address to the File daemon
*/
if (jcr->rstore->SDDport == 0) {
jcr->rstore->SDDport = jcr->rstore->SDport;
}
store_address = get_storage_address(jcr->client, jcr->rstore);
store_port = jcr->rstore->SDDport;
}
if (!send_store_addr_to_fd(jcr, jcr->rstore, store_address, store_port)) {
goto bail_out;
}
if (!jcr->RestoreBootstrap) {
Jmsg0(jcr, M_FATAL, 0, _("Deprecated feature ... use bootstrap.\n"));
goto bail_out;
}
if (jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG) {
level = "volume";
} else {
level = "data";
}
break;
case L_VERIFY_DISK_TO_CATALOG:
level="disk_to_catalog";
break;
default:
Jmsg2(jcr, M_FATAL, 0, _("Unimplemented Verify level %d(%c)\n"),
jcr->getJobLevel(),
jcr->getJobLevel());
goto bail_out;
}
if (!send_runscripts_commands(jcr)) {
goto bail_out;
}
/*
* Send verify command/level to File daemon
*/
fd->fsend(verifycmd, level);
if (!response(jcr, fd, OKverify, "Verify", DISPLAY_ERROR)) {
goto bail_out;
}
/*
* Now get data back from File daemon and
* compare it to the catalog or store it in the
* catalog depending on the run type.
*/
/* Compare to catalog */
switch (jcr->getJobLevel()) {
case L_VERIFY_CATALOG:
Dmsg0(10, "Verify level=catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_VOLUME_TO_CATALOG:
Dmsg0(10, "Verify level=volume\n");
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_DISK_TO_CATALOG:
Dmsg0(10, "Verify level=disk_to_catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_INIT:
/* Build catalog */
Dmsg0(10, "Verify level=init\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_put_in_catalog(jcr);
db_end_transaction(jcr, jcr->db); /* terminate any open transaction */
db_write_batch_file_records(jcr);
break;
case L_VERIFY_DATA:
/* Nothing special to do */
bget_dirmsg(fd); /* eat EOD */
break;
default:
Jmsg1(jcr, M_FATAL, 0, _("Unimplemented verify level %d\n"), jcr->getJobLevel());
goto bail_out;
}
stat = wait_for_job_termination(jcr);
verify_cleanup(jcr, stat);
return true;
bail_out:
return false;
}
/*
* This is the engine called by jobq.c:jobq_add() when we were pulled
* from the work queue.
* At this point, we are running in our own thread and all
* necessary resources are allocated -- see jobq.c
*/
static void *job_thread(void *arg)
{
JCR *jcr = (JCR *)arg;
pthread_detach(pthread_self());
Dsm_check(100);
Dmsg0(200, "=====Start Job=========\n");
jcr->setJobStatus(JS_Running); /* this will be set only if no error */
jcr->start_time = time(NULL); /* set the real start time */
jcr->jr.StartTime = jcr->start_time;
if (jcr->res.job->MaxStartDelay != 0 && jcr->res.job->MaxStartDelay <
(utime_t)(jcr->start_time - jcr->sched_time)) {
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n"));
}
if (job_check_maxrunschedtime(jcr)) {
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max run sched time exceeded.\n"));
}
/* TODO : check if it is used somewhere */
if (jcr->res.job->RunScripts == NULL) {
Dmsg0(200, "Warning, job->RunScripts is empty\n");
jcr->res.job->RunScripts = New(alist(10, not_owned_by_alist));
}
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
/* Run any script BeforeJob on dird */
run_scripts(jcr, jcr->res.job->RunScripts, "BeforeJob");
/*
* We re-update the job start record so that the start
* time is set after the run before job. This avoids
* that any files created by the run before job will
* be saved twice. They will be backed up in the current
* job, but not in the next one unless they are changed.
* Without this, they will be backed up in this job and
* in the next job run because in that case, their date
* is after the start of this run.
*/
jcr->start_time = time(NULL);
jcr->jr.StartTime = jcr->start_time;
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
generate_plugin_event(jcr, bDirEventJobRun);
switch (jcr->getJobType()) {
case JT_BACKUP:
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (!job_canceled(jcr)) {
if (do_ndmp_backup(jcr)) {
do_autoprune(jcr);
} else {
ndmp_backup_cleanup(jcr, JS_ErrorTerminated);
}
} else {
ndmp_backup_cleanup(jcr, JS_Canceled);
}
break;
default:
if (!job_canceled(jcr)) {
if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
if (do_native_vbackup(jcr)) {
do_autoprune(jcr);
} else {
native_vbackup_cleanup(jcr, JS_ErrorTerminated);
}
} else {
if (do_native_backup(jcr)) {
do_autoprune(jcr);
} else {
native_backup_cleanup(jcr, JS_ErrorTerminated);
}
}
} else {
if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
native_vbackup_cleanup(jcr, JS_Canceled);
} else {
native_backup_cleanup(jcr, JS_Canceled);
}
}
break;
}
break;
case JT_VERIFY:
if (!job_canceled(jcr)) {
if (do_verify(jcr)) {
do_autoprune(jcr);
} else {
verify_cleanup(jcr, JS_ErrorTerminated);
}
} else {
verify_cleanup(jcr, JS_Canceled);
}
break;
case JT_RESTORE:
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (!job_canceled(jcr)) {
if (do_ndmp_restore(jcr)) {
do_autoprune(jcr);
} else {
ndmp_restore_cleanup(jcr, JS_ErrorTerminated);
}
} else {
ndmp_restore_cleanup(jcr, JS_Canceled);
}
break;
default:
if (!job_canceled(jcr)) {
if (do_native_restore(jcr)) {
do_autoprune(jcr);
} else {
native_restore_cleanup(jcr, JS_ErrorTerminated);
}
} else {
native_restore_cleanup(jcr, JS_Canceled);
}
break;
}
break;
case JT_ADMIN:
if (!job_canceled(jcr)) {
if (do_admin(jcr)) {
do_autoprune(jcr);
} else {
admin_cleanup(jcr, JS_ErrorTerminated);
}
} else {
admin_cleanup(jcr, JS_Canceled);
}
break;
case JT_COPY:
case JT_MIGRATE:
if (!job_canceled(jcr)) {
if (do_migration(jcr)) {
do_autoprune(jcr);
} else {
migration_cleanup(jcr, JS_ErrorTerminated);
}
} else {
migration_cleanup(jcr, JS_Canceled);
}
break;
default:
Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->getJobType());
break;
}
run_scripts(jcr, jcr->res.job->RunScripts, "AfterJob");
/* Send off any queued messages */
if (jcr->msg_queue && jcr->msg_queue->size() > 0) {
dequeue_messages(jcr);
}
generate_plugin_event(jcr, bDirEventJobEnd);
Dmsg1(50, "======== End Job stat=%c ==========\n", jcr->JobStatus);
Dsm_check(100);
return NULL;
}
/*
* Do a verification of the specified files against the Catlaog
*
* Returns: false on failure
* true on success
*/
bool do_verify(JCR *jcr)
{
const char *level;
BSOCK *fd;
int stat;
char ed1[100];
JOB_DBR jr;
JobId_t verify_jobid = 0;
const char *Name;
free_wstorage(jcr); /* we don't write */
memset(&jcr->previous_jr, 0, sizeof(jcr->previous_jr));
/*
* Find JobId of last job that ran. Note, we do this when
* the job actually starts running, not at schedule time,
* so that we find the last job that terminated before
* this job runs rather than before it is scheduled. This
* permits scheduling a Backup and Verify at the same time,
* but with the Verify at a lower priority.
*
* For VERIFY_CATALOG we want the JobId of the last INIT.
* For VERIFY_VOLUME_TO_CATALOG, we want the JobId of the
* last backup Job.
*/
if (jcr->get_JobLevel() == L_VERIFY_CATALOG ||
jcr->get_JobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->get_JobLevel() == L_VERIFY_DISK_TO_CATALOG) {
memcpy(&jr, &jcr->jr, sizeof(jr));
if (jcr->verify_job &&
(jcr->get_JobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->get_JobLevel() == L_VERIFY_DISK_TO_CATALOG)) {
Name = jcr->verify_job->name();
} else {
Name = NULL;
}
Dmsg1(100, "find last jobid for: %s\n", NPRT(Name));
if (!db_find_last_jobid(jcr, jcr->db, Name, &jr)) {
if (jcr->get_JobLevel() == L_VERIFY_CATALOG) {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous InitCatalog Job.\n"
"Please run a Verify with Level=InitCatalog before\n"
"running the current Job.\n"));
} else {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous Job for this client.\n"));
}
return false;
}
verify_jobid = jr.JobId;
Dmsg1(100, "Last full jobid=%d\n", verify_jobid);
}
/*
* Now get the job record for the previous backup that interests
* us. We use the verify_jobid that we found above.
*/
if (jcr->get_JobLevel() == L_VERIFY_CATALOG ||
jcr->get_JobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->get_JobLevel() == L_VERIFY_DISK_TO_CATALOG) {
jcr->previous_jr.JobId = verify_jobid;
if (!db_get_job_record(jcr, jcr->db, &jcr->previous_jr)) {
Jmsg(jcr, M_FATAL, 0, _("Could not get job record for previous Job. ERR=%s"),
db_strerror(jcr->db));
return false;
}
if (!(jcr->previous_jr.JobStatus == JS_Terminated ||
jcr->previous_jr.JobStatus == JS_Warnings)) {
Jmsg(jcr, M_FATAL, 0, _("Last Job %d did not terminate normally. JobStatus=%c\n"),
verify_jobid, jcr->previous_jr.JobStatus);
return false;
}
Jmsg(jcr, M_INFO, 0, _("Verifying against JobId=%d Job=%s\n"),
jcr->previous_jr.JobId, jcr->previous_jr.Job);
}
/*
* If we are verifying a Volume, we need the Storage
* daemon, so open a connection, otherwise, just
* create a dummy authorization key (passed to
* File daemon but not used).
*/
if (jcr->get_JobLevel() == L_VERIFY_VOLUME_TO_CATALOG) {
if (!create_restore_bootstrap_file(jcr)) {
return false;
}
} else {
jcr->sd_auth_key = bstrdup("dummy"); /* dummy Storage daemon key */
}
if (jcr->get_JobLevel() == L_VERIFY_DISK_TO_CATALOG && jcr->verify_job) {
jcr->fileset = jcr->verify_job->fileset;
}
Dmsg2(100, "ClientId=%u JobLevel=%c\n", jcr->previous_jr.ClientId, jcr->get_JobLevel());
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
return false;
}
/* Print Job Start message */
Jmsg(jcr, M_INFO, 0, _("Start Verify JobId=%s Level=%s Job=%s\n"),
edit_uint64(jcr->JobId, ed1), level_to_str(jcr->get_JobLevel()), jcr->Job);
if (jcr->get_JobLevel() == L_VERIFY_VOLUME_TO_CATALOG) {
/*
* Start conversation with Storage daemon
*/
set_jcr_job_status(jcr, JS_Blocked);
if (!connect_to_storage_daemon(jcr, 10, SDConnectTimeout, 1)) {
return false;
}
/*
* Now start a job with the Storage daemon
*/
if (!start_storage_daemon_job(jcr, jcr->rstorage, NULL)) {
return false;
}
if (!jcr->store_bsock->fsend("run")) {
return false;
}
/*
* Now start a Storage daemon message thread
*/
if (!start_storage_daemon_message_thread(jcr)) {
return false;
}
Dmsg0(50, "Storage daemon connection OK\n");
}
/*
* OK, now connect to the File daemon
* and ask him for the files.
*/
set_jcr_job_status(jcr, JS_Blocked);
if (!connect_to_file_daemon(jcr, 10, FDConnectTimeout, 1)) {
goto bail_out;
}
set_jcr_job_status(jcr, JS_Running);
fd = jcr->file_bsock;
Dmsg0(30, ">filed: Send include list\n");
if (!send_include_list(jcr)) {
goto bail_out;
}
Dmsg0(30, ">filed: Send exclude list\n");
if (!send_exclude_list(jcr)) {
goto bail_out;
}
/*
* Send Level command to File daemon, as well
* as the Storage address if appropriate.
*/
switch (jcr->get_JobLevel()) {
case L_VERIFY_INIT:
level = "init";
break;
case L_VERIFY_CATALOG:
level = "catalog";
break;
case L_VERIFY_VOLUME_TO_CATALOG:
/*
* send Storage daemon address to the File daemon
*/
if (jcr->rstore->SDDport == 0) {
jcr->rstore->SDDport = jcr->rstore->SDport;
}
bnet_fsend(fd, storaddr, jcr->rstore->address, jcr->rstore->SDDport);
if (!response(jcr, fd, OKstore, "Storage", DISPLAY_ERROR)) {
goto bail_out;
}
/*
* Send the bootstrap file -- what Volumes/files to restore
*/
if (!send_bootstrap_file(jcr, fd) ||
!response(jcr, fd, OKbootstrap, "Bootstrap", DISPLAY_ERROR)) {
goto bail_out;
}
if (!jcr->RestoreBootstrap) {
Jmsg0(jcr, M_FATAL, 0, _("Deprecated feature ... use bootstrap.\n"));
goto bail_out;
}
level = "volume";
break;
case L_VERIFY_DATA:
level = "data";
break;
case L_VERIFY_DISK_TO_CATALOG:
level="disk_to_catalog";
break;
default:
Jmsg2(jcr, M_FATAL, 0, _("Unimplemented Verify level %d(%c)\n"), jcr->get_JobLevel(),
jcr->get_JobLevel());
goto bail_out;
}
if (!send_runscripts_commands(jcr)) {
goto bail_out;
}
/*
* Send verify command/level to File daemon
*/
fd->fsend(verifycmd, level);
if (!response(jcr, fd, OKverify, "Verify", DISPLAY_ERROR)) {
goto bail_out;
}
/*
* Now get data back from File daemon and
* compare it to the catalog or store it in the
* catalog depending on the run type.
*/
/* Compare to catalog */
switch (jcr->get_JobLevel()) {
case L_VERIFY_CATALOG:
Dmsg0(10, "Verify level=catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_VOLUME_TO_CATALOG:
Dmsg0(10, "Verify level=volume\n");
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_DISK_TO_CATALOG:
Dmsg0(10, "Verify level=disk_to_catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_INIT:
/* Build catalog */
Dmsg0(10, "Verify level=init\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_put_in_catalog(jcr);
db_end_transaction(jcr, jcr->db); /* terminate any open transaction */
db_write_batch_file_records(jcr);
break;
default:
Jmsg1(jcr, M_FATAL, 0, _("Unimplemented verify level %d\n"), jcr->get_JobLevel());
goto bail_out;
}
stat = wait_for_job_termination(jcr);
verify_cleanup(jcr, stat);
return true;
bail_out:
return false;
}
/*
* Do a verification of the specified files against the Catlaog
*
* Returns: false on failure
* true on success
*/
bool do_verify(JCR *jcr)
{
int JobLevel;
const char *level;
BSOCK *fd = NULL;
BSOCK *sd = NULL;
int status;
char ed1[100];
JOB_DBR jr;
JobId_t verify_jobid = 0;
const char *Name;
free_wstorage(jcr); /* we don't write */
memset(&jcr->previous_jr, 0, sizeof(jcr->previous_jr));
/*
* Find JobId of last job that ran. Note, we do this when
* the job actually starts running, not at schedule time,
* so that we find the last job that terminated before
* this job runs rather than before it is scheduled. This
* permits scheduling a Backup and Verify at the same time,
* but with the Verify at a lower priority.
*
* For VERIFY_CATALOG we want the JobId of the last INIT.
* For VERIFY_VOLUME_TO_CATALOG, we want the JobId of the
* last backup Job.
*/
JobLevel = jcr->getJobLevel();
switch (JobLevel) {
case L_VERIFY_CATALOG:
case L_VERIFY_VOLUME_TO_CATALOG:
case L_VERIFY_DISK_TO_CATALOG:
memcpy(&jr, &jcr->jr, sizeof(jr));
if (jcr->res.verify_job &&
(JobLevel == L_VERIFY_VOLUME_TO_CATALOG ||
JobLevel == L_VERIFY_DISK_TO_CATALOG)) {
Name = jcr->res.verify_job->name();
} else {
Name = NULL;
}
Dmsg1(100, "find last jobid for: %s\n", NPRT(Name));
/*
* See if user supplied a jobid= as run argument or from menu
*/
if (jcr->VerifyJobId) {
verify_jobid = jcr->VerifyJobId;
Dmsg1(100, "Supplied jobid=%d\n", verify_jobid);
} else {
if (!db_find_last_jobid(jcr, jcr->db, Name, &jr)) {
if (JobLevel == L_VERIFY_CATALOG) {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous InitCatalog Job.\n"
"Please run a Verify with Level=InitCatalog before\n"
"running the current Job.\n"));
} else {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous Job for this client.\n"));
}
return false;
}
verify_jobid = jr.JobId;
}
Dmsg1(100, "Last full jobid=%d\n", verify_jobid);
/*
* Now get the job record for the previous backup that interests
* us. We use the verify_jobid that we found above.
*/
jcr->previous_jr.JobId = verify_jobid;
if (!db_get_job_record(jcr, jcr->db, &jcr->previous_jr)) {
Jmsg(jcr, M_FATAL, 0, _("Could not get job record for previous Job. ERR=%s"),
db_strerror(jcr->db));
return false;
}
if (!(jcr->previous_jr.JobStatus == JS_Terminated ||
jcr->previous_jr.JobStatus == JS_Warnings)) {
Jmsg(jcr, M_FATAL, 0, _("Last Job %d did not terminate normally. JobStatus=%c\n"),
verify_jobid, jcr->previous_jr.JobStatus);
return false;
}
Jmsg(jcr, M_INFO, 0, _("Verifying against JobId=%d Job=%s\n"),
jcr->previous_jr.JobId, jcr->previous_jr.Job);
}
/*
* If we are verifying a Volume, we need the Storage
* daemon, so open a connection, otherwise, just
* create a dummy authorization key (passed to
* File daemon but not used).
*/
switch (JobLevel) {
case L_VERIFY_VOLUME_TO_CATALOG:
/*
* Note: negative status is an error, zero status, means
* no files were backed up, so skip calling SD and
* client.
*/
status = create_restore_bootstrap_file(jcr);
if (status < 0) { /* error */
return false;
} else if (status == 0) { /* No files, nothing to do */
verify_cleanup(jcr, JS_Terminated); /* clean up */
return true; /* get out */
}
if (jcr->res.verify_job) {
jcr->res.fileset = jcr->res.verify_job->fileset;
}
break;
default:
jcr->sd_auth_key = bstrdup("dummy"); /* dummy Storage daemon key */
break;
}
Dmsg2(100, "ClientId=%u JobLevel=%c\n", jcr->previous_jr.ClientId, JobLevel);
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
return false;
}
/*
* Print Job Start message
*/
Jmsg(jcr, M_INFO, 0, _("Start Verify JobId=%s Level=%s Job=%s\n"),
edit_uint64(jcr->JobId, ed1), level_to_str(JobLevel), jcr->Job);
switch (JobLevel) {
case L_VERIFY_VOLUME_TO_CATALOG:
/*
* Start conversation with Storage daemon
*/
jcr->setJobStatus(JS_Blocked);
if (!connect_to_storage_daemon(jcr, 10, me->SDConnectTimeout, true)) {
return false;
}
sd = jcr->store_bsock;
/*
* Now start a job with the Storage daemon
*/
if (!start_storage_daemon_job(jcr, jcr->res.rstorage, NULL, /* send_bsr */ true)) {
return false;
}
jcr->passive_client = jcr->res.client->passive;
if (!jcr->passive_client) {
/*
* Start the Job in the SD.
*/
if (!sd->fsend("run")) {
return false;
}
/*
* Now start a Storage daemon message thread
*/
if (!start_storage_daemon_message_thread(jcr)) {
return false;
}
Dmsg0(50, "Storage daemon connection OK\n");
}
/*
* OK, now connect to the File daemon and ask him for the files.
*/
jcr->setJobStatus(JS_Blocked);
if (!connect_to_file_daemon(jcr, 10, me->FDConnectTimeout, true)) {
goto bail_out;
}
send_job_info(jcr);
fd = jcr->file_bsock;
/*
* Check if the file daemon supports passive client mode.
*/
if (jcr->passive_client && jcr->FDVersion < FD_VERSION_51) {
Jmsg(jcr, M_FATAL, 0,
_("Client \"%s\" doesn't support passive client mode. "
"Please upgrade your client or disable compat mode.\n"),
jcr->res.client->name());
goto bail_out;
}
break;
default:
/*
* OK, now connect to the File daemon and ask him for the files.
*/
jcr->setJobStatus(JS_Blocked);
if (!connect_to_file_daemon(jcr, 10, me->FDConnectTimeout, true)) {
goto bail_out;
}
send_job_info(jcr);
fd = jcr->file_bsock;
break;
}
jcr->setJobStatus(JS_Running);
Dmsg0(30, ">filed: Send include list\n");
if (!send_include_list(jcr)) {
goto bail_out;
}
Dmsg0(30, ">filed: Send exclude list\n");
if (!send_exclude_list(jcr)) {
goto bail_out;
}
/*
* Send Level command to File daemon, as well as the Storage address if appropriate.
*/
switch (JobLevel) {
case L_VERIFY_INIT:
level = "init";
break;
case L_VERIFY_CATALOG:
level = "catalog";
break;
case L_VERIFY_VOLUME_TO_CATALOG:
if (!jcr->RestoreBootstrap) {
Jmsg0(jcr, M_FATAL, 0, _("Deprecated feature ... use bootstrap.\n"));
goto bail_out;
}
if (!jcr->passive_client) {
int tls_need = BNET_TLS_NONE;
STORERES *store = jcr->res.rstore;
/*
* Send Storage daemon address to the File daemon
*/
if (store->SDDport == 0) {
store->SDDport = store->SDport;
}
/*
* TLS Requirement
*/
if (store->tls.enable) {
if (store->tls.require) {
tls_need = BNET_TLS_REQUIRED;
} else {
tls_need = BNET_TLS_OK;
}
}
fd->fsend(storaddrcmd, store->address, store->SDDport, tls_need, jcr->sd_auth_key);
if (!response(jcr, fd, OKstore, "Storage", DISPLAY_ERROR)) {
goto bail_out;
}
} else {
int tls_need = BNET_TLS_NONE;
CLIENTRES *client = jcr->res.client;
/*
* TLS Requirement
*/
if (client->tls.enable) {
if (client->tls.require) {
tls_need = BNET_TLS_REQUIRED;
} else {
tls_need = BNET_TLS_OK;
}
}
/*
* Tell the SD to connect to the FD.
*/
sd->fsend(passiveclientcmd, client->address, client->FDport, tls_need);
if (!response(jcr, sd, OKpassiveclient, "Passive client", DISPLAY_ERROR)) {
goto bail_out;
}
/*
* Start the Job in the SD.
*/
if (!sd->fsend("run")) {
goto bail_out;
}
/*
* Now start a Storage daemon message thread
*/
if (!start_storage_daemon_message_thread(jcr)) {
goto bail_out;
}
Dmsg0(50, "Storage daemon connection OK\n");
}
level = "volume";
break;
case L_VERIFY_DATA:
level = "data";
break;
case L_VERIFY_DISK_TO_CATALOG:
level="disk_to_catalog";
break;
default:
Jmsg2(jcr, M_FATAL, 0, _("Unimplemented Verify level %d(%c)\n"), JobLevel, JobLevel);
goto bail_out;
}
if (!send_runscripts_commands(jcr)) {
goto bail_out;
}
/*
* Send verify command/level to File daemon
*/
fd->fsend(verifycmd, level);
if (!response(jcr, fd, OKverify, "Verify", DISPLAY_ERROR)) {
goto bail_out;
}
/*
* Now get data back from File daemon and
* compare it to the catalog or store it in the
* catalog depending on the run type.
*/
switch (JobLevel) {
case L_VERIFY_CATALOG:
/*
* Verify from catalog
*/
Dmsg0(10, "Verify level=catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_VOLUME_TO_CATALOG:
/*
* Verify Volume to catalog entries
*/
Dmsg0(10, "Verify level=volume\n");
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_DISK_TO_CATALOG:
/*
* Verify Disk attributes to catalog
*/
Dmsg0(10, "Verify level=disk_to_catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_INIT:
/*
* Build catalog
*/
Dmsg0(10, "Verify level=init\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_put_in_catalog(jcr);
db_end_transaction(jcr, jcr->db); /* terminate any open transaction */
db_write_batch_file_records(jcr);
break;
default:
Jmsg1(jcr, M_FATAL, 0, _("Unimplemented verify level %d\n"), JobLevel);
goto bail_out;
}
status = wait_for_job_termination(jcr);
verify_cleanup(jcr, status);
return true;
bail_out:
if (jcr->file_bsock) {
jcr->file_bsock->signal(BNET_TERMINATE);
jcr->file_bsock->close();
delete jcr->file_bsock;
jcr->file_bsock = NULL;
}
return false;
}
/*
* Do a backup of the specified FileSet
*
* Returns: false on failure
* true on success
*/
bool do_backup(JCR *jcr)
{
int stat;
int tls_need = BNET_TLS_NONE;
BSOCK *fd;
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"),
edit_uint64(jcr->JobId, ed1), jcr->Job);
set_jcr_job_status(jcr, JS_Running);
Dmsg2(100, "JobId=%d JobLevel=%c\n", jcr->jr.JobId, jcr->jr.JobLevel);
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
return false;
}
/*
* Open a message channel connection with the Storage
* daemon. This is to let him know that our client
* will be contacting him for a backup session.
*
*/
Dmsg0(110, "Open connection with storage daemon\n");
set_jcr_job_status(jcr, JS_WaitSD);
/*
* Start conversation with Storage daemon
*/
if (!connect_to_storage_daemon(jcr, 10, SDConnectTimeout, 1)) {
return false;
}
/*
* Now start a job with the Storage daemon
*/
if (!start_storage_daemon_job(jcr, NULL, jcr->wstorage)) {
return false;
}
/*
* Start the job prior to starting the message thread below
* to avoid two threads from using the BSOCK structure at
* the same time.
*/
if (!bnet_fsend(jcr->store_bsock, "run")) {
return false;
}
/*
* Now start a Storage daemon message thread. Note,
* this thread is used to provide the catalog services
* for the backup job, including inserting the attributes
* into the catalog. See catalog_update() in catreq.c
*/
if (!start_storage_daemon_message_thread(jcr)) {
return false;
}
Dmsg0(150, "Storage daemon connection OK\n");
set_jcr_job_status(jcr, JS_WaitFD);
if (!connect_to_file_daemon(jcr, 10, FDConnectTimeout, 1)) {
goto bail_out;
}
set_jcr_job_status(jcr, JS_Running);
fd = jcr->file_bsock;
if (!send_include_list(jcr)) {
goto bail_out;
}
if (!send_exclude_list(jcr)) {
goto bail_out;
}
if (!send_level_command(jcr)) {
goto bail_out;
}
/*
* send Storage daemon address to the File daemon
*/
store = jcr->wstore;
if (store->SDDport == 0) {
store->SDDport = store->SDport;
}
/* TLS Requirement */
if (store->tls_enable) {
if (store->tls_require) {
tls_need = BNET_TLS_REQUIRED;
} else {
tls_need = BNET_TLS_OK;
}
}
fd->fsend(storaddr, store->address, store->SDDport, tls_need);
if (!response(jcr, fd, OKstore, "Storage", DISPLAY_ERROR)) {
goto bail_out;
}
if (!send_runscripts_commands(jcr)) {
goto bail_out;
}
/*
* We re-update the job start record so that the start
* time is set after the run before job. This avoids
* that any files created by the run before job will
* be saved twice. They will be backed up in the current
* job, but not in the next one unless they are changed.
* Without this, they will be backed up in this job and
* in the next job run because in that case, their date
* is after the start of this run.
*/
jcr->start_time = time(NULL);
jcr->jr.StartTime = jcr->start_time;
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
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 */
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;
}
return false;
/* Come here only after starting SD thread */
bail_out:
set_jcr_job_status(jcr, JS_ErrorTerminated);
Dmsg1(400, "wait for sd. use=%d\n", jcr->use_count());
/* Cancel SD */
wait_for_job_termination(jcr, FDConnectTimeout);
Dmsg1(400, "after wait for sd. use=%d\n", jcr->use_count());
return false;
}
