/*
* Complete the BSR by filling in the VolumeName and
* VolSessionId and VolSessionTime using the JobId
*/
bool complete_bsr(UAContext *ua, RBSR *bsr)
{
for ( ; bsr; bsr=bsr->next) {
JOB_DBR jr;
memset(&jr, 0, sizeof(jr));
jr.JobId = bsr->JobId;
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record. ERR=%s\n"), db_strerror(ua->db));
return false;
}
bsr->VolSessionId = jr.VolSessionId;
bsr->VolSessionTime = jr.VolSessionTime;
if (jr.JobFiles == 0) { /* zero files is OK, not an error, but */
bsr->VolCount = 0; /* there are no volumes */
continue;
}
if ((bsr->VolCount=db_get_job_volume_parameters(ua->jcr, ua->db, bsr->JobId,
&(bsr->VolParams))) == 0) {
ua->error_msg(_("Unable to get Job Volume Parameters. ERR=%s\n"), db_strerror(ua->db));
if (bsr->VolParams) {
free(bsr->VolParams);
bsr->VolParams = NULL;
}
return false;
}
}
return true;
}
/*
* Release resources allocated during backup.
*/
void admin_cleanup(JCR *jcr, int TermCode)
{
char sdt[50], edt[50], schedt[50];
char term_code[100];
const char *term_msg;
int msg_type;
MEDIA_DBR mr;
Dmsg0(100, "Enter backup_cleanup()\n");
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 Job report: ERR=%s"),
db_strerror(jcr->db));
jcr->setJobStatus(JS_ErrorTerminated);
}
msg_type = M_INFO; /* by default INFO message */
switch (jcr->JobStatus) {
case JS_Terminated:
term_msg = _("Admin OK");
break;
case JS_FatalError:
case JS_ErrorTerminated:
term_msg = _("*** Admin Error ***");
msg_type = M_ERROR; /* Generate error message */
break;
case JS_Canceled:
term_msg = _("Admin Canceled");
break;
default:
term_msg = term_code;
sprintf(term_code, _("Inappropriate term code: %c\n"), jcr->JobStatus);
break;
}
bstrftimes(schedt, sizeof(schedt), jcr->jr.SchedTime);
bstrftimes(sdt, sizeof(sdt), jcr->jr.StartTime);
bstrftimes(edt, sizeof(edt), jcr->jr.EndTime);
Jmsg(jcr, msg_type, 0, _("Bacula " VERSION " (" LSMDATE "): %s\n"
" JobId: %d\n"
" Job: %s\n"
" Scheduled time: %s\n"
" Start time: %s\n"
" End time: %s\n"
" Termination: %s\n\n"),
edt,
jcr->jr.JobId,
jcr->jr.Job,
schedt,
sdt,
edt,
term_msg);
Dmsg0(100, "Leave admin_cleanup()\n");
}
/*
* Release resources allocated during backup.
*/
void native_vbackup_cleanup(JCR *jcr, int TermCode)
{
char ec1[30], ec2[30];
char term_code[100];
const char *term_msg;
int msg_type = M_INFO;
CLIENT_DBR cr;
POOL_MEM query(PM_MESSAGE);
Dmsg2(100, "Enter backup_cleanup %d %c\n", TermCode, TermCode);
memset(&cr, 0, sizeof(cr));
switch (jcr->JobStatus) {
case JS_Terminated:
case JS_Warnings:
jcr->jr.JobLevel = L_FULL; /* we want this to appear as a Full backup */
break;
default:
break;
}
jcr->JobFiles = jcr->SDJobFiles;
jcr->JobBytes = jcr->SDJobBytes;
if (jcr->getJobStatus() == JS_Terminated &&
(jcr->JobErrors || jcr->SDErrors)) {
TermCode = JS_Warnings;
}
update_job_end(jcr, TermCode);
/*
* Update final items to set them to the previous job's values
*/
Mmsg(query, "UPDATE Job SET StartTime='%s',EndTime='%s',"
"JobTDate=%s WHERE JobId=%s",
jcr->previous_jr.cStartTime, jcr->previous_jr.cEndTime,
edit_uint64(jcr->previous_jr.JobTDate, ec1),
edit_uint64(jcr->JobId, ec2));
db_sql_query(jcr->db, query.c_str());
/*
* Get the fully updated job record
*/
if (!db_get_job_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_WARNING, 0, _("Error getting Job record for Job report: ERR=%s"),
db_strerror(jcr->db));
jcr->setJobStatus(JS_ErrorTerminated);
}
bstrncpy(cr.Name, jcr->res.client->name(), sizeof(cr.Name));
if (!db_get_client_record(jcr, jcr->db, &cr)) {
Jmsg(jcr, M_WARNING, 0, _("Error getting Client record for Job report: ERR=%s"),
db_strerror(jcr->db));
}
update_bootstrap_file(jcr);
switch (jcr->JobStatus) {
case JS_Terminated:
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) {
jcr->store_bsock->signal(BNET_TERMINATE);
if (jcr->SD_msg_chan_started) {
pthread_cancel(jcr->SD_msg_chan);
}
}
break;
case JS_Canceled:
term_msg = _("Backup Canceled");
if (jcr->store_bsock) {
jcr->store_bsock->signal(BNET_TERMINATE);
if (jcr->SD_msg_chan_started) {
pthread_cancel(jcr->SD_msg_chan);
}
}
break;
default:
term_msg = term_code;
sprintf(term_code, _("Inappropriate term code: %c\n"), jcr->JobStatus);
break;
}
generate_backup_summary(jcr, &cr, msg_type, term_msg);
Dmsg0(100, "Leave vbackup_cleanup()\n");
}
/*
* 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;
}
/*
* The first step in the restore process is for the user to
* select a list of JobIds from which he will subsequently
* select which files are to be restored.
*
* Returns: 2 if filename list made
* 1 if jobid list made
* 0 on error
*/
static int user_select_jobids_or_files(UAContext *ua, RESTORE_CTX *rx)
{
char *p;
char date[MAX_TIME_LENGTH];
bool have_date = false;
/* Include current second if using current time */
utime_t now = time(NULL) + 1;
JobId_t JobId;
JOB_DBR jr = { (JobId_t)-1 };
bool done = false;
int i, j;
const char *list[] = {
_("List last 20 Jobs run"),
_("List Jobs where a given File is saved"),
_("Enter list of comma separated JobIds to select"),
_("Enter SQL list command"),
_("Select the most recent backup for a client"),
_("Select backup for a client before a specified time"),
_("Enter a list of files to restore"),
_("Enter a list of files to restore before a specified time"),
_("Find the JobIds of the most recent backup for a client"),
_("Find the JobIds for a backup for a client before a specified time"),
_("Enter a list of directories to restore for found JobIds"),
_("Select full restore to a specified Job date"),
_("Cancel"),
NULL
};
const char *kw[] = {
/*
* These keywords are handled in a for loop
*/
"jobid", /* 0 */
"current", /* 1 */
"before", /* 2 */
"file", /* 3 */
"directory", /* 4 */
"select", /* 5 */
"pool", /* 6 */
"all", /* 7 */
/*
* The keyword below are handled by individual arg lookups
*/
"client", /* 8 */
"storage", /* 9 */
"fileset", /* 10 */
"where", /* 11 */
"yes", /* 12 */
"bootstrap", /* 13 */
"done", /* 14 */
"strip_prefix", /* 15 */
"add_prefix", /* 16 */
"add_suffix", /* 17 */
"regexwhere", /* 18 */
"restoreclient", /* 19 */
"copies", /* 20 */
"comment", /* 21 */
"restorejob", /* 22 */
"replace", /* 23 */
"pluginoptions", /* 24 */
NULL
};
rx->JobIds[0] = 0;
for (i = 1; i<ua->argc; i++) { /* loop through arguments */
bool found_kw = false;
for (j = 0; kw[j]; j++) { /* loop through keywords */
if (bstrcasecmp(kw[j], ua->argk[i])) {
found_kw = true;
break;
}
}
if (!found_kw) {
ua->error_msg(_("Unknown keyword: %s\n"), ua->argk[i]);
return 0;
}
/* Found keyword in kw[] list, process it */
switch (j) {
case 0: /* jobid */
if (!has_value(ua, i)) {
return 0;
}
if (*rx->JobIds != 0) {
pm_strcat(rx->JobIds, ",");
}
pm_strcat(rx->JobIds, ua->argv[i]);
done = true;
break;
case 1: /* current */
/*
* Note, we add one second here just to include any job
* that may have finished within the current second,
* which happens a lot in scripting small jobs.
*/
bstrutime(date, sizeof(date), now);
have_date = true;
break;
case 2: /* before */
if (have_date || !has_value(ua, i)) {
return 0;
}
if (str_to_utime(ua->argv[i]) == 0) {
ua->error_msg(_("Improper date format: %s\n"), ua->argv[i]);
return 0;
}
bstrncpy(date, ua->argv[i], sizeof(date));
have_date = true;
break;
case 3: /* file */
case 4: /* dir */
if (!has_value(ua, i)) {
return 0;
}
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
pm_strcpy(ua->cmd, ua->argv[i]);
insert_one_file_or_dir(ua, rx, date, j==4);
return 2;
case 5: /* select */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = true;
break;
case 6: /* pool specified */
if (!has_value(ua, i)) {
return 0;
}
rx->pool = (POOLRES *)GetResWithName(R_POOL, ua->argv[i]);
if (!rx->pool) {
ua->error_msg(_("Error: Pool resource \"%s\" does not exist.\n"), ua->argv[i]);
return 0;
}
if (!acl_access_ok(ua, Pool_ACL, ua->argv[i], true)) {
rx->pool = NULL;
ua->error_msg(_("Error: Pool resource \"%s\" access not allowed.\n"), ua->argv[i]);
return 0;
}
break;
case 7: /* all specified */
rx->all = true;
break;
default:
/*
* All keywords 7 or greater are ignored or handled by a select prompt
*/
break;
}
}
if (!done) {
ua->send_msg(_("\nFirst you select one or more JobIds that contain files\n"
"to be restored. You will be presented several methods\n"
"of specifying the JobIds. Then you will be allowed to\n"
"select which files from those JobIds are to be restored.\n\n"));
}
/* If choice not already made above, prompt */
for ( ; !done; ) {
char *fname;
int len;
bool gui_save;
db_list_ctx jobids;
start_prompt(ua, _("To select the JobIds, you have the following choices:\n"));
for (int i=0; list[i]; i++) {
add_prompt(ua, list[i]);
}
done = true;
switch (do_prompt(ua, "", _("Select item: "), NULL, 0)) {
case -1: /* error or cancel */
return 0;
case 0: /* list last 20 Jobs run */
if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), true)) {
ua->error_msg(_("SQL query not authorized.\n"));
return 0;
}
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, uar_list_jobs, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 1: /* list where a file is saved */
if (!get_client_name(ua, rx)) {
return 0;
}
if (!get_cmd(ua, _("Enter Filename (no path):"))) {
return 0;
}
len = strlen(ua->cmd);
fname = (char *)malloc(len * 2 + 1);
db_escape_string(ua->jcr, ua->db, fname, ua->cmd, len);
Mmsg(rx->query, uar_file[db_get_type_index(ua->db)], rx->ClientName, fname);
free(fname);
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, rx->query, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 2: /* enter a list of JobIds */
if (!get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
return 0;
}
pm_strcpy(rx->JobIds, ua->cmd);
break;
case 3: /* Enter an SQL list command */
if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), true)) {
ua->error_msg(_("SQL query not authorized.\n"));
return 0;
}
if (!get_cmd(ua, _("Enter SQL list command: "))) {
return 0;
}
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, ua->cmd, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 4: /* Select the most recent backups */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
break;
case 5: /* select backup at specified time */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
break;
case 6: /* Enter files */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
"containing a list of file names with paths, and terminate\n"
"them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter full filename: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
insert_one_file_or_dir(ua, rx, date, false);
}
return 2;
case 7: /* enter files backed up before specified time */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
"containing a list of file names with paths, and terminate\n"
"them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter full filename: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
insert_one_file_or_dir(ua, rx, date, false);
}
return 2;
case 8: /* Find JobIds for current backup */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = false;
break;
case 9: /* Find JobIds for give date */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = false;
break;
case 10: /* Enter directories */
if (*rx->JobIds != 0) {
ua->send_msg(_("You have already selected the following JobIds: %s\n"),
rx->JobIds);
} else if (get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
if (*rx->JobIds != 0 && *ua->cmd) {
pm_strcat(rx->JobIds, ",");
}
pm_strcat(rx->JobIds, ua->cmd);
}
if (*rx->JobIds == 0 || *rx->JobIds == '.') {
*rx->JobIds = 0;
return 0; /* nothing entered, return */
}
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter full directory names or start the name\n"
"with a < to indicate it is a filename containing a list\n"
"of directories and terminate them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter directory name: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
/* Add trailing slash to end of directory names */
if (ua->cmd[0] != '<' && !IsPathSeparator(ua->cmd[len-1])) {
strcat(ua->cmd, "/");
}
insert_one_file_or_dir(ua, rx, date, true);
}
return 2;
case 11: /* Choose a jobid and select jobs */
if (!get_cmd(ua, _("Enter JobId to get the state to restore: ")) ||
!is_an_integer(ua->cmd))
{
return 0;
}
memset(&jr, 0, sizeof(jr));
jr.JobId = str_to_int64(ua->cmd);
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
ua->cmd, db_strerror(ua->db));
return 0;
}
ua->send_msg(_("Selecting jobs to build the Full state at %s\n"),
jr.cStartTime);
jr.JobLevel = L_INCREMENTAL; /* Take Full+Diff+Incr */
if (!db_accurate_get_jobids(ua->jcr, ua->db, &jr, &jobids)) {
return 0;
}
pm_strcpy(rx->JobIds, jobids.list);
Dmsg1(30, "Item 12: jobids = %s\n", rx->JobIds);
break;
case 12: /* Cancel or quit */
return 0;
}
}
memset(&jr, 0, sizeof(jr));
POOLMEM *JobIds = get_pool_memory(PM_FNAME);
*JobIds = 0;
rx->TotalFiles = 0;
/*
* Find total number of files to be restored, and filter the JobId
* list to contain only ones permitted by the ACL conditions.
*/
for (p=rx->JobIds; ; ) {
char ed1[50];
int status = get_next_jobid_from_list(&p, &JobId);
if (status < 0) {
ua->error_msg(_("Invalid JobId in list.\n"));
free_pool_memory(JobIds);
return 0;
}
if (status == 0) {
break;
}
if (jr.JobId == JobId) {
continue; /* duplicate of last JobId */
}
memset(&jr, 0, sizeof(jr));
jr.JobId = JobId;
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
edit_int64(JobId, ed1), db_strerror(ua->db));
free_pool_memory(JobIds);
return 0;
}
if (!acl_access_ok(ua, Job_ACL, jr.Name, true)) {
ua->error_msg(_("Access to JobId=%s (Job \"%s\") not authorized. Not selected.\n"),
edit_int64(JobId, ed1), jr.Name);
continue;
}
if (*JobIds != 0) {
pm_strcat(JobIds, ",");
}
pm_strcat(JobIds, edit_int64(JobId, ed1));
rx->TotalFiles += jr.JobFiles;
}
free_pool_memory(rx->JobIds);
rx->JobIds = JobIds; /* Set ACL filtered list */
if (*rx->JobIds == 0) {
ua->warning_msg(_("No Jobs selected.\n"));
return 0;
}
if (strchr(rx->JobIds,',')) {
ua->info_msg(_("You have selected the following JobIds: %s\n"), rx->JobIds);
} else {
ua->info_msg(_("You have selected the following JobId: %s\n"), rx->JobIds);
}
return true;
}
/*
* Update a Job record -- allows you to change the
* date fields in a Job record. This helps when
* providing migration from other vendors.
*/
static bool update_job(UAContext *ua)
{
int i;
char ed1[50], ed2[50];
POOL_MEM cmd(PM_MESSAGE);
JOB_DBR jr;
CLIENT_DBR cr;
utime_t StartTime;
char *client_name = NULL;
char *start_time = NULL;
const char *kw[] = {
NT_("starttime"), /* 0 */
NT_("client"), /* 1 */
NULL };
Dmsg1(200, "cmd=%s\n", ua->cmd);
i = find_arg_with_value(ua, NT_("jobid"));
if (i < 0) {
ua->error_msg(_("Expect JobId keyword, not found.\n"));
return false;
}
memset(&jr, 0, sizeof(jr));
memset(&cr, 0, sizeof(cr));
jr.JobId = str_to_int64(ua->argv[i]);
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg("%s", db_strerror(ua->db));
return false;
}
for (i=0; kw[i]; i++) {
int j;
if ((j=find_arg_with_value(ua, kw[i])) >= 0) {
switch (i) {
case 0: /* start time */
start_time = ua->argv[j];
break;
case 1: /* Client name */
client_name = ua->argv[j];
break;
}
}
}
if (!client_name && !start_time) {
ua->error_msg(_("Neither Client nor StartTime specified.\n"));
return 0;
}
if (client_name) {
if (!get_client_dbr(ua, &cr)) {
return false;
}
jr.ClientId = cr.ClientId;
}
if (start_time) {
utime_t delta_start;
StartTime = str_to_utime(start_time);
if (StartTime == 0) {
ua->error_msg(_("Improper date format: %s\n"), ua->argv[i]);
return false;
}
delta_start = StartTime - jr.StartTime;
Dmsg3(200, "ST=%lld jr.ST=%lld delta=%lld\n", StartTime,
(utime_t)jr.StartTime, delta_start);
jr.StartTime = (time_t)StartTime;
jr.SchedTime += (time_t)delta_start;
jr.EndTime += (time_t)delta_start;
jr.JobTDate += delta_start;
/* Convert to DB times */
bstrutime(jr.cStartTime, sizeof(jr.cStartTime), jr.StartTime);
bstrutime(jr.cSchedTime, sizeof(jr.cSchedTime), jr.SchedTime);
bstrutime(jr.cEndTime, sizeof(jr.cEndTime), jr.EndTime);
}
Mmsg(cmd, "UPDATE Job SET ClientId=%s,StartTime='%s',SchedTime='%s',"
"EndTime='%s',JobTDate=%s WHERE JobId=%s",
edit_int64(jr.ClientId, ed1),
jr.cStartTime,
jr.cSchedTime,
jr.cEndTime,
edit_uint64(jr.JobTDate, ed1),
edit_int64(jr.JobId, ed2));
if (!db_sql_query(ua->db, cmd.c_str(), NULL, NULL)) {
ua->error_msg("%s", db_strerror(ua->db));
return false;
}
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;
}
/*
* .bvfs_get_jobids jobid=1
* -> returns needed jobids to restore
* .bvfs_get_jobids jobid=1 all
* -> returns needed jobids to restore with all filesets a JobId=1 time
* .bvfs_get_jobids ujobid=JobName
* -> returns needed jobids to restore
*/
bool dot_bvfs_get_jobids_cmd(UAContext *ua, const char *cmd)
{
JOB_DBR jr;
db_list_ctx jobids, tempids;
int pos;
char ed1[50];
POOL_MEM query;
dbid_list ids; /* Store all FileSetIds for this client */
if (!open_client_db(ua, true)) {
return true;
}
memset(&jr, 0, sizeof(jr));
if ((pos = find_arg_with_value(ua, "ujobid")) >= 0) {
bstrncpy(jr.Job, ua->argv[pos], sizeof(jr.Job));
} else if ((pos = find_arg_with_value(ua, "jobid")) >= 0) {
jr.JobId = str_to_int64(ua->argv[pos]);
} else {
ua->error_msg(_("Can't find ujobid or jobid argument\n"));
return false;
}
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
ua->argv[pos], db_strerror(ua->db));
return false;
}
/*
* When in level base, we don't rely on any Full/Incr/Diff
*/
if (jr.JobLevel == L_BASE) {
jobids.add(edit_int64(jr.JobId, ed1));
} else {
/*
* If we have the "all" option, we do a search on all defined fileset for this client
*/
if (find_arg(ua, "all") > 0) {
edit_int64(jr.ClientId, ed1);
Mmsg(query, uar_sel_filesetid, ed1);
db_get_query_dbids(ua->jcr, ua->db, query, ids);
} else {
ids.num_ids = 1;
ids.DBId[0] = jr.FileSetId;
}
jr.JobLevel = L_INCREMENTAL; /* Take Full+Diff+Incr */
/*
* Foreach different FileSet, we build a restore jobid list
*/
for (int i = 0; i < ids.num_ids; i++) {
jr.FileSetId = ids.DBId[i];
if (!db_accurate_get_jobids(ua->jcr, ua->db, &jr, &tempids)) {
return true;
}
jobids.add(tempids);
}
}
switch (ua->api) {
case API_MODE_JSON: {
char *cur_id, *bp;
ua->send->array_start("jobids");
cur_id = jobids.list;
while (cur_id && strlen(cur_id)) {
bp = strchr(cur_id, ',');
if (bp) {
*bp++ = '\0';
}
ua->send->object_start();
ua->send->object_key_value("id", cur_id, "%s\n");
ua->send->object_end();
cur_id = bp;
}
ua->send->array_end("jobids");
break;
}
default:
ua->send_msg("%s\n", jobids.list);
break;
}
return true;
}
/*
*
* This is the central piece of code that finds a job or jobs
* actually JobIds to migrate. It first looks to see if one
* has been "manually" specified in jcr->MigrateJobId, and if
* so, it returns that JobId to be run. Otherwise, it
* examines the Selection Type to see what kind of migration
* we are doing (Volume, Job, Client, ...) and applies any
* Selection Pattern if appropriate to obtain a list of JobIds.
* Finally, it will loop over all the JobIds found, except the last
* one starting a new job with MigrationJobId set to that JobId, and
* finally, it returns the last JobId to the caller.
*
* Returns: -1 on error
* 0 if no jobs to migrate
* 1 if OK and jcr->previous_jr filled in
*/
int getJob_to_migrate(JCR *jcr)
{
char ed1[30], ed2[30];
POOL_MEM query(PM_MESSAGE);
JobId_t JobId;
DBId_t DBId = 0;
int stat;
char *p;
idpkt ids, mid, jids;
db_int64_ctx ctx;
int64_t pool_bytes;
time_t ttime;
struct tm tm;
char dt[MAX_TIME_LENGTH];
int count = 0;
int limit = jcr->job->MaxSpawnedJobs; /* limit is max jobs to start */
ids.list = get_pool_memory(PM_MESSAGE);
ids.list[0] = 0;
ids.count = 0;
mid.list = get_pool_memory(PM_MESSAGE);
mid.list[0] = 0;
mid.count = 0;
jids.list = get_pool_memory(PM_MESSAGE);
jids.list[0] = 0;
jids.count = 0;
/*
* If MigrateJobId is set, then we migrate only that Job,
* otherwise, we go through the full selection of jobs to
* migrate.
*/
if (jcr->MigrateJobId != 0) {
Dmsg1(dbglevel, "At Job start previous jobid=%u\n", jcr->MigrateJobId);
JobId = jcr->MigrateJobId;
} else {
switch (jcr->job->selection_type) {
case MT_JOB:
if (!regex_find_jobids(jcr, &ids, sql_job, sql_jobids_from_job, "Job")) {
goto bail_out;
}
break;
case MT_CLIENT:
if (!regex_find_jobids(jcr, &ids, sql_client, sql_jobids_from_client, "Client")) {
goto bail_out;
}
break;
case MT_VOLUME:
if (!regex_find_jobids(jcr, &ids, sql_vol, sql_jobids_from_vol, "Volume")) {
goto bail_out;
}
break;
case MT_SQLQUERY:
if (!jcr->job->selection_pattern) {
Jmsg(jcr, M_FATAL, 0, _("No %s SQL selection pattern specified.\n"), jcr->get_OperationName());
goto bail_out;
}
Dmsg1(dbglevel, "SQL=%s\n", jcr->job->selection_pattern);
if (!db_sql_query(jcr->db, jcr->job->selection_pattern,
unique_dbid_handler, (void *)&ids)) {
Jmsg(jcr, M_FATAL, 0,
_("SQL failed. ERR=%s\n"), db_strerror(jcr->db));
goto bail_out;
}
break;
case MT_SMALLEST_VOL:
if (!find_mediaid_then_jobids(jcr, &ids, sql_smallest_vol, "Smallest Volume")) {
goto bail_out;
}
break;
case MT_OLDEST_VOL:
if (!find_mediaid_then_jobids(jcr, &ids, sql_oldest_vol, "Oldest Volume")) {
goto bail_out;
}
break;
case MT_POOL_OCCUPANCY:
ctx.count = 0;
/* Find count of bytes in pool */
Mmsg(query, sql_pool_bytes, jcr->rpool->name());
if (!db_sql_query(jcr->db, query.c_str(), db_int64_handler, (void *)&ctx)) {
Jmsg(jcr, M_FATAL, 0, _("SQL failed. ERR=%s\n"), db_strerror(jcr->db));
goto bail_out;
}
if (ctx.count == 0) {
Jmsg(jcr, M_INFO, 0, _("No Volumes found to %s.\n"), jcr->get_ActionName(0));
goto ok_out;
}
pool_bytes = ctx.value;
Dmsg2(dbglevel, "highbytes=%lld pool=%lld\n", jcr->rpool->MigrationHighBytes,
pool_bytes);
if (pool_bytes < (int64_t)jcr->rpool->MigrationHighBytes) {
Jmsg(jcr, M_INFO, 0, _("No Volumes found to %s.\n"), jcr->get_ActionName(0));
goto ok_out;
}
Dmsg0(dbglevel, "We should do Occupation migration.\n");
ids.count = 0;
/* Find a list of MediaIds that could be migrated */
Mmsg(query, sql_mediaids, jcr->rpool->name());
Dmsg1(dbglevel, "query=%s\n", query.c_str());
if (!db_sql_query(jcr->db, query.c_str(), unique_dbid_handler, (void *)&ids)) {
Jmsg(jcr, M_FATAL, 0, _("SQL failed. ERR=%s\n"), db_strerror(jcr->db));
goto bail_out;
}
if (ids.count == 0) {
Jmsg(jcr, M_INFO, 0, _("No Volumes found to %s.\n"), jcr->get_ActionName(0));
goto ok_out;
}
Dmsg2(dbglevel, "Pool Occupancy ids=%d MediaIds=%s\n", ids.count, ids.list);
if (!find_jobids_from_mediaid_list(jcr, &ids, "Volume")) {
goto bail_out;
}
/* ids == list of jobs */
p = ids.list;
for (int i=0; i < (int)ids.count; i++) {
stat = get_next_dbid_from_list(&p, &DBId);
Dmsg2(dbglevel, "get_next_dbid stat=%d JobId=%u\n", stat, (uint32_t)DBId);
if (stat < 0) {
Jmsg(jcr, M_FATAL, 0, _("Invalid JobId found.\n"));
goto bail_out;
} else if (stat == 0) {
break;
}
mid.count = 1;
Mmsg(mid.list, "%s", edit_int64(DBId, ed1));
if (jids.count > 0) {
pm_strcat(jids.list, ",");
}
pm_strcat(jids.list, mid.list);
jids.count += mid.count;
/* Find count of bytes from Jobs */
Mmsg(query, sql_job_bytes, mid.list);
Dmsg1(dbglevel, "Jobbytes query: %s\n", query.c_str());
if (!db_sql_query(jcr->db, query.c_str(), db_int64_handler, (void *)&ctx)) {
Jmsg(jcr, M_FATAL, 0, _("SQL failed. ERR=%s\n"), db_strerror(jcr->db));
goto bail_out;
}
pool_bytes -= ctx.value;
Dmsg2(dbglevel, "Total %s Job bytes=%s\n", jcr->get_ActionName(0), edit_int64_with_commas(ctx.value, ed1));
Dmsg2(dbglevel, "lowbytes=%s poolafter=%s\n",
edit_int64_with_commas(jcr->rpool->MigrationLowBytes, ed1),
edit_int64_with_commas(pool_bytes, ed2));
if (pool_bytes <= (int64_t)jcr->rpool->MigrationLowBytes) {
Dmsg0(dbglevel, "We should be done.\n");
break;
}
}
/* Transfer jids to ids, where the jobs list is expected */
ids.count = jids.count;
pm_strcpy(ids.list, jids.list);
Dmsg2(dbglevel, "Pool Occupancy ids=%d JobIds=%s\n", ids.count, ids.list);
break;
case MT_POOL_TIME:
ttime = time(NULL) - (time_t)jcr->rpool->MigrationTime;
(void)localtime_r(&ttime, &tm);
strftime(dt, sizeof(dt), "%Y-%m-%d %H:%M:%S", &tm);
ids.count = 0;
Mmsg(query, sql_pool_time, jcr->rpool->name(), dt);
Dmsg1(dbglevel, "query=%s\n", query.c_str());
if (!db_sql_query(jcr->db, query.c_str(), unique_dbid_handler, (void *)&ids)) {
Jmsg(jcr, M_FATAL, 0, _("SQL failed. ERR=%s\n"), db_strerror(jcr->db));
goto bail_out;
}
if (ids.count == 0) {
Jmsg(jcr, M_INFO, 0, _("No Volumes found to %s.\n"), jcr->get_ActionName(0));
goto ok_out;
}
Dmsg2(dbglevel, "PoolTime ids=%d JobIds=%s\n", ids.count, ids.list);
break;
case MT_POOL_UNCOPIED_JOBS:
if (!find_jobids_of_pool_uncopied_jobs(jcr, &ids)) {
goto bail_out;
}
break;
default:
Jmsg(jcr, M_FATAL, 0, _("Unknown %s Selection Type.\n"), jcr->get_OperationName());
goto bail_out;
}
/*
* Loop over all jobids except the last one, sending
* them to start_mac_job(), which will start a job
* for each of them. For the last JobId, we handle it below.
*/
p = ids.list;
if (ids.count == 0) {
Jmsg(jcr, M_INFO, 0, _("No JobIds found to %s.\n"), jcr->get_ActionName(0));
goto ok_out;
}
Jmsg(jcr, M_INFO, 0, _("The following %u JobId%s chosen to be %s: %s\n"),
ids.count, (ids.count < 2) ? _(" was") : _("s were"),
jcr->get_ActionName(1), ids.list);
Dmsg2(dbglevel, "Before loop count=%d ids=%s\n", ids.count, ids.list);
/*
* Note: to not over load the system, limit the number
* of new jobs started to 100 (see limit above)
*/
for (int i=1; i < (int)ids.count; i++) {
JobId = 0;
stat = get_next_jobid_from_list(&p, &JobId);
Dmsg3(dbglevel, "getJobid_no=%d stat=%d JobId=%u\n", i, stat, JobId);
if (stat < 0) {
Jmsg(jcr, M_FATAL, 0, _("Invalid JobId found.\n"));
goto bail_out;
} else if (stat == 0) {
Jmsg(jcr, M_INFO, 0, _("No JobIds found to %s.\n"), jcr->get_ActionName(0));
goto ok_out;
}
jcr->MigrateJobId = JobId;
/* Don't start any more when limit reaches zero */
limit--;
if (limit > 0) {
start_mac_job(jcr);
Dmsg0(dbglevel, "Back from start_mac_job\n");
}
}
/* Now get the last JobId and handle it in the current job */
JobId = 0;
stat = get_next_jobid_from_list(&p, &JobId);
Dmsg2(dbglevel, "Last get_next_jobid stat=%d JobId=%u\n", stat, (int)JobId);
if (stat < 0) {
Jmsg(jcr, M_FATAL, 0, _("Invalid JobId found.\n"));
goto bail_out;
} else if (stat == 0) {
Jmsg(jcr, M_INFO, 0, _("No JobIds found to %s.\n"), jcr->get_ActionName(0));
goto ok_out;
}
}
jcr->previous_jr.JobId = JobId;
Dmsg1(dbglevel, "Previous jobid=%d\n", (int)jcr->previous_jr.JobId);
if (!db_get_job_record(jcr, jcr->db, &jcr->previous_jr)) {
Jmsg(jcr, M_FATAL, 0, _("Could not get job record for JobId %s to %s. ERR=%s"),
edit_int64(jcr->previous_jr.JobId, ed1),
jcr->get_ActionName(0),
db_strerror(jcr->db));
goto bail_out;
}
Jmsg(jcr, M_INFO, 0, _("%s using JobId=%s Job=%s\n"),
jcr->get_OperationName(),
edit_int64(jcr->previous_jr.JobId, ed1), jcr->previous_jr.Job);
Dmsg4(dbglevel, "%s JobId=%d using JobId=%s Job=%s\n",
jcr->get_OperationName(),
jcr->JobId,
edit_int64(jcr->previous_jr.JobId, ed1), jcr->previous_jr.Job);
count = 1;
ok_out:
goto out;
bail_out:
count = -1;
out:
free_pool_memory(ids.list);
free_pool_memory(mid.list);
free_pool_memory(jids.list);
return count;
}
static int do_list_cmd(UAContext *ua, const char *cmd, e_list_type llist)
{
POOLMEM *VolumeName;
int jobid, n;
int i, j;
JOB_DBR jr;
POOL_DBR pr;
MEDIA_DBR mr;
if (!open_client_db(ua))
return 1;
memset(&jr, 0, sizeof(jr));
memset(&pr, 0, sizeof(pr));
Dmsg1(20, "list: %s\n", cmd);
if (!ua->db) {
ua->error_msg(_("Hey! DB is NULL\n"));
}
/* Apply any limit */
j = find_arg_with_value(ua, NT_("limit"));
if (j >= 0) {
jr.limit = atoi(ua->argv[j]);
}
/* Scan arguments looking for things to do */
for (i=1; i<ua->argc; i++) {
/* List JOBS */
if (bstrcasecmp(ua->argk[i], NT_("jobs"))) {
db_list_job_records(ua->jcr, ua->db, &jr, prtit, ua, llist);
/* List JOBTOTALS */
} else if (bstrcasecmp(ua->argk[i], NT_("jobtotals"))) {
db_list_job_totals(ua->jcr, ua->db, &jr, prtit, ua);
/* List JOBID=nn */
} else if (bstrcasecmp(ua->argk[i], NT_("jobid"))) {
if (ua->argv[i]) {
jobid = str_to_int64(ua->argv[i]);
if (jobid > 0) {
jr.JobId = jobid;
db_list_job_records(ua->jcr, ua->db, &jr, prtit, ua, llist);
}
}
/* List JOB=xxx */
} else if ((bstrcasecmp(ua->argk[i], NT_("job")) ||
bstrcasecmp(ua->argk[i], NT_("jobname"))) && ua->argv[i]) {
bstrncpy(jr.Name, ua->argv[i], MAX_NAME_LENGTH);
jr.JobId = 0;
db_list_job_records(ua->jcr, ua->db, &jr, prtit, ua, llist);
/* List UJOBID=xxx */
} else if (bstrcasecmp(ua->argk[i], NT_("ujobid")) && ua->argv[i]) {
bstrncpy(jr.Job, ua->argv[i], MAX_NAME_LENGTH);
jr.JobId = 0;
db_list_job_records(ua->jcr, ua->db, &jr, prtit, ua, llist);
/* List Base files */
} else if (bstrcasecmp(ua->argk[i], NT_("basefiles"))) {
/* TODO: cleanup this block */
for (j=i+1; j<ua->argc; j++) {
if (bstrcasecmp(ua->argk[j], NT_("ujobid")) && ua->argv[j]) {
bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
jr.JobId = 0;
db_get_job_record(ua->jcr, ua->db, &jr);
jobid = jr.JobId;
} else if (bstrcasecmp(ua->argk[j], NT_("jobid")) && ua->argv[j]) {
jobid = str_to_int64(ua->argv[j]);
} else {
continue;
}
if (jobid > 0) {
db_list_base_files_for_job(ua->jcr, ua->db, jobid, prtit, ua);
}
}
/* List FILES */
} else if (bstrcasecmp(ua->argk[i], NT_("files"))) {
for (j=i+1; j<ua->argc; j++) {
if (bstrcasecmp(ua->argk[j], NT_("ujobid")) && ua->argv[j]) {
bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
jr.JobId = 0;
db_get_job_record(ua->jcr, ua->db, &jr);
jobid = jr.JobId;
} else if (bstrcasecmp(ua->argk[j], NT_("jobid")) && ua->argv[j]) {
jobid = str_to_int64(ua->argv[j]);
} else {
continue;
}
if (jobid > 0) {
db_list_files_for_job(ua->jcr, ua->db, jobid, prtit, ua);
}
}
/* List JOBMEDIA */
} else if (bstrcasecmp(ua->argk[i], NT_("jobmedia"))) {
bool done = false;
for (j=i+1; j<ua->argc; j++) {
if (bstrcasecmp(ua->argk[j], NT_("ujobid")) && ua->argv[j]) {
bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
jr.JobId = 0;
db_get_job_record(ua->jcr, ua->db, &jr);
jobid = jr.JobId;
} else if (bstrcasecmp(ua->argk[j], NT_("jobid")) && ua->argv[j]) {
jobid = str_to_int64(ua->argv[j]);
} else {
continue;
}
db_list_jobmedia_records(ua->jcr, ua->db, jobid, prtit, ua, llist);
done = true;
}
if (!done) {
/* List for all jobs (jobid=0) */
db_list_jobmedia_records(ua->jcr, ua->db, 0, prtit, ua, llist);
}
/* List JOBLOG */
} else if (bstrcasecmp(ua->argk[i], NT_("joblog"))) {
bool done = false;
for (j=i+1; j<ua->argc; j++) {
if (bstrcasecmp(ua->argk[j], NT_("ujobid")) && ua->argv[j]) {
bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
jr.JobId = 0;
db_get_job_record(ua->jcr, ua->db, &jr);
jobid = jr.JobId;
} else if (bstrcasecmp(ua->argk[j], NT_("jobid")) && ua->argv[j]) {
jobid = str_to_int64(ua->argv[j]);
} else {
continue;
}
db_list_joblog_records(ua->jcr, ua->db, jobid, prtit, ua, llist);
done = true;
}
if (!done) {
/* List for all jobs (jobid=0) */
db_list_joblog_records(ua->jcr, ua->db, 0, prtit, ua, llist);
}
/* List POOLS */
} else if (bstrcasecmp(ua->argk[i], NT_("pool")) ||
bstrcasecmp(ua->argk[i], NT_("pools"))) {
POOL_DBR pr;
memset(&pr, 0, sizeof(pr));
if (ua->argv[i]) {
bstrncpy(pr.Name, ua->argv[i], sizeof(pr.Name));
}
db_list_pool_records(ua->jcr, ua->db, &pr, prtit, ua, llist);
} else if (bstrcasecmp(ua->argk[i], NT_("clients"))) {
db_list_client_records(ua->jcr, ua->db, prtit, ua, llist);
/* List MEDIA or VOLUMES */
} else if (bstrcasecmp(ua->argk[i], NT_("media")) ||
bstrcasecmp(ua->argk[i], NT_("volume")) ||
bstrcasecmp(ua->argk[i], NT_("volumes"))) {
bool done = false;
for (j=i+1; j<ua->argc; j++) {
if (bstrcasecmp(ua->argk[j], NT_("ujobid")) && ua->argv[j]) {
bstrncpy(jr.Job, ua->argv[j], MAX_NAME_LENGTH);
jr.JobId = 0;
db_get_job_record(ua->jcr, ua->db, &jr);
jobid = jr.JobId;
} else if (bstrcasecmp(ua->argk[j], NT_("jobid")) && ua->argv[j]) {
jobid = str_to_int64(ua->argv[j]);
} else {
continue;
}
VolumeName = get_pool_memory(PM_FNAME);
n = db_get_job_volume_names(ua->jcr, ua->db, jobid, &VolumeName);
ua->send_msg(_("Jobid %d used %d Volume(s): %s\n"), jobid, n, VolumeName);
free_pool_memory(VolumeName);
done = true;
}
/* if no job or jobid keyword found, then we list all media */
if (!done) {
int num_pools;
uint32_t *ids;
/* List a specific volume? */
if (ua->argv[i]) {
bstrncpy(mr.VolumeName, ua->argv[i], sizeof(mr.VolumeName));
db_list_media_records(ua->jcr, ua->db, &mr, prtit, ua, llist);
return 1;
}
/* Is a specific pool wanted? */
for (i=1; i<ua->argc; i++) {
if (bstrcasecmp(ua->argk[i], NT_("pool"))) {
if (!get_pool_dbr(ua, &pr)) {
ua->error_msg(_("No Pool specified.\n"));
return 1;
}
mr.PoolId = pr.PoolId;
db_list_media_records(ua->jcr, ua->db, &mr, prtit, ua, llist);
return 1;
}
}
/* List Volumes in all pools */
if (!db_get_pool_ids(ua->jcr, ua->db, &num_pools, &ids)) {
ua->error_msg(_("Error obtaining pool ids. ERR=%s\n"),
db_strerror(ua->db));
return 1;
}
if (num_pools <= 0) {
return 1;
}
for (i=0; i < num_pools; i++) {
pr.PoolId = ids[i];
if (db_get_pool_record(ua->jcr, ua->db, &pr)) {
ua->send_msg(_("Pool: %s\n"), pr.Name);
}
mr.PoolId = ids[i];
db_list_media_records(ua->jcr, ua->db, &mr, prtit, ua, llist);
}
free(ids);
return 1;
}
/* List next volume */
} else if (bstrcasecmp(ua->argk[i], NT_("nextvol")) ||
bstrcasecmp(ua->argk[i], NT_("nextvolume"))) {
n = 1;
j = find_arg_with_value(ua, NT_("days"));
if (j >= 0) {
n = atoi(ua->argv[j]);
if ((n < 0) || (n > 50)) {
ua->warning_msg(_("Ignoring invalid value for days. Max is 50.\n"));
n = 1;
}
}
list_nextvol(ua, n);
} else if (bstrcasecmp(ua->argk[i], NT_("copies"))) {
char *jobids = NULL;
uint32_t limit=0;
for (j=i+1; j<ua->argc; j++) {
if (bstrcasecmp(ua->argk[j], NT_("jobid")) && ua->argv[j]) {
if (is_a_number_list(ua->argv[j])) {
jobids = ua->argv[j];
}
} else if (bstrcasecmp(ua->argk[j], NT_("limit")) && ua->argv[j]) {
limit = atoi(ua->argv[j]);
}
}
db_list_copies_records(ua->jcr,ua->db,limit,jobids,prtit,ua,llist);
} else if (bstrcasecmp(ua->argk[i], NT_("limit"))
|| bstrcasecmp(ua->argk[i], NT_("days"))) {
/* Ignore it */
} else {
ua->error_msg(_("Unknown list keyword: %s\n"), NPRT(ua->argk[i]));
}
}
return 1;
}
/*
* 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;
}
/*
* .bvfs_get_jobids jobid=1
* -> returns needed jobids to restore
* .bvfs_get_jobids jobid=1 all
* -> returns needed jobids to restore with all filesets a JobId=1 time
* .bvfs_get_jobids ujobid=JobName
* -> returns needed jobids to restore
*/
static bool dot_bvfs_get_jobids(UAContext *ua, const char *cmd)
{
JOB_DBR jr;
db_list_ctx jobids, tempids;
int pos;
char ed1[50];
POOL_MEM query;
dbid_list ids; /* Store all FileSetIds for this client */
if (!open_client_db(ua, true)) {
return true;
}
memset(&jr, 0, sizeof(jr));
if ((pos = find_arg_with_value(ua, "ujobid")) >= 0) {
bstrncpy(jr.Job, ua->argv[pos], sizeof(jr.Job));
}
if ((pos = find_arg_with_value(ua, "jobid")) >= 0) {
jr.JobId = str_to_int64(ua->argv[pos]);
}
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
ua->cmd, db_strerror(ua->db));
return true;
}
/* When in level base, we don't rely on any Full/Incr/Diff */
if (jr.JobLevel == L_BASE) {
ua->send_msg("%s\n", edit_int64(jr.JobId, ed1));
return true;
}
/* If we have the "all" option, we do a search on all defined fileset
* for this client
*/
if (find_arg(ua, "all") > 0) {
edit_int64(jr.ClientId, ed1);
Mmsg(query, uar_sel_filesetid, ed1);
db_get_query_dbids(ua->jcr, ua->db, query, ids);
} else {
ids.num_ids = 1;
ids.DBId[0] = jr.FileSetId;
}
jr.JobLevel = L_INCREMENTAL; /* Take Full+Diff+Incr */
/* Foreach different FileSet, we build a restore jobid list */
for (int i=0; i < ids.num_ids; i++) {
jr.FileSetId = ids.DBId[i];
if (!db_accurate_get_jobids(ua->jcr, ua->db, &jr, &tempids)) {
return true;
}
jobids.add(tempids);
}
ua->send_msg("%s\n", jobids.list);
return true;
}
/*
* Release resources allocated during backup.
*/
void backup_cleanup(JCR *jcr, int TermCode)
{
char sdt[50], edt[50], schedt[50];
char ec1[30], ec2[30], ec3[30], ec4[30], ec5[30], compress[50];
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 = 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);
memset(&mr, 0, sizeof(mr));
memset(&cr, 0, sizeof(cr));
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 Job report: ERR=%s"),
db_strerror(jcr->db));
set_jcr_job_status(jcr, JS_ErrorTerminated);
}
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 Job report: ERR=%s"),
db_strerror(jcr->db));
}
bstrncpy(mr.VolumeName, jcr->VolumeName, sizeof(mr.VolumeName));
if (!db_get_media_record(jcr, jcr->db, &mr)) {
Jmsg(jcr, M_WARNING, 0, _("Error getting Media record for Volume \"%s\": ERR=%s"),
mr.VolumeName, db_strerror(jcr->db));
set_jcr_job_status(jcr, JS_ErrorTerminated);
}
update_bootstrap_file(jcr);
switch (jcr->JobStatus) {
case JS_Terminated:
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) {
jcr->store_bsock->signal(BNET_TERMINATE);
if (jcr->SD_msg_chan) {
pthread_cancel(jcr->SD_msg_chan);
}
}
break;
case JS_Canceled:
term_msg = _("Backup Canceled");
if (jcr->store_bsock) {
jcr->store_bsock->signal(BNET_TERMINATE);
if (jcr->SD_msg_chan) {
pthread_cancel(jcr->SD_msg_chan);
}
}
break;
default:
term_msg = term_code;
sprintf(term_code, _("Inappropriate term code: %c\n"), jcr->JobStatus);
break;
}
bstrftimes(schedt, sizeof(schedt), jcr->jr.SchedTime);
bstrftimes(sdt, sizeof(sdt), jcr->jr.StartTime);
bstrftimes(edt, sizeof(edt), jcr->jr.EndTime);
RunTime = jcr->jr.EndTime - jcr->jr.StartTime;
if (RunTime <= 0) {
kbps = 0;
} else {
kbps = ((double)jcr->jr.JobBytes) / (1000.0 * (double)RunTime);
}
if (!db_get_job_volume_names(jcr, jcr->db, jcr->jr.JobId, &jcr->VolumeName)) {
/*
* Note, if the job has erred, most likely it did not write any
* tape, so suppress this "error" message since in that case
* it is normal. Or look at it the other way, only for a
* normal exit should we complain about this error.
*/
if (jcr->JobStatus == JS_Terminated && jcr->jr.JobBytes) {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
}
jcr->VolumeName[0] = 0; /* none */
}
if (jcr->ReadBytes == 0) {
bstrncpy(compress, "None", sizeof(compress));
} else {
compression = (double)100 - 100.0 * ((double)jcr->JobBytes / (double)jcr->ReadBytes);
if (compression < 0.5) {
bstrncpy(compress, "None", sizeof(compress));
} else {
bsnprintf(compress, sizeof(compress), "%.1f %%", compression);
}
}
jobstatus_to_ascii(jcr->FDJobStatus, fd_term_msg, sizeof(fd_term_msg));
jobstatus_to_ascii(jcr->SDJobStatus, sd_term_msg, sizeof(sd_term_msg));
// bmicrosleep(15, 0); /* for debugging SIGHUP */
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\" (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"
" Elapsed time: %s\n"
" Priority: %d\n"
" FD Files Written: %s\n"
" SD Files Written: %s\n"
" FD Bytes Written: %s (%sB)\n"
" 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"
" Last Volume Bytes: %s (%sB)\n"
" Non-fatal FD errors: %d\n"
" SD Errors: %d\n"
" FD termination status: %s\n"
" SD termination status: %s\n"
" Termination: %s\n\n"),
BACULA, my_name, VERSION, LSMDATE, edt,
HOST_OS, DISTNAME, DISTVER,
jcr->jr.JobId,
jcr->jr.Job,
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,
edit_utime(RunTime, elapsed, sizeof(elapsed)),
jcr->JobPriority,
edit_uint64_with_commas(jcr->jr.JobFiles, ec1),
edit_uint64_with_commas(jcr->SDJobFiles, ec2),
edit_uint64_with_commas(jcr->jr.JobBytes, ec3),
edit_uint64_with_suffix(jcr->jr.JobBytes, ec4),
edit_uint64_with_commas(jcr->SDJobBytes, ec5),
edit_uint64_with_suffix(jcr->SDJobBytes, ec6),
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->JobErrors,
jcr->SDErrors,
fd_term_msg,
sd_term_msg,
term_msg);
Dmsg0(100, "Leave backup_cleanup()\n");
}
