/*
* Send current file list to FD
* DIR -> FD : accurate files=xxxx
* DIR -> FD : /path/to/file\0Lstat
* DIR -> FD : /path/to/dir/\0Lstat
* ...
* DIR -> FD : EOD
*/
bool send_accurate_current_files(JCR *jcr)
{
POOL_MEM buf;
if (!jcr->accurate || job_canceled(jcr) || jcr->get_JobLevel()==L_FULL) {
return true;
}
POOLMEM *jobids = get_pool_memory(PM_FNAME);
db_accurate_get_jobids(jcr, jcr->db, &jcr->jr, jobids);
if (*jobids == 0) {
free_pool_memory(jobids);
Jmsg(jcr, M_FATAL, 0, _("Cannot find previous jobids.\n"));
return false;
}
Jmsg(jcr, M_INFO, 0, _("Sending Accurate information.\n"));
/* to be able to allocate the right size for htable */
POOLMEM *nb = get_pool_memory(PM_FNAME);
*nb = 0; /* clear buffer */
Mmsg(buf, "SELECT sum(JobFiles) FROM Job WHERE JobId IN (%s)",jobids);
db_sql_query(jcr->db, buf.c_str(), db_get_int_handler, nb);
Dmsg2(200, "jobids=%s nb=%s\n", jobids, nb);
jcr->file_bsock->fsend("accurate files=%s\n", nb);
if (!db_open_batch_connexion(jcr, jcr->db)) {
Jmsg0(jcr, M_FATAL, 0, "Can't get dedicate sql connexion");
return false;
}
db_get_file_list(jcr, jcr->db_batch, jobids, accurate_list_handler, (void *)jcr);
/* TODO: close the batch connexion ? (can be used very soon) */
free_pool_memory(jobids);
free_pool_memory(nb);
jcr->file_bsock->signal(BNET_EOD);
return true;
}
/*
* Do a 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;
}
/*
* Pruning Jobs is a bit more complicated than purging Files
* because we delete Job records only if there is a more current
* backup of the FileSet. Otherwise, we keep the Job record.
* In other words, we never delete the only Job record that
* contains a current backup of a FileSet. This prevents the
* Volume from being recycled and destroying a current backup.
*
* For Verify Jobs, we do not delete the last InitCatalog.
*
* For Restore Jobs there are no restrictions.
*/
int prune_jobs(UAContext *ua, CLIENTRES *client, POOLRES *pool, int JobType)
{
POOL_MEM query(PM_MESSAGE);
POOL_MEM sql_where(PM_MESSAGE);
POOL_MEM sql_from(PM_MESSAGE);
utime_t period;
char ed1[50];
alist *jobids_check=NULL;
struct accurate_check_ctx *elt;
db_list_ctx jobids, tempids;
JOB_DBR jr;
struct del_ctx del;
memset(&del, 0, sizeof(del));
if (pool && pool->JobRetention > 0) {
period = pool->JobRetention;
} else if (client) {
period = client->JobRetention;
} else { /* should specify at least pool or client */
return false;
}
db_lock(ua->db);
if (!prune_set_filter(ua, client, pool, period, &sql_from, &sql_where)) {
goto bail_out;
}
/* Drop any previous temporary tables still there */
drop_temp_tables(ua);
/* Create temp tables and indicies */
if (!create_temp_tables(ua)) {
goto bail_out;
}
edit_utime(period, ed1, sizeof(ed1));
Jmsg(ua->jcr, M_INFO, 0, _("Begin pruning Jobs older than %s.\n"), ed1);
del.max_ids = 100;
del.JobId = (JobId_t *)malloc(sizeof(JobId_t) * del.max_ids);
del.PurgedFiles = (char *)malloc(del.max_ids);
/*
* Select all files that are older than the JobRetention period
* and add them into the "DeletionCandidates" table.
*/
Mmsg(query,
"INSERT INTO DelCandidates "
"SELECT JobId,PurgedFiles,FileSetId,JobFiles,JobStatus "
"FROM Job %s " /* JOIN Pool/Client */
"WHERE Type IN ('B', 'C', 'M', 'V', 'D', 'R', 'c', 'm', 'g') "
" %s ", /* Pool/Client + JobTDate */
sql_from.c_str(), sql_where.c_str());
Dmsg1(050, "select sql=%s\n", query.c_str());
if (!db_sql_query(ua->db, query.c_str())) {
if (ua->verbose) {
ua->error_msg("%s", db_strerror(ua->db));
}
goto bail_out;
}
/* Now, for the selection, we discard some of them in order to be always
* able to restore files. (ie, last full, last diff, last incrs)
* Note: The DISTINCT could be more useful if we don't get FileSetId
*/
jobids_check = New(alist(10, owned_by_alist));
Mmsg(query,
"SELECT DISTINCT Job.Name, FileSet, Client.Name, Job.FileSetId, "
"Job.ClientId, Job.Type "
"FROM DelCandidates "
"JOIN Job USING (JobId) "
"JOIN Client USING (ClientId) "
"JOIN FileSet ON (Job.FileSetId = FileSet.FileSetId) "
"WHERE Job.Type IN ('B') " /* Look only Backup jobs */
"AND Job.JobStatus IN ('T', 'W') " /* Look only useful jobs */
);
/* The job_select_handler will skip jobs or filesets that are no longer
* in the configuration file. Interesting ClientId/FileSetId will be
* added to jobids_check (currently disabled in 6.0.7b)
*/
if (!db_sql_query(ua->db, query.c_str(), job_select_handler, jobids_check)) {
ua->error_msg("%s", db_strerror(ua->db));
}
/* For this selection, we exclude current jobs used for restore or
* accurate. This will prevent to prune the last full backup used for
* current backup & restore
*/
memset(&jr, 0, sizeof(jr));
/* To find useful jobs, we do like an incremental */
jr.JobLevel = L_INCREMENTAL;
foreach_alist(elt, jobids_check) {
jr.ClientId = elt->ClientId; /* should be always the same */
jr.FileSetId = elt->FileSetId;
db_accurate_get_jobids(ua->jcr, ua->db, &jr, &tempids);
jobids.add(tempids);
}
/*
* 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;
}
/*
* .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;
}
/*
* .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;
}
