static void update_volslot(UAContext *ua, char *val, MEDIA_DBR *mr)
{
POOL_DBR pr;
memset(&pr, 0, sizeof(POOL_DBR));
pr.PoolId = mr->PoolId;
if (!db_get_pool_numvols(ua->jcr, ua->db, &pr)) {
ua->error_msg("%s", db_strerror(ua->db));
return;
}
mr->Slot = atoi(val);
if (pr.MaxVols > 0 && mr->Slot > (int)pr.MaxVols) {
ua->error_msg(_("Invalid slot, it must be between 0 and MaxVols=%d\n"),
pr.MaxVols);
return;
}
/*
* Make sure to use db_update... rather than doing this directly,
* so that any Slot is handled correctly.
*/
set_storageid_in_mr(NULL, mr);
if (!db_update_media_record(ua->jcr, ua->db, mr)) {
ua->error_msg(_("Error updating media record Slot: ERR=%s"), db_strerror(ua->db));
} else {
ua->info_msg(_("New Slot is: %d\n"), mr->Slot);
}
}
/*
* Called here to send the appropriate commands to the SD
* to do truncate on purge.
*/
static void do_truncate_on_purge(UAContext *ua, MEDIA_DBR *mr,
char *pool, char *storage,
int drive, BSOCK *sd)
{
bool ok=false;
uint64_t VolBytes = 0;
/* TODO: Return if not mr->Recyle ? */
if (!mr->Recycle) {
return;
}
/* Do it only if action on purge = truncate is set */
if (!(mr->ActionOnPurge & ON_PURGE_TRUNCATE)) {
return;
}
/*
* Send the command to truncate the volume after purge. If this feature
* is disabled for the specific device, this will be a no-op.
*/
/* Protect us from spaces */
bash_spaces(mr->VolumeName);
bash_spaces(mr->MediaType);
bash_spaces(pool);
bash_spaces(storage);
/* Do it by relabeling the Volume, which truncates it */
sd->fsend("relabel %s OldName=%s NewName=%s PoolName=%s "
"MediaType=%s Slot=%d drive=%d\n",
storage,
mr->VolumeName, mr->VolumeName,
pool, mr->MediaType, mr->Slot, drive);
unbash_spaces(mr->VolumeName);
unbash_spaces(mr->MediaType);
unbash_spaces(pool);
unbash_spaces(storage);
/* Send relabel command, and check for valid response */
while (sd->recv() >= 0) {
ua->send_msg("%s", sd->msg);
if (sscanf(sd->msg, "3000 OK label. VolBytes=%llu ", &VolBytes) == 1) {
ok = true;
}
}
if (ok) {
mr->VolBytes = VolBytes;
mr->VolFiles = 0;
set_storageid_in_mr(NULL, mr);
if (!db_update_media_record(ua->jcr, ua->db, mr)) {
ua->error_msg(_("Can't update volume size in the catalog\n"));
}
ua->send_msg(_("The volume \"%s\" has been truncated\n"), mr->VolumeName);
} else {
ua->warning_msg(_("Unable to truncate volume \"%s\"\n"), mr->VolumeName);
}
}
/*
* Set the inchanger flag to zero for each slot marked in
* the given slot_list.
*
* The vol_list passed here needs to be from an "autochanger listall" cmd.
*/
void update_inchanger_for_export(UAContext *ua, STORERES *store, dlist *vol_list, char *slot_list)
{
vol_list_t *vl;
MEDIA_DBR mr;
if (!open_client_db(ua)) {
return;
}
/*
* Walk through the list updating the media records
*/
foreach_dlist(vl, vol_list) {
/*
* We are only interested in normal slots.
*/
switch (vl->Type) {
case slot_type_normal:
break;
default:
continue;
}
/*
* Only update entries of slots marked in the slot_list.
*/
if (!bit_is_set(vl->Slot - 1, slot_list)) {
continue;
}
/*
* Set InChanger to zero for this Slot
*/
memset(&mr, 0, sizeof(mr));
mr.Slot = vl->Slot;
mr.InChanger = 1;
mr.MediaId = 0; /* Get by VolumeName */
if (vl->VolName) {
bstrncpy(mr.VolumeName, vl->VolName, sizeof(mr.VolumeName));
} else {
mr.VolumeName[0] = 0;
}
set_storageid_in_mr(store, &mr);
Dmsg4(100, "Before make unique: Vol=%s slot=%d inchanger=%d sid=%d\n",
mr.VolumeName, mr.Slot, mr.InChanger, mr.StorageId);
db_lock(ua->db);
/*
* Set InChanger to zero for this Slot
*/
db_make_inchanger_unique(ua->jcr, ua->db, &mr);
db_unlock(ua->db);
Dmsg4(100, "After make unique: Vol=%s slot=%d inchanger=%d sid=%d\n",
mr.VolumeName, mr.Slot, mr.InChanger, mr.StorageId);
}
return;
}
/*
* IF volume status is Append, Full, Used, or Error, mark it Purged
* Purged volumes can then be recycled (if enabled).
*/
bool mark_media_purged(UAContext *ua, MEDIA_DBR *mr)
{
JCR *jcr = ua->jcr;
bool status;
status = bstrcmp(mr->VolStatus, "Append") ||
bstrcmp(mr->VolStatus, "Full") ||
bstrcmp(mr->VolStatus, "Used") ||
bstrcmp(mr->VolStatus, "Error");
if (status) {
bstrncpy(mr->VolStatus, "Purged", sizeof(mr->VolStatus));
set_storageid_in_mr(NULL, mr);
if (!db_update_media_record(jcr, ua->db, mr)) {
return false;
}
pm_strcpy(jcr->VolumeName, mr->VolumeName);
generate_plugin_event(jcr, bDirEventVolumePurged);
/*
* If the RecyclePool is defined, move the volume there
*/
if (mr->RecyclePoolId && mr->RecyclePoolId != mr->PoolId) {
POOL_DBR oldpr, newpr;
memset(&oldpr, 0, sizeof(POOL_DBR));
memset(&newpr, 0, sizeof(POOL_DBR));
newpr.PoolId = mr->RecyclePoolId;
oldpr.PoolId = mr->PoolId;
if ( db_get_pool_record(jcr, ua->db, &oldpr)
&& db_get_pool_record(jcr, ua->db, &newpr))
{
/* check if destination pool size is ok */
if (newpr.MaxVols > 0 && newpr.NumVols >= newpr.MaxVols) {
ua->error_msg(_("Unable move recycled Volume in full "
"Pool \"%s\" MaxVols=%d\n"),
newpr.Name, newpr.MaxVols);
} else { /* move media */
update_vol_pool(ua, newpr.Name, mr, &oldpr);
}
} else {
ua->error_msg("%s", db_strerror(ua->db));
}
}
/* Send message to Job report, if it is a *real* job */
if (jcr && jcr->JobId > 0) {
Jmsg(jcr, M_INFO, 0, _("All records pruned from Volume \"%s\"; marking it \"Purged\"\n"),
mr->VolumeName);
}
return true;
} else {
ua->error_msg(_("Cannot purge Volume with VolStatus=%s\n"), mr->VolStatus);
}
return bstrcmp(mr->VolStatus, "Purged");
}
static void update_volenabled(UAContext *ua, char *val, MEDIA_DBR *mr)
{
mr->Enabled = get_enabled(ua, val);
if (mr->Enabled < 0) {
return;
}
set_storageid_in_mr(NULL, mr);
if (!db_update_media_record(ua->jcr, ua->db, mr)) {
ua->error_msg(_("Error updating media record Enabled: ERR=%s"),
db_strerror(ua->db));
} else {
ua->info_msg(_("New Enabled is: %d\n"), mr->Enabled);
}
}
static void update_vol_actiononpurge(UAContext *ua, char *val, MEDIA_DBR *mr)
{
POOL_MEM ret;
if (strcasecmp(val, "truncate") == 0) {
mr->ActionOnPurge = ON_PURGE_TRUNCATE;
} else {
mr->ActionOnPurge = 0;
}
set_storageid_in_mr(NULL, mr);
if (!db_update_media_record(ua->jcr, ua->db, mr)) {
ua->error_msg(_("Error updating media record ActionOnPurge: ERR=%s"),
db_strerror(ua->db));
} else {
ua->info_msg(_("New ActionOnPurge is: %s\n"),
action_on_purge_to_string(mr->ActionOnPurge, ret));
}
}
/*
* NOTE! This routine opens the SD socket but leaves it open
*/
static bool send_label_request(UAContext *ua, MEDIA_DBR *mr, MEDIA_DBR *omr,
POOL_DBR *pr, bool relabel, bool media_record_exists,
int drive)
{
BSOCK *sd;
char dev_name[MAX_NAME_LENGTH];
bool ok = false;
uint64_t VolBytes = 0;
if (!(sd=open_sd_bsock(ua))) {
return false;
}
bstrncpy(dev_name, ua->jcr->res.wstore->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
bash_spaces(mr->VolumeName);
bash_spaces(mr->MediaType);
bash_spaces(pr->Name);
if (relabel) {
bash_spaces(omr->VolumeName);
sd->fsend("relabel %s OldName=%s NewName=%s PoolName=%s "
"MediaType=%s Slot=%d drive=%d MinBlocksize=%d MaxBlocksize=%d",
dev_name, omr->VolumeName, mr->VolumeName, pr->Name,
mr->MediaType, mr->Slot, drive,
/*
* if relabeling, keep blocksize settings
*/
omr->MinBlocksize, omr->MaxBlocksize);
ua->send_msg(_("Sending relabel command from \"%s\" to \"%s\" ...\n"),
omr->VolumeName, mr->VolumeName);
} else {
sd->fsend("label %s VolumeName=%s PoolName=%s MediaType=%s "
"Slot=%d drive=%d MinBlocksize=%d MaxBlocksize=%d",
dev_name, mr->VolumeName, pr->Name, mr->MediaType,
mr->Slot, drive,
/*
* if labeling, use blocksize defined in pool
*/
pr->MinBlocksize, pr->MaxBlocksize);
ua->send_msg(_("Sending label command for Volume \"%s\" Slot %d ...\n"),
mr->VolumeName, mr->Slot);
Dmsg8(100, "label %s VolumeName=%s PoolName=%s MediaType=%s "
"Slot=%d drive=%d MinBlocksize=%d MaxBlocksize=%d\n",
dev_name, mr->VolumeName, pr->Name, mr->MediaType, mr->Slot, drive,
pr->MinBlocksize, pr->MaxBlocksize);
}
/*
* We use bget_dirmsg here and not bnet_recv because as part of
* the label request the stored can request catalog information for
* any plugin who listens to the bsdEventLabelVerified event.
* As we don't want to loose any non protocol data e.g. errors
* without a 3xxx prefix we set the allow_any_message of
* bget_dirmsg to true and as such is behaves like a normal
* bnet_recv for any non protocol messages.
*/
while (bget_dirmsg(sd, true) >= 0) {
ua->send_msg("%s", sd->msg);
if (sscanf(sd->msg, "3000 OK label. VolBytes=%llu ", &VolBytes) == 1) {
ok = true;
}
}
unbash_spaces(mr->VolumeName);
unbash_spaces(mr->MediaType);
unbash_spaces(pr->Name);
mr->LabelDate = time(NULL);
mr->set_label_date = true;
if (ok) {
if (media_record_exists) { /* we update it */
mr->VolBytes = VolBytes;
mr->InChanger = mr->Slot > 0; /* if slot give assume in changer */
set_storageid_in_mr(ua->jcr->res.wstore, mr);
if (!db_update_media_record(ua->jcr, ua->db, mr)) {
ua->error_msg("%s", db_strerror(ua->db));
ok = false;
}
} else { /* create the media record */
set_pool_dbr_defaults_in_media_dbr(mr, pr);
mr->VolBytes = VolBytes;
mr->InChanger = mr->Slot > 0; /* if slot give assume in changer */
mr->Enabled = 1;
set_storageid_in_mr(ua->jcr->res.wstore, mr);
if (db_create_media_record(ua->jcr, ua->db, mr)) {
ua->info_msg(_("Catalog record for Volume \"%s\", Slot %d successfully created.\n"),
mr->VolumeName, mr->Slot);
/*
* Update number of volumes in pool
*/
pr->NumVols++;
if (!db_update_pool_record(ua->jcr, ua->db, pr)) {
ua->error_msg("%s", db_strerror(ua->db));
}
} else {
ua->error_msg("%s", db_strerror(ua->db));
ok = false;
}
}
} else {
ua->error_msg(_("Label command failed for Volume %s.\n"), mr->VolumeName);
}
return ok;
}
/*
* Request SD to send us the slot:barcodes, then wiffle
* through them all labeling them.
*/
static void label_from_barcodes(UAContext *ua, int drive, bool label_encrypt)
{
STORERES *store = ua->jcr->res.wstore;
POOL_DBR pr;
MEDIA_DBR mr, omr;
vol_list_t *vl;
dlist *vol_list = NULL;
bool media_record_exists;
char *slot_list;
int max_slots;
max_slots = get_num_slots_from_SD(ua);
if (max_slots <= 0) {
ua->warning_msg(_("No slots in changer to scan.\n"));
return;
}
slot_list = (char *)malloc(nbytes_for_bits(max_slots));
clear_all_bits(max_slots, slot_list);
if (!get_user_slot_list(ua, slot_list, "slots", max_slots)) {
goto bail_out;
}
vol_list = get_vol_list_from_SD(ua, store, false /* no listall */ , false /*no scan*/);
if (!vol_list) {
ua->warning_msg(_("No Volumes found to label, or no barcodes.\n"));
goto bail_out;
}
/*
* Display list of Volumes and ask if he really wants to proceed
*/
ua->send_msg(_("The following Volumes will be labeled:\n"
"Slot Volume\n"
"==============\n"));
foreach_dlist(vl, vol_list) {
if (!vl->VolName || !bit_is_set(vl->Slot - 1, slot_list)) {
continue;
}
ua->send_msg("%4d %s\n", vl->Slot, vl->VolName);
}
if (!get_yesno(ua, _("Do you want to label these Volumes? (yes|no): ")) ||
(ua->pint32_val == 0)) {
goto bail_out;
}
/*
* Select a pool
*/
memset(&pr, 0, sizeof(pr));
if (!select_pool_dbr(ua, &pr)) {
goto bail_out;
}
/*
* Fire off the label requests
*/
foreach_dlist(vl, vol_list) {
if (!vl->VolName || !bit_is_set(vl->Slot - 1, slot_list)) {
continue;
}
mr.clear();
bstrncpy(mr.VolumeName, vl->VolName, sizeof(mr.VolumeName));
media_record_exists = false;
if (db_get_media_record(ua->jcr, ua->db, &mr)) {
if (mr.VolBytes != 0) {
ua->warning_msg(_("Media record for Slot %d Volume \"%s\" already exists.\n"),
vl->Slot, mr.VolumeName);
mr.Slot = vl->Slot;
mr.InChanger = mr.Slot > 0; /* if slot give assume in changer */
set_storageid_in_mr(store, &mr);
if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
ua->error_msg(_("Error setting InChanger: ERR=%s"), db_strerror(ua->db));
}
continue;
}
media_record_exists = true;
}
mr.InChanger = mr.Slot > 0; /* if slot give assume in changer */
set_storageid_in_mr(store, &mr);
/*
* Deal with creating cleaning tape here. Normal tapes created in send_label_request() below
*/
if (is_cleaning_tape(ua, &mr, &pr)) {
if (media_record_exists) { /* we update it */
mr.VolBytes = 1; /* any bytes to indicate it exists */
bstrncpy(mr.VolStatus, "Cleaning", sizeof(mr.VolStatus));
mr.MediaType[0] = 0;
set_storageid_in_mr(store, &mr);
if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
ua->error_msg("%s", db_strerror(ua->db));
}
} else { /* create the media record */
if (pr.MaxVols > 0 && pr.NumVols >= pr.MaxVols) {
ua->error_msg(_("Maximum pool Volumes=%d reached.\n"), pr.MaxVols);
goto bail_out;
}
set_pool_dbr_defaults_in_media_dbr(&mr, &pr);
bstrncpy(mr.VolStatus, "Cleaning", sizeof(mr.VolStatus));
mr.MediaType[0] = 0;
set_storageid_in_mr(store, &mr);
if (db_create_media_record(ua->jcr, ua->db, &mr)) {
ua->send_msg(_("Catalog record for cleaning tape \"%s\" successfully created.\n"),
mr.VolumeName);
pr.NumVols++; /* this is a bit suspect */
if (!db_update_pool_record(ua->jcr, ua->db, &pr)) {
ua->error_msg("%s", db_strerror(ua->db));
}
} else {
ua->error_msg(_("Catalog error on cleaning tape: %s"), db_strerror(ua->db));
}
}
continue; /* done, go handle next volume */
}
bstrncpy(mr.MediaType, store->media_type, sizeof(mr.MediaType));
/*
* See if we need to generate a new passphrase for hardware encryption.
*/
if (label_encrypt) {
if (!generate_new_encryption_key(ua, &mr)) {
continue;
}
}
mr.Slot = vl->Slot;
send_label_request(ua, &mr, &omr, &pr, false, media_record_exists, drive);
}
bail_out:
free(slot_list);
if (vol_list) {
free_vol_list(vol_list);
}
close_sd_bsock(ua);
return;
}
/*
* Automatic Volume name creation using the LabelFormat
*
* The media record must have the PoolId filled in when
* calling this routine.
*/
bool newVolume(JCR *jcr, MEDIA_DBR *mr, STORERES *store)
{
bool retval = false;
POOL_DBR pr;
memset(&pr, 0, sizeof(pr));
/*
* See if we can create a new Volume
*/
db_lock(jcr->db);
pr.PoolId = mr->PoolId;
if (!db_get_pool_record(jcr, jcr->db, &pr)) {
goto bail_out;
}
if (pr.MaxVols == 0 || pr.NumVols < pr.MaxVols) {
memset(mr, 0, sizeof(MEDIA_DBR));
set_pool_dbr_defaults_in_media_dbr(mr, &pr);
jcr->VolumeName[0] = 0;
bstrncpy(mr->MediaType, jcr->res.wstore->media_type, sizeof(mr->MediaType));
generate_plugin_event(jcr, bDirEventNewVolume); /* return void... */
if (jcr->VolumeName[0] && is_volume_name_legal(NULL, jcr->VolumeName)) {
bstrncpy(mr->VolumeName, jcr->VolumeName, sizeof(mr->VolumeName));
} else if (pr.LabelFormat[0] && pr.LabelFormat[0] != '*') {
/*
* Check for special characters
*/
if (is_volume_name_legal(NULL, pr.LabelFormat)) {
/*
* No special characters, so apply simple algorithm
*/
if (!create_simple_name(jcr, mr, &pr)) {
goto bail_out;
}
} else {
/*
* Found special characters, so try full substitution
*/
if (!perform_full_name_substitution(jcr, mr, &pr)) {
goto bail_out;
}
if (!is_volume_name_legal(NULL, mr->VolumeName)) {
Jmsg(jcr, M_ERROR, 0, _("Illegal character in Volume name \"%s\"\n"),
mr->VolumeName);
goto bail_out;
}
}
} else {
goto bail_out;
}
pr.NumVols++;
mr->Enabled = 1;
set_storageid_in_mr(store, mr);
if (db_create_media_record(jcr, jcr->db, mr) &&
db_update_pool_record(jcr, jcr->db, &pr)) {
Jmsg(jcr, M_INFO, 0, _("Created new Volume \"%s\" in catalog.\n"), mr->VolumeName);
Dmsg1(90, "Created new Volume=%s\n", mr->VolumeName);
retval = true;
goto bail_out;
} else {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
}
}
bail_out:
db_unlock(jcr->db);
return retval;
}
/*
* Implement Bareos bconsole command purge action
* purge action= pool= volume= storage= devicetype=
*/
static int action_on_purge_cmd(UAContext *ua, const char *cmd)
{
bool allpools = false;
int drive = -1;
int nb = 0;
uint32_t *results = NULL;
const char *action = "all";
STORERES *store = NULL;
POOLRES *pool = NULL;
MEDIA_DBR mr;
POOL_DBR pr;
BSOCK *sd = NULL;
memset(&pr, 0, sizeof(pr));
/* Look at arguments */
for (int i=1; i<ua->argc; i++) {
if (bstrcasecmp(ua->argk[i], NT_("allpools"))) {
allpools = true;
} else if (bstrcasecmp(ua->argk[i], NT_("volume")) &&
is_name_valid(ua->argv[i], NULL)) {
bstrncpy(mr.VolumeName, ua->argv[i], sizeof(mr.VolumeName));
} else if (bstrcasecmp(ua->argk[i], NT_("devicetype")) &&
ua->argv[i]) {
bstrncpy(mr.MediaType, ua->argv[i], sizeof(mr.MediaType));
} else if (bstrcasecmp(ua->argk[i], NT_("drive")) && ua->argv[i]) {
drive = atoi(ua->argv[i]);
} else if (bstrcasecmp(ua->argk[i], NT_("action")) &&
is_name_valid(ua->argv[i], NULL)) {
action=ua->argv[i];
}
}
/* Choose storage */
ua->jcr->res.wstore = store = get_storage_resource(ua, false);
if (!store) {
goto bail_out;
}
switch (store->Protocol) {
case APT_NDMPV2:
case APT_NDMPV3:
case APT_NDMPV4:
ua->warning_msg(_("Storage has non-native protocol.\n"));
goto bail_out;
default:
break;
}
if (!open_db(ua)) {
Dmsg0(100, "Can't open db\n");
goto bail_out;
}
if (!allpools) {
/* force pool selection */
pool = get_pool_resource(ua);
if (!pool) {
Dmsg0(100, "Can't get pool resource\n");
goto bail_out;
}
bstrncpy(pr.Name, pool->name(), sizeof(pr.Name));
if (!db_get_pool_record(ua->jcr, ua->db, &pr)) {
Dmsg0(100, "Can't get pool record\n");
goto bail_out;
}
mr.PoolId = pr.PoolId;
}
/*
* Look for all Purged volumes that can be recycled, are enabled and
* have more the 10,000 bytes.
*/
mr.Recycle = 1;
mr.Enabled = 1;
mr.VolBytes = 10000;
set_storageid_in_mr(store, &mr);
bstrncpy(mr.VolStatus, "Purged", sizeof(mr.VolStatus));
if (!db_get_media_ids(ua->jcr, ua->db, &mr, &nb, &results)) {
Dmsg0(100, "No results from db_get_media_ids\n");
goto bail_out;
}
if (!nb) {
ua->send_msg(_("No Volumes found to perform %s action.\n"), action);
goto bail_out;
}
if ((sd = open_sd_bsock(ua)) == NULL) {
Dmsg0(100, "Can't open connection to sd\n");
goto bail_out;
}
/*
* Loop over the candidate Volumes and actually truncate them
*/
for (int i=0; i < nb; i++) {
mr.clear();
mr.MediaId = results[i];
if (db_get_media_record(ua->jcr, ua->db, &mr)) {
/* TODO: ask for drive and change Pool */
if (bstrcasecmp("truncate", action) || bstrcasecmp("all", action)) {
do_truncate_on_purge(ua, &mr, pr.Name, store->dev_name(), drive, sd);
}
} else {
Dmsg1(0, "Can't find MediaId=%lld\n", (uint64_t) mr.MediaId);
}
}
bail_out:
close_db(ua);
if (sd) {
sd->signal(BNET_TERMINATE);
sd->close();
ua->jcr->store_bsock = NULL;
}
ua->jcr->res.wstore = NULL;
if (results) {
free(results);
}
return 1;
}
/*
* Update Slots corresponding to Volumes in autochanger.
* We only update any new volume location of slots marked in
* the given slot_list. If you want to do funky stuff
* run an "update slots" with the options you want. This
* is a simple function which syncs the info from the
* vol_list to the database for each slot marked in
* the slot_list.
*
* The vol_list passed here needs to be from an "autochanger listall" cmd.
*/
void update_slots_from_vol_list(UAContext *ua, STORERES *store, dlist *vol_list, char *slot_list)
{
vol_list_t *vl;
MEDIA_DBR mr;
if (!open_client_db(ua)) {
return;
}
/*
* Walk through the list updating the media records
*/
foreach_dlist(vl, vol_list) {
/*
* We are only interested in normal slots.
*/
switch (vl->Type) {
case slot_type_normal:
break;
default:
continue;
}
/*
* Only update entries of slots marked in the slot_list.
*/
if (!bit_is_set(vl->Slot - 1, slot_list)) {
continue;
}
/*
* Set InChanger to zero for this Slot
*/
memset(&mr, 0, sizeof(mr));
mr.Slot = vl->Slot;
mr.InChanger = 1;
mr.MediaId = 0; /* Get by VolumeName */
if (vl->VolName) {
bstrncpy(mr.VolumeName, vl->VolName, sizeof(mr.VolumeName));
} else {
mr.VolumeName[0] = 0;
}
set_storageid_in_mr(store, &mr);
Dmsg4(100, "Before make unique: Vol=%s slot=%d inchanger=%d sid=%d\n",
mr.VolumeName, mr.Slot, mr.InChanger, mr.StorageId);
db_lock(ua->db);
/*
* Set InChanger to zero for this Slot
*/
db_make_inchanger_unique(ua->jcr, ua->db, &mr);
db_unlock(ua->db);
Dmsg4(100, "After make unique: Vol=%s slot=%d inchanger=%d sid=%d\n",
mr.VolumeName, mr.Slot, mr.InChanger, mr.StorageId);
/*
* See if there is anything in the slot.
*/
switch (vl->Content) {
case slot_content_full:
if (!vl->VolName) {
Dmsg1(100, "No VolName for Slot=%d setting InChanger to zero.\n", vl->Slot);
continue;
}
break;
default:
continue;
}
/*
* There is something in the slot and it has a VolumeName so we can check
* the database and perform an update if needed.
*/
db_lock(ua->db);
Dmsg4(100, "Before get MR: Vol=%s slot=%d inchanger=%d sid=%d\n",
mr.VolumeName, mr.Slot, mr.InChanger, mr.StorageId);
if (db_get_media_record(ua->jcr, ua->db, &mr)) {
Dmsg4(100, "After get MR: Vol=%s slot=%d inchanger=%d sid=%d\n",
mr.VolumeName, mr.Slot, mr.InChanger, mr.StorageId);
/* If Slot, Inchanger, and StorageId have changed, update the Media record */
if (mr.Slot != vl->Slot || !mr.InChanger || mr.StorageId != store->StorageId) {
mr.Slot = vl->Slot;
mr.InChanger = 1;
set_storageid_in_mr(store, &mr);
if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
ua->error_msg("%s", db_strerror(ua->db));
}
}
} else {
ua->warning_msg(_("Volume \"%s\" not found in catalog. Slot=%d InChanger set to zero.\n"),
mr.VolumeName, vl->Slot);
}
db_unlock(ua->db);
}
return;
}
/*
* Update a media record -- allows you to change the
* Volume status. E.g. if you want Bacula to stop
* writing on the volume, set it to anything other
* than Append.
*/
static int update_volume(UAContext *ua)
{
MEDIA_DBR mr;
POOL *pool;
POOL_DBR pr;
POOLMEM *query;
POOL_MEM ret;
char buf[1000];
char ed1[130];
bool done = false;
int i;
const char *kw[] = {
NT_("VolStatus"), /* 0 */
NT_("VolRetention"), /* 1 */
NT_("VolUse"), /* 2 */
NT_("MaxVolJobs"), /* 3 */
NT_("MaxVolFiles"), /* 4 */
NT_("MaxVolBytes"), /* 5 */
NT_("Recycle"), /* 6 */
NT_("InChanger"), /* 7 */
NT_("Slot"), /* 8 */
NT_("Pool"), /* 9 */
NT_("FromPool"), /* 10 */
NT_("AllFromPool"), /* 11 !!! see below !!! */
NT_("Enabled"), /* 12 */
NT_("RecyclePool"), /* 13 */
NT_("ActionOnPurge"), /* 14 */
NULL };
#define AllFromPool 11 /* keep this updated with above */
for (i=0; kw[i]; i++) {
int j;
POOL_DBR pr;
if ((j=find_arg_with_value(ua, kw[i])) > 0) {
/* If all from pool don't select a media record */
if (i != AllFromPool && !select_media_dbr(ua, &mr)) {
return 0;
}
switch (i) {
case 0:
update_volstatus(ua, ua->argv[j], &mr);
break;
case 1:
update_volretention(ua, ua->argv[j], &mr);
break;
case 2:
update_voluseduration(ua, ua->argv[j], &mr);
break;
case 3:
update_volmaxjobs(ua, ua->argv[j], &mr);
break;
case 4:
update_volmaxfiles(ua, ua->argv[j], &mr);
break;
case 5:
update_volmaxbytes(ua, ua->argv[j], &mr);
break;
case 6:
update_volrecycle(ua, ua->argv[j], &mr);
break;
case 7:
update_volinchanger(ua, ua->argv[j], &mr);
break;
case 8:
update_volslot(ua, ua->argv[j], &mr);
break;
case 9:
memset(&pr, 0, sizeof(POOL_DBR));
pr.PoolId = mr.PoolId;
if (!db_get_pool_numvols(ua->jcr, ua->db, &pr)) {
ua->error_msg("%s", db_strerror(ua->db));
break;
}
update_vol_pool(ua, ua->argv[j], &mr, &pr);
break;
case 10:
update_vol_from_pool(ua, &mr);
return 1;
case 11:
update_all_vols_from_pool(ua, ua->argv[j]);
return 1;
case 12:
update_volenabled(ua, ua->argv[j], &mr);
break;
case 13:
update_vol_recyclepool(ua, ua->argv[j], &mr);
break;
case 14:
update_vol_actiononpurge(ua, ua->argv[j], &mr);
break;
}
done = true;
}
}
/* Allow user to simply update all volumes */
if (find_arg(ua, NT_("fromallpools")) > 0) {
update_all_vols(ua);
return 1;
}
for ( ; !done; ) {
start_prompt(ua, _("Parameters to modify:\n"));
add_prompt(ua, _("Volume Status")); /* 0 */
add_prompt(ua, _("Volume Retention Period")); /* 1 */
add_prompt(ua, _("Volume Use Duration")); /* 2 */
add_prompt(ua, _("Maximum Volume Jobs")); /* 3 */
add_prompt(ua, _("Maximum Volume Files")); /* 4 */
add_prompt(ua, _("Maximum Volume Bytes")); /* 5 */
add_prompt(ua, _("Recycle Flag")); /* 6 */
add_prompt(ua, _("Slot")); /* 7 */
add_prompt(ua, _("InChanger Flag")); /* 8 */
add_prompt(ua, _("Volume Files")); /* 9 */
add_prompt(ua, _("Pool")); /* 10 */
add_prompt(ua, _("Volume from Pool")); /* 11 */
add_prompt(ua, _("All Volumes from Pool")); /* 12 */
add_prompt(ua, _("All Volumes from all Pools")); /* 13 */
add_prompt(ua, _("Enabled")), /* 14 */
add_prompt(ua, _("RecyclePool")), /* 15 */
add_prompt(ua, _("Action On Purge")), /* 16 */
add_prompt(ua, _("Done")); /* 17 */
i = do_prompt(ua, "", _("Select parameter to modify"), NULL, 0);
/* For All Volumes, All Volumes from Pool, and Done, we don't need
* a Volume record */
if ( i != 12 && i != 13 && i != 17) {
if (!select_media_dbr(ua, &mr)) { /* Get Volume record */
return 0;
}
ua->info_msg(_("Updating Volume \"%s\"\n"), mr.VolumeName);
}
switch (i) {
case 0: /* Volume Status */
/* Modify Volume Status */
ua->info_msg(_("Current Volume status is: %s\n"), mr.VolStatus);
start_prompt(ua, _("Possible Values are:\n"));
add_prompt(ua, NT_("Append"));
add_prompt(ua, NT_("Archive"));
add_prompt(ua, NT_("Disabled"));
add_prompt(ua, NT_("Full"));
add_prompt(ua, NT_("Used"));
add_prompt(ua, NT_("Cleaning"));
if (strcmp(mr.VolStatus, NT_("Purged")) == 0) {
add_prompt(ua, NT_("Recycle"));
}
add_prompt(ua, NT_("Read-Only"));
if (do_prompt(ua, "", _("Choose new Volume Status"), ua->cmd, sizeof(mr.VolStatus)) < 0) {
return 1;
}
update_volstatus(ua, ua->cmd, &mr);
break;
case 1: /* Retention */
ua->info_msg(_("Current retention period is: %s\n"),
edit_utime(mr.VolRetention, ed1, sizeof(ed1)));
if (!get_cmd(ua, _("Enter Volume Retention period: "))) {
return 0;
}
update_volretention(ua, ua->cmd, &mr);
break;
case 2: /* Use Duration */
ua->info_msg(_("Current use duration is: %s\n"),
edit_utime(mr.VolUseDuration, ed1, sizeof(ed1)));
if (!get_cmd(ua, _("Enter Volume Use Duration: "))) {
return 0;
}
update_voluseduration(ua, ua->cmd, &mr);
break;
case 3: /* Max Jobs */
ua->info_msg(_("Current max jobs is: %u\n"), mr.MaxVolJobs);
if (!get_pint(ua, _("Enter new Maximum Jobs: "))) {
return 0;
}
update_volmaxjobs(ua, ua->cmd, &mr);
break;
case 4: /* Max Files */
ua->info_msg(_("Current max files is: %u\n"), mr.MaxVolFiles);
if (!get_pint(ua, _("Enter new Maximum Files: "))) {
return 0;
}
update_volmaxfiles(ua, ua->cmd, &mr);
break;
case 5: /* Max Bytes */
ua->info_msg(_("Current value is: %s\n"), edit_uint64(mr.MaxVolBytes, ed1));
if (!get_cmd(ua, _("Enter new Maximum Bytes: "))) {
return 0;
}
update_volmaxbytes(ua, ua->cmd, &mr);
break;
case 6: /* Recycle */
ua->info_msg(_("Current recycle flag is: %s\n"),
mr.Recycle==1?_("yes"):_("no"));
if (!get_yesno(ua, _("Enter new Recycle status: "))) {
return 0;
}
update_volrecycle(ua, ua->cmd, &mr);
break;
case 7: /* Slot */
ua->info_msg(_("Current Slot is: %d\n"), mr.Slot);
if (!get_pint(ua, _("Enter new Slot: "))) {
return 0;
}
update_volslot(ua, ua->cmd, &mr);
break;
case 8: /* InChanger */
ua->info_msg(_("Current InChanger flag is: %d\n"), mr.InChanger);
bsnprintf(buf, sizeof(buf), _("Set InChanger flag for Volume \"%s\": yes/no: "),
mr.VolumeName);
if (!get_yesno(ua, buf)) {
return 0;
}
mr.InChanger = ua->pint32_val;
/*
* Make sure to use db_update... rather than doing this directly,
* so that any Slot is handled correctly.
*/
set_storageid_in_mr(NULL, &mr);
if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
ua->error_msg(_("Error updating media record Slot: ERR=%s"), db_strerror(ua->db));
} else {
ua->info_msg(_("New InChanger flag is: %d\n"), mr.InChanger);
}
break;
case 9: /* Volume Files */
int32_t VolFiles;
ua->warning_msg(_("Warning changing Volume Files can result\n"
"in loss of data on your Volume\n\n"));
ua->info_msg(_("Current Volume Files is: %u\n"), mr.VolFiles);
if (!get_pint(ua, _("Enter new number of Files for Volume: "))) {
return 0;
}
VolFiles = ua->pint32_val;
if (VolFiles != (int)(mr.VolFiles + 1)) {
ua->warning_msg(_("Normally, you should only increase Volume Files by one!\n"));
if (!get_yesno(ua, _("Increase Volume Files? (yes/no): ")) || ua->pint32_val == 0) {
break;
}
}
query = get_pool_memory(PM_MESSAGE);
Mmsg(query, "UPDATE Media SET VolFiles=%u WHERE MediaId=%s",
VolFiles, edit_int64(mr.MediaId, ed1));
if (!db_sql_query(ua->db, query, NULL, NULL)) {
ua->error_msg("%s", db_strerror(ua->db));
} else {
ua->info_msg(_("New Volume Files is: %u\n"), VolFiles);
}
free_pool_memory(query);
break;
case 10: /* Volume's Pool */
memset(&pr, 0, sizeof(POOL_DBR));
pr.PoolId = mr.PoolId;
if (!db_get_pool_numvols(ua->jcr, ua->db, &pr)) {
ua->error_msg("%s", db_strerror(ua->db));
return 0;
}
ua->info_msg(_("Current Pool is: %s\n"), pr.Name);
if (!get_cmd(ua, _("Enter new Pool name: "))) {
return 0;
}
update_vol_pool(ua, ua->cmd, &mr, &pr);
return 1;
case 11:
update_vol_from_pool(ua, &mr);
return 1;
case 12:
pool = select_pool_resource(ua);
if (pool) {
update_all_vols_from_pool(ua, pool->name());
}
return 1;
case 13:
update_all_vols(ua);
return 1;
case 14:
ua->info_msg(_("Current Enabled is: %d\n"), mr.Enabled);
if (!get_cmd(ua, _("Enter new Enabled: "))) {
return 0;
}
update_volenabled(ua, ua->cmd, &mr);
break;
case 15:
memset(&pr, 0, sizeof(POOL_DBR));
pr.PoolId = mr.RecyclePoolId;
if (db_get_pool_numvols(ua->jcr, ua->db, &pr)) {
ua->info_msg(_("Current RecyclePool is: %s\n"), pr.Name);
} else {
ua->info_msg(_("No current RecyclePool\n"));
}
if (!select_pool_dbr(ua, &pr, NT_("recyclepool"))) {
return 0;
}
update_vol_recyclepool(ua, pr.Name, &mr);
return 1;
case 16:
pm_strcpy(ret, "");
ua->info_msg(_("Current ActionOnPurge is: %s\n"),
action_on_purge_to_string(mr.ActionOnPurge, ret));
if (!get_cmd(ua, _("Enter new ActionOnPurge (one of: Truncate, None): "))) {
return 0;
}
update_vol_actiononpurge(ua, ua->cmd, &mr);
break;
default: /* Done or error */
ua->info_msg(_("Selection terminated.\n"));
return 1;
}
}
return 1;
}
/*
* Update Slots corresponding to Volumes in autochanger
*/
static void update_slots(UAContext *ua)
{
USTORERES store;
vol_list_t *vl;
dlist *vol_list = NULL;
MEDIA_DBR mr;
char *slot_list;
bool scan;
int max_slots;
int drive = -1;
int Enabled = 1;
bool have_enabled;
int i;
if (!open_client_db(ua)) {
return;
}
store.store = get_storage_resource(ua, true, true);
if (!store.store) {
return;
}
pm_strcpy(store.store_source, _("command line"));
set_wstorage(ua->jcr, &store);
scan = find_arg(ua, NT_("scan")) >= 0;
if (scan) {
drive = get_storage_drive(ua, store.store);
}
if ((i=find_arg_with_value(ua, NT_("Enabled"))) >= 0) {
Enabled = get_enabled(ua, ua->argv[i]);
if (Enabled < 0) {
return;
}
have_enabled = true;
} else {
have_enabled = false;
}
max_slots = get_num_slots_from_SD(ua);
Dmsg1(100, "max_slots=%d\n", max_slots);
if (max_slots <= 0) {
ua->warning_msg(_("No slots in changer to scan.\n"));
return;
}
slot_list = (char *)malloc(nbytes_for_bits(max_slots));
clear_all_bits(max_slots, slot_list);
if (!get_user_slot_list(ua, slot_list, "slots", max_slots)) {
free(slot_list);
return;
}
vol_list = get_vol_list_from_SD(ua, store.store, false, scan);
if (!vol_list) {
ua->warning_msg(_("No Volumes found to update, or no barcodes.\n"));
goto bail_out;
}
/*
* First zap out any InChanger with StorageId=0
*/
db_sql_query(ua->db, "UPDATE Media SET InChanger=0 WHERE StorageId=0");
/*
* Walk through the list updating the media records
*/
memset(&mr, 0, sizeof(mr));
foreach_dlist(vl, vol_list) {
if (vl->Slot > max_slots) {
ua->warning_msg(_("Slot %d greater than max %d ignored.\n"), vl->Slot, max_slots);
continue;
}
/*
* Check if user wants us to look at this slot
*/
if (!bit_is_set(vl->Slot - 1, slot_list)) {
Dmsg1(100, "Skipping slot=%d\n", vl->Slot);
continue;
}
/*
* If scanning, we read the label rather than the barcode
*/
if (scan) {
if (vl->VolName) {
free(vl->VolName);
vl->VolName = NULL;
}
vl->VolName = get_volume_name_from_SD(ua, vl->Slot, drive);
Dmsg2(100, "Got Vol=%s from SD for Slot=%d\n", vl->VolName, vl->Slot);
}
clear_bit(vl->Slot - 1, slot_list); /* clear Slot */
set_storageid_in_mr(store.store, &mr);
mr.Slot = vl->Slot;
mr.InChanger = 1;
mr.MediaId = 0; /* Get by VolumeName */
if (vl->VolName) {
bstrncpy(mr.VolumeName, vl->VolName, sizeof(mr.VolumeName));
} else {
mr.VolumeName[0] = 0;
}
set_storageid_in_mr(store.store, &mr);
Dmsg4(100, "Before make unique: Vol=%s slot=%d inchanger=%d sid=%d\n",
mr.VolumeName, mr.Slot, mr.InChanger, mr.StorageId);
db_lock(ua->db);
/*
* Set InChanger to zero for this Slot
*/
db_make_inchanger_unique(ua->jcr, ua->db, &mr);
db_unlock(ua->db);
Dmsg4(100, "After make unique: Vol=%s slot=%d inchanger=%d sid=%d\n",
mr.VolumeName, mr.Slot, mr.InChanger, mr.StorageId);
if (!vl->VolName) {
Dmsg1(100, "No VolName for Slot=%d setting InChanger to zero.\n", vl->Slot);
ua->info_msg(_("No VolName for Slot=%d InChanger set to zero.\n"), vl->Slot);
continue;
}
db_lock(ua->db);
Dmsg4(100, "Before get MR: Vol=%s slot=%d inchanger=%d sid=%d\n",
mr.VolumeName, mr.Slot, mr.InChanger, mr.StorageId);
if (db_get_media_record(ua->jcr, ua->db, &mr)) {
Dmsg4(100, "After get MR: Vol=%s slot=%d inchanger=%d sid=%d\n",
mr.VolumeName, mr.Slot, mr.InChanger, mr.StorageId);
/*
* If Slot, Inchanger, and StorageId have changed, update the Media record
*/
if (mr.Slot != vl->Slot || !mr.InChanger || mr.StorageId != store.store->StorageId) {
mr.Slot = vl->Slot;
mr.InChanger = 1;
if (have_enabled) {
mr.Enabled = Enabled;
}
set_storageid_in_mr(store.store, &mr);
if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
ua->error_msg("%s", db_strerror(ua->db));
} else {
ua->info_msg(_("Catalog record for Volume \"%s\" updated to reference slot %d.\n"),
mr.VolumeName, mr.Slot);
}
} else {
ua->info_msg(_("Catalog record for Volume \"%s\" is up to date.\n"), mr.VolumeName);
}
} else {
ua->warning_msg(_("Volume \"%s\" not found in catalog. Slot=%d InChanger set to zero.\n"),
mr.VolumeName, vl->Slot);
}
db_unlock(ua->db);
}
memset(&mr, 0, sizeof(mr));
mr.InChanger = 1;
set_storageid_in_mr(store.store, &mr);
/*
* Any slot not visited gets it Inchanger flag reset.
*/
db_lock(ua->db);
for (i = 1; i <= max_slots; i++) {
if (bit_is_set(i - 1, slot_list)) {
/*
* Set InChanger to zero for this Slot
*/
mr.Slot = i;
db_make_inchanger_unique(ua->jcr, ua->db, &mr);
}
}
db_unlock(ua->db);
bail_out:
if (vol_list) {
free_vol_list(vol_list);
}
free(slot_list);
close_sd_bsock(ua);
return;
}
/*
* Common routine for both label and relabel
*/
static int do_label(UAContext *ua, const char *cmd, bool relabel)
{
USTORERES store;
BSOCK *sd;
char dev_name[MAX_NAME_LENGTH];
MEDIA_DBR mr, omr;
POOL_DBR pr;
bool print_reminder = true;
bool label_barcodes = false;
bool label_encrypt = false;
int ok = FALSE;
int i, j;
int drive;
bool media_record_exists = false;
static const char *barcode_keywords[] = {
"barcode",
"barcodes",
NULL
};
memset(&pr, 0, sizeof(pr));
if (!open_client_db(ua)) {
return 1;
}
/*
* Look for one of the barcode keywords
*/
if (!relabel && (i = find_arg_keyword(ua, barcode_keywords)) >= 0) {
/*
* Now find the keyword in the list
*/
if ((j = find_arg(ua, barcode_keywords[i])) > 0) {
*ua->argk[j] = 0; /* zap barcode keyword */
}
label_barcodes = true;
}
/*
* Look for the encrypt keyword
*/
if ((i = find_arg(ua, "encrypt")) > 0) {
*ua->argk[i] = 0; /* zap encrypt keyword */
label_encrypt = true;
}
store.store = get_storage_resource(ua, true, label_barcodes);
if (!store.store) {
return 1;
}
switch (store.store->Protocol) {
case APT_NDMPV2:
case APT_NDMPV3:
case APT_NDMPV4:
/*
* See if the user selected a NDMP storage device but its
* handled by a native Bareos storage daemon e.g. we have
* a paired_storage pointer.
*/
if (store.store->paired_storage) {
store.store = store.store->paired_storage;
} else {
ua->warning_msg(_("Storage has non-native protocol.\n"));
return 1;
}
break;
default:
break;
}
pm_strcpy(store.store_source, _("command line"));
set_wstorage(ua->jcr, &store);
drive = get_storage_drive(ua, store.store);
if (label_barcodes) {
label_from_barcodes(ua, drive, label_encrypt);
return 1;
}
/*
* If relabel get name of Volume to relabel
*/
if (relabel) {
/*
* Check for oldvolume=name
*/
i = find_arg_with_value(ua, "oldvolume");
if (i >= 0) {
bstrncpy(omr.VolumeName, ua->argv[i], sizeof(omr.VolumeName));
if (db_get_media_record(ua->jcr, ua->db, &omr)) {
goto checkVol;
}
ua->error_msg("%s", db_strerror(ua->db));
}
/*
* No keyword or Vol not found, ask user to select
*/
if (!select_media_dbr(ua, &omr)) {
return 1;
}
/*
* Require Volume to be Purged or Recycled
*/
checkVol:
if (!bstrcmp(omr.VolStatus, "Purged") && !bstrcmp(omr.VolStatus, "Recycle")) {
ua->error_msg(_("Volume \"%s\" has VolStatus %s. It must be Purged or Recycled before relabeling.\n"),
omr.VolumeName, omr.VolStatus);
return 1;
}
}
/*
* Check for volume=NewVolume
*/
i = find_arg_with_value(ua, "volume");
if (i >= 0) {
pm_strcpy(ua->cmd, ua->argv[i]);
goto checkName;
}
/*
* Get a new Volume name
*/
for ( ;; ) {
media_record_exists = false;
if (!get_cmd(ua, _("Enter new Volume name: "))) {
return 1;
}
checkName:
if (!is_volume_name_legal(ua, ua->cmd)) {
continue;
}
/*
* Search by Media name so set VolumeName and clear MediaId.
*/
mr.MediaId = 0;
bstrncpy(mr.VolumeName, ua->cmd, sizeof(mr.VolumeName));
/*
* If VolBytes are zero the Volume is not labeled
*/
if (db_get_media_record(ua->jcr, ua->db, &mr)) {
if (mr.VolBytes != 0) {
ua->error_msg(_("Media record for new Volume \"%s\" already exists.\n"),
mr.VolumeName);
continue;
}
media_record_exists = true;
}
break; /* Got it */
}
/*
* If autochanger, request slot
*/
i = find_arg_with_value(ua, "slot");
if (i >= 0) {
mr.Slot = atoi(ua->argv[i]);
if (mr.Slot < 0) {
mr.Slot = 0;
}
mr.InChanger = mr.Slot > 0; /* if slot give assume in changer */
} else if (store.store->autochanger) {
if (!get_pint(ua, _("Enter slot (0 or Enter for none): "))) {
return 1;
}
mr.Slot = ua->pint32_val;
if (mr.Slot < 0) {
mr.Slot = 0;
}
mr.InChanger = mr.Slot > 0; /* if slot give assume in changer */
}
set_storageid_in_mr(store.store, &mr);
bstrncpy(mr.MediaType, store.store->media_type, sizeof(mr.MediaType));
/*
* Must select Pool if not already done
*/
if (pr.PoolId == 0) {
memset(&pr, 0, sizeof(pr));
if (!select_pool_dbr(ua, &pr)) {
return 1;
}
}
/*
* See if we need to generate a new passphrase for hardware encryption.
*/
if (label_encrypt) {
ua->info_msg(_("Generating new hardware encryption key\n"));
if (!generate_new_encryption_key(ua, &mr)) {
return 1;
}
}
ok = send_label_request(ua, &mr, &omr, &pr, relabel, media_record_exists, drive);
if (ok) {
sd = ua->jcr->store_bsock;
if (relabel) {
/*
* Delete the old media record
*/
if (!db_delete_media_record(ua->jcr, ua->db, &omr)) {
ua->error_msg(_("Delete of Volume \"%s\" failed. ERR=%s"),
omr.VolumeName, db_strerror(ua->db));
} else {
ua->info_msg(_("Old volume \"%s\" deleted from catalog.\n"),
omr.VolumeName);
/*
* Update the number of Volumes in the pool
*/
pr.NumVols--;
if (!db_update_pool_record(ua->jcr, ua->db, &pr)) {
ua->error_msg("%s", db_strerror(ua->db));
}
}
}
if (ua->automount) {
bstrncpy(dev_name, store.store->dev_name(), sizeof(dev_name));
ua->info_msg(_("Requesting to mount %s ...\n"), dev_name);
bash_spaces(dev_name);
sd->fsend("mount %s drive=%d", dev_name, drive);
unbash_spaces(dev_name);
/*
* We use bget_dirmsg here and not bnet_recv because as part of
* the mount request the stored can request catalog information for
* any plugin who listens to the bsdEventLabelVerified event.
* As we don't want to loose any non protocol data e.g. errors
* without a 3xxx prefix we set the allow_any_message of
* bget_dirmsg to true and as such is behaves like a normal
* bnet_recv for any non protocol messages.
*/
while (bget_dirmsg(sd, true) >= 0) {
ua->send_msg("%s", sd->msg);
/*
* Here we can get
* 3001 OK mount. Device=xxx or
* 3001 Mounted Volume vvvv
* 3002 Device "DVD-Writer" (/dev/hdc) is mounted.
* 3906 is cannot mount non-tape
* So for those, no need to print a reminder
*/
if (bstrncmp(sd->msg, "3001 ", 5) ||
bstrncmp(sd->msg, "3002 ", 5) ||
bstrncmp(sd->msg, "3906 ", 5)) {
print_reminder = false;
}
}
}
}
if (print_reminder) {
ua->info_msg(_("Do not forget to mount the drive!!!\n"));
}
close_sd_bsock(ua);
return 1;
}
static bool list_nextvol(UAContext *ua, int ndays)
{
JOBRES *job;
JCR *jcr;
USTORERES store;
RUNRES *run;
utime_t runtime;
bool found = false;
MEDIA_DBR mr;
POOL_DBR pr;
int i = find_arg_with_value(ua, "job");
if (i <= 0) {
if ((job = select_job_resource(ua)) == NULL) {
return false;
}
} else {
job = (JOBRES *)GetResWithName(R_JOB, ua->argv[i]);
if (!job) {
Jmsg(ua->jcr, M_ERROR, 0, _("%s is not a job name.\n"), ua->argv[i]);
if ((job = select_job_resource(ua)) == NULL) {
return false;
}
}
}
jcr = new_jcr(sizeof(JCR), dird_free_jcr);
for (run=NULL; (run = find_next_run(run, job, runtime, ndays)); ) {
if (!complete_jcr_for_job(jcr, job, run->pool)) {
found = false;
goto get_out;
}
if (!jcr->jr.PoolId) {
ua->error_msg(_("Could not find Pool for Job %s\n"), job->name());
continue;
}
memset(&pr, 0, sizeof(pr));
pr.PoolId = jcr->jr.PoolId;
if (!db_get_pool_record(jcr, jcr->db, &pr)) {
bstrncpy(pr.Name, "*UnknownPool*", sizeof(pr.Name));
}
mr.PoolId = jcr->jr.PoolId;
get_job_storage(&store, job, run);
set_storageid_in_mr(store.store, &mr);
/* no need to set ScratchPoolId, since we use fnv_no_create_vol */
if (!find_next_volume_for_append(jcr, &mr, 1, fnv_no_create_vol, fnv_prune)) {
ua->error_msg(_("Could not find next Volume for Job %s (Pool=%s, Level=%s).\n"),
job->name(), pr.Name, level_to_str(run->level));
} else {
ua->send_msg(
_("The next Volume to be used by Job \"%s\" (Pool=%s, Level=%s) will be %s\n"),
job->name(), pr.Name, level_to_str(run->level), mr.VolumeName);
found = true;
}
}
get_out:
if (jcr->db) {
db_sql_close_pooled_connection(jcr, jcr->db);
jcr->db = NULL;
}
free_jcr(jcr);
if (!found) {
ua->error_msg(_("Could not find next Volume for Job %s.\n"),
job->hdr.name);
return false;
}
return true;
}
void catalog_request(JCR *jcr, BSOCK *bs)
{
MEDIA_DBR mr, sdmr;
JOBMEDIA_DBR jm;
char Job[MAX_NAME_LENGTH];
char pool_name[MAX_NAME_LENGTH];
int index, ok, label, writing;
POOLMEM *omsg;
POOL_DBR pr;
uint32_t Stripe, Copy;
uint64_t MediaId;
utime_t VolFirstWritten;
utime_t VolLastWritten;
memset(&sdmr, 0, sizeof(sdmr));
memset(&jm, 0, sizeof(jm));
Dsm_check(100);
/*
* Request to find next appendable Volume for this Job
*/
Dmsg1(100, "catreq %s", bs->msg);
if (!jcr->db) {
omsg = get_memory(bs->msglen+1);
pm_strcpy(omsg, bs->msg);
bs->fsend(_("1990 Invalid Catalog Request: %s"), omsg);
Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog request; DB not open: %s"), omsg);
free_memory(omsg);
return;
}
/*
* Find next appendable medium for SD
*/
if (sscanf(bs->msg, Find_media, &Job, &index, &pool_name, &mr.MediaType) == 4) {
memset(&pr, 0, sizeof(pr));
bstrncpy(pr.Name, pool_name, sizeof(pr.Name));
unbash_spaces(pr.Name);
ok = db_get_pool_record(jcr, jcr->db, &pr);
if (ok) {
mr.PoolId = pr.PoolId;
set_storageid_in_mr(jcr->res.wstore, &mr);
mr.ScratchPoolId = pr.ScratchPoolId;
ok = find_next_volume_for_append(jcr, &mr, index, fnv_create_vol, fnv_prune);
Dmsg3(050, "find_media ok=%d idx=%d vol=%s\n", ok, index, mr.VolumeName);
}
/*
* Send Find Media response to Storage daemon
*/
if (ok) {
send_volume_info_to_storage_daemon(jcr, bs, &mr);
} else {
bs->fsend(_("1901 No Media.\n"));
Dmsg0(500, "1901 No Media.\n");
}
/*
* Request to find specific Volume information
*/
} else if (sscanf(bs->msg, Get_Vol_Info, &Job, &mr.VolumeName, &writing) == 3) {
Dmsg1(100, "CatReq GetVolInfo Vol=%s\n", mr.VolumeName);
/*
* Find the Volume
*/
unbash_spaces(mr.VolumeName);
if (db_get_media_record(jcr, jcr->db, &mr)) {
const char *reason = NULL; /* detailed reason for rejection */
/*
* If we are reading, accept any volume (reason == NULL)
* If we are writing, check if the Volume is valid
* for this job, and do a recycle if necessary
*/
if (writing) {
/*
* SD wants to write this Volume, so make
* sure it is suitable for this job, i.e.
* Pool matches, and it is either Append or Recycle
* and Media Type matches and Pool allows any volume.
*/
if (mr.PoolId != jcr->jr.PoolId) {
reason = _("not in Pool");
} else if (!bstrcmp(mr.MediaType, jcr->res.wstore->media_type)) {
reason = _("not correct MediaType");
} else {
/*
* Now try recycling if necessary
* reason set non-NULL if we cannot use it
*/
check_if_volume_valid_or_recyclable(jcr, &mr, &reason);
}
}
if (!reason && mr.Enabled != 1) {
reason = _("is not Enabled");
}
if (reason == NULL) {
/*
* Send Find Media response to Storage daemon
*/
send_volume_info_to_storage_daemon(jcr, bs, &mr);
} else {
/* Not suitable volume */
bs->fsend(_("1998 Volume \"%s\" catalog status is %s, %s.\n"), mr.VolumeName,
mr.VolStatus, reason);
}
} else {
bs->fsend(_("1997 Volume \"%s\" not in catalog.\n"), mr.VolumeName);
Dmsg1(100, "1997 Volume \"%s\" not in catalog.\n", mr.VolumeName);
}
/*
* Request to update Media record. Comes typically at the end
* of a Storage daemon Job Session, when labeling/relabeling a
* Volume, or when an EOF mark is written.
*/
} else if (sscanf(bs->msg, Update_media, &Job, &sdmr.VolumeName,
&sdmr.VolJobs, &sdmr.VolFiles, &sdmr.VolBlocks, &sdmr.VolBytes,
&sdmr.VolMounts, &sdmr.VolErrors, &sdmr.VolWrites, &sdmr.MaxVolBytes,
&VolLastWritten, &sdmr.VolStatus, &sdmr.Slot, &label, &sdmr.InChanger,
&sdmr.VolReadTime, &sdmr.VolWriteTime, &VolFirstWritten) == 18) {
db_lock(jcr->db);
Dmsg3(400, "Update media %s oldStat=%s newStat=%s\n", sdmr.VolumeName,
mr.VolStatus, sdmr.VolStatus);
bstrncpy(mr.VolumeName, sdmr.VolumeName, sizeof(mr.VolumeName)); /* copy Volume name */
unbash_spaces(mr.VolumeName);
if (!db_get_media_record(jcr, jcr->db, &mr)) {
Jmsg(jcr, M_ERROR, 0, _("Unable to get Media record for Volume %s: ERR=%s\n"),
mr.VolumeName, db_strerror(jcr->db));
bs->fsend(_("1991 Catalog Request for vol=%s failed: %s"),
mr.VolumeName, db_strerror(jcr->db));
goto bail_out;
}
/* Set first written time if this is first job */
if (mr.FirstWritten == 0) {
if (VolFirstWritten == 0) {
mr.FirstWritten = jcr->start_time; /* use Job start time as first write */
} else {
mr.FirstWritten = VolFirstWritten;
}
mr.set_first_written = true;
}
/* If we just labeled the tape set time */
if (label || mr.LabelDate == 0) {
mr.LabelDate = jcr->start_time;
mr.set_label_date = true;
if (mr.InitialWrite == 0) {
mr.InitialWrite = jcr->start_time;
}
Dmsg2(400, "label=%d labeldate=%d\n", label, mr.LabelDate);
} else {
/*
* Insanity check for VolFiles get set to a smaller value
*/
if (sdmr.VolFiles < mr.VolFiles) {
Jmsg(jcr, M_FATAL, 0, _("Volume Files at %u being set to %u"
" for Volume \"%s\". This is incorrect.\n"),
mr.VolFiles, sdmr.VolFiles, mr.VolumeName);
bs->fsend(_("1992 Update Media error. VolFiles=%u, CatFiles=%u\n"),
sdmr.VolFiles, mr.VolFiles);
goto bail_out;
}
}
Dmsg2(400, "Update media: BefVolJobs=%u After=%u\n", mr.VolJobs, sdmr.VolJobs);
/*
* Check if the volume has been written by the job,
* and update the LastWritten field if needed.
*/
if (mr.VolBlocks != sdmr.VolBlocks && VolLastWritten != 0) {
mr.LastWritten = VolLastWritten;
}
/*
* Update to point to the last device used to write the Volume.
* However, do so only if we are writing the tape, i.e.
* the number of VolWrites has increased.
*/
if (jcr->res.wstore && sdmr.VolWrites > mr.VolWrites) {
Dmsg2(050, "Update StorageId old=%d new=%d\n",
mr.StorageId, jcr->res.wstore->StorageId);
/* Update StorageId after write */
set_storageid_in_mr(jcr->res.wstore, &mr);
} else {
/* Nothing written, reset same StorageId */
set_storageid_in_mr(NULL, &mr);
}
/* Copy updated values to original media record */
mr.VolJobs = sdmr.VolJobs;
mr.VolFiles = sdmr.VolFiles;
mr.VolBlocks = sdmr.VolBlocks;
mr.VolBytes = sdmr.VolBytes;
mr.VolMounts = sdmr.VolMounts;
mr.VolErrors = sdmr.VolErrors;
mr.VolWrites = sdmr.VolWrites;
mr.Slot = sdmr.Slot;
mr.InChanger = sdmr.InChanger;
bstrncpy(mr.VolStatus, sdmr.VolStatus, sizeof(mr.VolStatus));
mr.VolReadTime = sdmr.VolReadTime;
mr.VolWriteTime = sdmr.VolWriteTime;
Dmsg2(400, "db_update_media_record. Stat=%s Vol=%s\n", mr.VolStatus, mr.VolumeName);
/*
* Update the database, then before sending the response to the
* SD, check if the Volume has expired.
*/
if (!db_update_media_record(jcr, jcr->db, &mr)) {
Jmsg(jcr, M_FATAL, 0, _("Catalog error updating Media record. %s"),
db_strerror(jcr->db));
bs->fsend(_("1993 Update Media error\n"));
Dmsg0(400, "send error\n");
} else {
(void)has_volume_expired(jcr, &mr);
send_volume_info_to_storage_daemon(jcr, bs, &mr);
}
bail_out:
db_unlock(jcr->db);
Dmsg1(400, ">CatReq response: %s", bs->msg);
Dmsg1(400, "Leave catreq jcr 0x%x\n", jcr);
return;
/*
* Request to create a JobMedia record
*/
} else if (sscanf(bs->msg, Create_job_media, &Job,
&jm.FirstIndex, &jm.LastIndex, &jm.StartFile, &jm.EndFile,
&jm.StartBlock, &jm.EndBlock, &Copy, &Stripe, &MediaId) == 10) {
if (jcr->mig_jcr) {
jm.JobId = jcr->mig_jcr->JobId;
} else {
jm.JobId = jcr->JobId;
}
jm.MediaId = MediaId;
Dmsg6(400, "create_jobmedia JobId=%d MediaId=%d SF=%d EF=%d FI=%d LI=%d\n",
jm.JobId, jm.MediaId, jm.StartFile, jm.EndFile, jm.FirstIndex, jm.LastIndex);
if (!db_create_jobmedia_record(jcr, jcr->db, &jm)) {
Jmsg(jcr, M_FATAL, 0, _("Catalog error creating JobMedia record. %s"),
db_strerror(jcr->db));
bs->fsend(_("1992 Create JobMedia error\n"));
} else {
Dmsg0(400, "JobMedia record created\n");
bs->fsend(OK_create);
}
} else {
omsg = get_memory(bs->msglen+1);
pm_strcpy(omsg, bs->msg);
bs->fsend(_("1990 Invalid Catalog Request: %s"), omsg);
Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog request: %s"), omsg);
free_memory(omsg);
}
Dmsg1(400, ">CatReq response: %s", bs->msg);
Dmsg1(400, "Leave catreq jcr 0x%x\n", jcr);
return;
}
/*
* Prune at least one Volume in current Pool. This is called from
* catreq.c => next_vol.c when the Storage daemon is asking for another
* volume and no appendable volumes are available.
*
*/
void prune_volumes(JCR *jcr, bool InChanger,
MEDIA_DBR *mr, STORERES *store)
{
int i;
int count;
POOL_DBR spr;
UAContext *ua;
dbid_list ids;
struct del_ctx prune_list;
POOL_MEM query(PM_MESSAGE);
char ed1[50], ed2[100], ed3[50];
Dmsg1(100, "Prune volumes PoolId=%d\n", jcr->jr.PoolId);
if (!jcr->res.job->PruneVolumes && !jcr->res.pool->AutoPrune) {
Dmsg0(100, "AutoPrune not set in Pool.\n");
return;
}
memset(&prune_list, 0, sizeof(prune_list));
prune_list.max_ids = 10000;
prune_list.JobId = (JobId_t *)malloc(sizeof(JobId_t) * prune_list.max_ids);
ua = new_ua_context(jcr);
db_lock(jcr->db);
/* Edit PoolId */
edit_int64(mr->PoolId, ed1);
/*
* Get Pool record for Scratch Pool
*/
memset(&spr, 0, sizeof(spr));
bstrncpy(spr.Name, "Scratch", sizeof(spr.Name));
if (db_get_pool_record(jcr, jcr->db, &spr)) {
edit_int64(spr.PoolId, ed2);
bstrncat(ed2, ",", sizeof(ed2));
} else {
ed2[0] = 0;
}
if (mr->ScratchPoolId) {
edit_int64(mr->ScratchPoolId, ed3);
bstrncat(ed2, ed3, sizeof(ed2));
bstrncat(ed2, ",", sizeof(ed2));
}
Dmsg1(100, "Scratch pool(s)=%s\n", ed2);
/*
* ed2 ends up with scratch poolid and current poolid or
* just current poolid if there is no scratch pool
*/
bstrncat(ed2, ed1, sizeof(ed2));
/*
* Get the List of all media ids in the current Pool or whose
* RecyclePoolId is the current pool or the scratch pool
*/
const char *select = "SELECT DISTINCT MediaId,LastWritten FROM Media WHERE "
"(PoolId=%s OR RecyclePoolId IN (%s)) AND MediaType='%s' %s"
"ORDER BY LastWritten ASC,MediaId";
if (InChanger) {
char changer[100];
/* Ensure it is in this autochanger */
bsnprintf(changer, sizeof(changer), "AND InChanger=1 AND StorageId=%s ",
edit_int64(mr->StorageId, ed3));
Mmsg(query, select, ed1, ed2, mr->MediaType, changer);
} else {
Mmsg(query, select, ed1, ed2, mr->MediaType, "");
}
Dmsg1(100, "query=%s\n", query.c_str());
if (!db_get_query_dbids(ua->jcr, ua->db, query, ids)) {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
goto bail_out;
}
Dmsg1(100, "Volume prune num_ids=%d\n", ids.num_ids);
/* Visit each Volume and Prune it until we find one that is purged */
for (i=0; i<ids.num_ids; i++) {
MEDIA_DBR lmr;
lmr.MediaId = ids.DBId[i];
Dmsg1(100, "Get record MediaId=%d\n", (int)lmr.MediaId);
if (!db_get_media_record(jcr, jcr->db, &lmr)) {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
continue;
}
Dmsg1(100, "Examine vol=%s\n", lmr.VolumeName);
/* Don't prune archived volumes */
if (lmr.Enabled == 2) {
Dmsg1(100, "Vol=%s disabled\n", lmr.VolumeName);
continue;
}
/* Prune only Volumes with status "Full", or "Used" */
if (bstrcmp(lmr.VolStatus, "Full") ||
bstrcmp(lmr.VolStatus, "Used")) {
Dmsg2(100, "Add prune list MediaId=%d Volume %s\n", (int)lmr.MediaId, lmr.VolumeName);
count = get_prune_list_for_volume(ua, &lmr, &prune_list);
Dmsg1(100, "Num pruned = %d\n", count);
if (count != 0) {
purge_job_list_from_catalog(ua, prune_list);
prune_list.num_ids = 0; /* reset count */
}
if (!is_volume_purged(ua, &lmr)) {
Dmsg1(050, "Vol=%s not pruned\n", lmr.VolumeName);
continue;
}
Dmsg1(050, "Vol=%s is purged\n", lmr.VolumeName);
/*
* Since we are also pruning the Scratch pool, continue
* until and check if this volume is available (InChanger + StorageId)
* If not, just skip this volume and try the next one
*/
if (InChanger) {
if (!lmr.InChanger || (lmr.StorageId != mr->StorageId)) {
Dmsg1(100, "Vol=%s not inchanger or correct StoreId\n", lmr.VolumeName);
continue; /* skip this volume, ie not loadable */
}
}
if (!lmr.Recycle) {
Dmsg1(100, "Vol=%s not recyclable\n", lmr.VolumeName);
continue;
}
if (has_volume_expired(jcr, &lmr)) {
Dmsg1(100, "Vol=%s has expired\n", lmr.VolumeName);
continue; /* Volume not usable */
}
/*
* If purged and not moved to another Pool,
* then we stop pruning and take this volume.
*/
if (lmr.PoolId == mr->PoolId) {
Dmsg2(100, "Got Vol=%s MediaId=%d purged.\n", lmr.VolumeName, (int)lmr.MediaId);
mr->copy(&lmr);
set_storageid_in_mr(store, mr);
break; /* got a volume */
}
}
}
bail_out:
Dmsg0(100, "Leave prune volumes\n");
db_unlock(jcr->db);
free_ua_context(ua);
if (prune_list.JobId) {
free(prune_list.JobId);
}
return;
}
