/*
* Prune a given Volume
*/
bool prune_volume(UAContext *ua, MEDIA_DBR *mr)
{
POOL_MEM query(PM_MESSAGE);
struct del_ctx del;
bool ok = false;
int count;
if (mr->Enabled == 2) {
return false; /* Cannot prune archived volumes */
}
memset(&del, 0, sizeof(del));
del.max_ids = 10000;
del.JobId = (JobId_t *)malloc(sizeof(JobId_t) * del.max_ids);
db_lock(ua->db);
/* Prune only Volumes with status "Full", or "Used" */
if (strcmp(mr->VolStatus, "Full") == 0 ||
strcmp(mr->VolStatus, "Used") == 0) {
Dmsg2(050, "get prune list MediaId=%d Volume %s\n", (int)mr->MediaId, mr->VolumeName);
count = get_prune_list_for_volume(ua, mr, &del);
Dmsg1(050, "Num pruned = %d\n", count);
if (count != 0) {
purge_job_list_from_catalog(ua, del);
}
ok = is_volume_purged(ua, mr);
}
db_unlock(ua->db);
if (del.JobId) {
free(del.JobId);
}
return ok;
}
/*
* Purge Job records from the database. For any Job which
* is older than the retention period, we unconditionally delete
* it and all File records for that Job. This is simple enough that no
* temporary tables are needed. We simply make an in memory list of
* the JobIds then delete the Job, Files, and JobMedia records in that list.
*/
static int purge_jobs_from_client(UAContext *ua, CLIENTRES *client)
{
struct del_ctx del;
POOL_MEM query(PM_MESSAGE);
CLIENT_DBR cr;
char ed1[50];
memset(&cr, 0, sizeof(cr));
bstrncpy(cr.Name, client->name(), sizeof(cr.Name));
if (!db_create_client_record(ua->jcr, ua->db, &cr)) {
return 0;
}
memset(&del, 0, sizeof(del));
del.max_ids = 1000;
del.JobId = (JobId_t *)malloc(sizeof(JobId_t) * del.max_ids);
del.PurgedFiles = (char *)malloc(del.max_ids);
ua->info_msg(_("Begin purging jobs from Client \"%s\"\n"), cr.Name);
Mmsg(query, select_jobs_from_client, edit_int64(cr.ClientId, ed1));
Dmsg1(150, "select sql=%s\n", query.c_str());
db_sql_query(ua->db, query.c_str(), job_delete_handler, (void *)&del);
purge_job_list_from_catalog(ua, del);
if (del.num_ids == 0) {
ua->warning_msg(_("No Files found for client %s to purge from %s catalog.\n"),
client->name(), client->catalog->name());
} else {
ua->info_msg(_("%d Jobs for client %s purged from %s catalog.\n"), del.num_ids,
client->name(), client->catalog->name());
}
if (del.JobId) {
free(del.JobId);
}
if (del.PurgedFiles) {
free(del.PurgedFiles);
}
return 1;
}
/*
* 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, CLIENT *client, int JobType)
{
struct del_ctx del;
POOL_MEM query(PM_MESSAGE);
utime_t now, period;
CLIENT_DBR cr;
char ed1[50], ed2[50];
db_lock(ua->db);
memset(&cr, 0, sizeof(cr));
memset(&del, 0, sizeof(del));
bstrncpy(cr.Name, client->name(), sizeof(cr.Name));
if (!db_create_client_record(ua->jcr, ua->db, &cr)) {
db_unlock(ua->db);
return 0;
}
period = client->JobRetention;
now = (utime_t)time(NULL);
/* Drop any previous temporary tables still there */
drop_temp_tables(ua);
/* Create temp tables and indicies */
if (!create_temp_tables(ua)) {
goto bail_out;
}
/*
* Select all files that are older than the JobRetention period
* and stuff them into the "DeletionCandidates" table.
*/
edit_int64(now - period, ed1);
Mmsg(query, insert_delcand, (char)JobType, ed1,
edit_int64(cr.ClientId, ed2));
if (!db_sql_query(ua->db, query.c_str(), NULL, (void *)NULL)) {
if (ua->verbose) {
ua->error_msg("%s", db_strerror(ua->db));
}
Dmsg0(050, "insert delcand failed\n");
goto bail_out;
}
del.max_ids = 100;
del.JobId = (JobId_t *)malloc(sizeof(JobId_t) * del.max_ids);
del.PurgedFiles = (char *)malloc(del.max_ids);
/* ed1 = JobTDate */
edit_int64(cr.ClientId, ed2);
switch (JobType) {
case JT_BACKUP:
Mmsg(query, select_backup_del, ed1, ed2);
break;
case JT_RESTORE:
Mmsg(query, select_restore_del, ed1, ed2);
break;
case JT_VERIFY:
Mmsg(query, select_verify_del, ed1, ed2);
break;
case JT_ADMIN:
Mmsg(query, select_admin_del, ed1, ed2);
break;
case JT_COPY:
Mmsg(query, select_copy_del, ed1, ed2);
break;
case JT_MIGRATE:
Mmsg(query, select_migrate_del, ed1, ed2);
break;
}
Dmsg1(150, "Query=%s\n", query.c_str());
if (!db_sql_query(ua->db, query.c_str(), job_delete_handler, (void *)&del)) {
ua->error_msg("%s", db_strerror(ua->db));
}
purge_job_list_from_catalog(ua, del);
if (del.num_del > 0) {
ua->info_msg(_("Pruned %d %s for client %s from catalog.\n"), del.num_del,
del.num_del==1?_("Job"):_("Jobs"), client->name());
} else if (ua->verbose) {
ua->info_msg(_("No Jobs found to prune.\n"));
}
bail_out:
drop_temp_tables(ua);
db_unlock(ua->db);
if (del.JobId) {
free(del.JobId);
}
if (del.PurgedFiles) {
free(del.PurgedFiles);
}
return 1;
}
/*
* 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;
}
