add prune jobs api

Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com>

src/bin/proxmox-backup-manager.rs

@@ -430,6 +430,7 @@ async fn run() -> Result<(), Error> {
         .insert("subscription", subscription_commands())
         .insert("sync-job", sync_job_commands())
         .insert("verify-job", verify_job_commands())
+        .insert("prune-job", prune_job_commands())
         .insert("task", task_mgmt_cli())
         .insert(
             "pull",

src/bin/proxmox-backup-proxy.rs

@@ -47,8 +47,8 @@ use pbs_buildcfg::configdir;
 use proxmox_time::CalendarEvent;
 
 use pbs_api_types::{
-    Authid, DataStoreConfig, Operation, PruneOptions, SyncJobConfig, TapeBackupJobConfig,
-    VerificationJobConfig,
+    Authid, DataStoreConfig, KeepOptions, Operation, PruneJobConfig, PruneJobOptions,
+    SyncJobConfig, TapeBackupJobConfig, VerificationJobConfig,
 };
 
 use proxmox_rest_server::daemon;
@@ -558,6 +558,7 @@ async fn run_task_scheduler() {
 async fn schedule_tasks() -> Result<(), Error> {
     schedule_datastore_garbage_collection().await;
     schedule_datastore_prune().await;
+    schedule_datastore_prune_jobs().await;
     schedule_datastore_sync_jobs().await;
     schedule_datastore_verify_jobs().await;
     schedule_tape_backup_jobs().await;
@@ -690,16 +691,19 @@ async fn schedule_datastore_prune() {
             None => continue,
         };
 
-        let prune_options = PruneOptions {
-            keep_last: store_config.keep_last,
-            keep_hourly: store_config.keep_hourly,
-            keep_daily: store_config.keep_daily,
-            keep_weekly: store_config.keep_weekly,
-            keep_monthly: store_config.keep_monthly,
-            keep_yearly: store_config.keep_yearly,
+        let prune_options = PruneJobOptions {
+            keep: KeepOptions {
+                keep_last: store_config.keep_last,
+                keep_hourly: store_config.keep_hourly,
+                keep_daily: store_config.keep_daily,
+                keep_weekly: store_config.keep_weekly,
+                keep_monthly: store_config.keep_monthly,
+                keep_yearly: store_config.keep_yearly,
+            },
+            ..Default::default()
         };
 
-        if !pbs_datastore::prune::keeps_something(&prune_options) {
+        if !prune_options.keeps_something() {
             // no prune settings - keep all
             continue;
         }
@@ -721,6 +725,52 @@ async fn schedule_datastore_prune() {
     }
 }
 
+async fn schedule_datastore_prune_jobs() {
+    let config = match pbs_config::prune::config() {
+        Err(err) => {
+            eprintln!("unable to read prune job config - {}", err);
+            return;
+        }
+        Ok((config, _digest)) => config,
+    };
+    for (job_id, (_, job_config)) in config.sections {
+        let job_config: PruneJobConfig = match serde_json::from_value(job_config) {
+            Ok(c) => c,
+            Err(err) => {
+                eprintln!("prune job config from_value failed - {}", err);
+                continue;
+            }
+        };
+
+        if job_config.disable {
+            continue;
+        }
+
+        if !job_config.options.keeps_something() {
+            // no 'keep' values set, keep all
+            continue;
+        }
+
+        let worker_type = "prunejob";
+        let auth_id = Authid::root_auth_id().clone();
+        if check_schedule(worker_type, &job_config.schedule, &job_id) {
+            let job = match Job::new(worker_type, &job_id) {
+                Ok(job) => job,
+                Err(_) => continue, // could not get lock
+            };
+            if let Err(err) = do_prune_job(
+                job,
+                job_config.options,
+                job_config.store,
+                &auth_id,
+                Some(job_config.schedule),
+            ) {
+                eprintln!("unable to start datastore prune job {} - {}", &job_id, err);
+            }
+        };
+    }
+}
+
 async fn schedule_datastore_sync_jobs() {
     let config = match pbs_config::sync::config() {
         Err(err) => {

src/bin/proxmox_backup_manager/mod.rs

@@ -10,6 +10,8 @@ mod dns;
 pub use dns::*;
 mod network;
 pub use network::*;
+mod prune;
+pub use prune::*;
 mod remote;
 pub use remote::*;
 mod sync;

src/bin/proxmox_backup_manager/prune.rs

@@ -0,0 +1,157 @@
+use std::collections::HashMap;
+
+use anyhow::Error;
+use serde_json::Value;
+
+use proxmox_router::{cli::*, ApiHandler, RpcEnvironment};
+use proxmox_schema::api;
+
+use pbs_api_types::{PruneJobConfig, JOB_ID_SCHEMA};
+use pbs_config::prune;
+
+use proxmox_backup::api2;
+
+#[api(
+    input: {
+        properties: {
+            "output-format": {
+                schema: OUTPUT_FORMAT,
+                optional: true,
+            },
+        }
+    }
+)]
+/// List all prune jobs
+fn list_prune_jobs(param: Value, rpcenv: &mut dyn RpcEnvironment) -> Result<Value, Error> {
+    let output_format = get_output_format(&param);
+
+    let info = &api2::config::prune::API_METHOD_LIST_PRUNE_JOBS;
+    let mut data = match info.handler {
+        ApiHandler::Sync(handler) => (handler)(param, info, rpcenv)?,
+        _ => unreachable!(),
+    };
+
+    let options = default_table_format_options()
+        .column(ColumnConfig::new("id"))
+        .column(ColumnConfig::new("disable"))
+        .column(ColumnConfig::new("store"))
+        .column(ColumnConfig::new("ns"))
+        .column(ColumnConfig::new("schedule"))
+        .column(ColumnConfig::new("max-depth"))
+        .column(ColumnConfig::new("keep-last"))
+        .column(ColumnConfig::new("keep-hourly"))
+        .column(ColumnConfig::new("keep-daily"))
+        .column(ColumnConfig::new("keep-weekly"))
+        .column(ColumnConfig::new("keep-monthly"))
+        .column(ColumnConfig::new("keep-yearly"));
+
+    format_and_print_result_full(&mut data, &info.returns, &output_format, &options);
+
+    Ok(Value::Null)
+}
+
+#[api(
+    input: {
+        properties: {
+            id: {
+                schema: JOB_ID_SCHEMA,
+            },
+            "output-format": {
+                schema: OUTPUT_FORMAT,
+                optional: true,
+            },
+        }
+    }
+)]
+/// Show prune job configuration
+fn show_prune_job(param: Value, rpcenv: &mut dyn RpcEnvironment) -> Result<Value, Error> {
+    let output_format = get_output_format(&param);
+
+    let info = &api2::config::prune::API_METHOD_READ_PRUNE_JOB;
+    let mut data = match info.handler {
+        ApiHandler::Sync(handler) => (handler)(param, info, rpcenv)?,
+        _ => unreachable!(),
+    };
+
+    let options = default_table_format_options();
+    format_and_print_result_full(&mut data, &info.returns, &output_format, &options);
+
+    Ok(Value::Null)
+}
+
+pub fn prune_job_commands() -> CommandLineInterface {
+    let cmd_def = CliCommandMap::new()
+        .insert("list", CliCommand::new(&API_METHOD_LIST_PRUNE_JOBS))
+        .insert(
+            "show",
+            CliCommand::new(&API_METHOD_SHOW_PRUNE_JOB)
+                .arg_param(&["id"])
+                .completion_cb("id", pbs_config::prune::complete_prune_job_id),
+        )
+        .insert(
+            "create",
+            CliCommand::new(&api2::config::prune::API_METHOD_CREATE_PRUNE_JOB)
+                .arg_param(&["id"])
+                .completion_cb("id", pbs_config::prune::complete_prune_job_id)
+                .completion_cb("schedule", pbs_config::datastore::complete_calendar_event)
+                .completion_cb("store", pbs_config::datastore::complete_datastore_name)
+                .completion_cb("ns", complete_prune_local_datastore_namespace),
+        )
+        .insert(
+            "update",
+            CliCommand::new(&api2::config::prune::API_METHOD_UPDATE_PRUNE_JOB)
+                .arg_param(&["id"])
+                .completion_cb("id", pbs_config::prune::complete_prune_job_id)
+                .completion_cb("schedule", pbs_config::datastore::complete_calendar_event)
+                .completion_cb("store", pbs_config::datastore::complete_datastore_name)
+                .completion_cb("ns", complete_prune_local_datastore_namespace),
+        )
+        .insert(
+            "remove",
+            CliCommand::new(&api2::config::prune::API_METHOD_DELETE_PRUNE_JOB)
+                .arg_param(&["id"])
+                .completion_cb("id", pbs_config::prune::complete_prune_job_id),
+        );
+
+    cmd_def.into()
+}
+
+// shell completion helper
+fn complete_prune_local_datastore_namespace(
+    _arg: &str,
+    param: &HashMap<String, String>,
+) -> Vec<String> {
+    let mut list = Vec::new();
+    let mut rpcenv = CliEnvironment::new();
+    rpcenv.set_auth_id(Some(String::from("root@pam")));
+
+    let mut job: Option<PruneJobConfig> = None;
+
+    let store = param.get("store").map(|r| r.to_owned()).or_else(|| {
+        if let Some(id) = param.get("id") {
+            job = get_prune_job(id).ok();
+            if let Some(ref job) = job {
+                return Some(job.store.clone());
+            }
+        }
+        None
+    });
+
+    if let Some(store) = store {
+        if let Ok(data) =
+            crate::api2::admin::namespace::list_namespaces(store, None, None, &mut rpcenv)
+        {
+            for item in data {
+                list.push(item.ns.name());
+            }
+        }
+    }
+
+    list
+}
+
+fn get_prune_job(id: &str) -> Result<PruneJobConfig, Error> {
+    let (config, _digest) = prune::config()?;
+
+    config.lookup("prune", id)
+}