src/api2/admin/datastore.rs: use new WorkerTask::new_thread()

[proxmox-backup.git] / src / api2 / admin / datastore.rs

diff --git a/src/api2/admin/datastore.rs b/src/api2/admin/datastore.rs
index 404e420a0e6a13520916222110fb1a169bdaaa9b..ca7fe09cb851fc1c96c720c51758ed4734d26f78 100644 (file)
--- a/src/api2/admin/datastore.rs
+++ b/src/api2/admin/datastore.rs
@@ -16,8 +16,10 @@ use std::sync::Arc;
 use crate::config::datastore;
 
 use crate::backup::*;
+use crate::server::WorkerTask;
 
-mod catar;
+mod pxar;
+mod upload;
 
 fn group_backups(backup_list: Vec<BackupInfo>) -> HashMap<String, Vec<BackupInfo>> {
 
@@ -87,6 +89,26 @@ fn list_groups(
     Ok(json!(groups))
 }
 
+fn list_snapshot_files (
+    param: Value,
+    _info: &ApiMethod,
+    _rpcenv: &mut RpcEnvironment,
+) -> Result<Value, Error> {
+
+    let store = tools::required_string_param(&param, "store")?;
+    let backup_type = tools::required_string_param(&param, "backup-type")?;
+    let backup_id = tools::required_string_param(&param, "backup-id")?;
+    let backup_time = tools::required_integer_param(&param, "backup-time")?;
+
+    let snapshot = BackupDir::new(backup_type, backup_id, backup_time);
+
+    let datastore = DataStore::lookup_datastore(store)?;
+
+    let files = datastore.list_files(&snapshot)?;
+
+    Ok(json!(files))
+}
+
 fn delete_snapshots (
     param: Value,
     _info: &ApiMethod,
@@ -261,22 +283,28 @@ fn api_method_prune() -> ApiMethod {
     )
 }
 
-// this is just a test for mutability/mutex handling  - will remove later
 fn start_garbage_collection(
     param: Value,
     _info: &ApiMethod,
-    _rpcenv: &mut RpcEnvironment,
+    rpcenv: &mut RpcEnvironment,
 ) -> Result<Value, Error> {
 
-    let store = param["store"].as_str().unwrap();
+    let store = param["store"].as_str().unwrap().to_string();
 
-    let datastore = DataStore::lookup_datastore(store)?;
+    let datastore = DataStore::lookup_datastore(&store)?;
 
     println!("Starting garbage collection on store {}", store);
 
-    datastore.garbage_collection()?;
+    let to_stdout = if rpcenv.env_type() == RpcEnvironmentType::CLI { true } else { false };
 
-    Ok(json!(null))
+    let upid_str = WorkerTask::new_thread(
+        "garbage_collection", Some(store.clone()), "root@pam", to_stdout, move |worker|
+        {
+            worker.log(format!("starting garbage collection on store {}", store));
+            datastore.garbage_collection()
+        })?;
+
+    Ok(json!(upid_str))
 }
 
 pub fn api_method_start_garbage_collection() -> ApiMethod {
@@ -359,7 +387,7 @@ pub fn router() -> Router {
         .get(ApiMethod::new(
             |_,_,_| Ok(json!([
                 {"subdir": "backups" },
-                {"subdir": "catar" },
+                {"subdir": "pxar" },
                 {"subdir": "gc" },
                 {"subdir": "groups" },
                 {"subdir": "snapshots" },
@@ -377,15 +405,34 @@ pub fn router() -> Router {
                     ObjectSchema::new("List backups.")
                         .required("store", store_schema.clone()))))
         .subdir(
-            "catar",
+            "pxar",
             Router::new()
-                .download(catar::api_method_download_catar())
-                .upload(catar::api_method_upload_catar()))
+                .download(pxar::api_method_download_pxar())
+                .upload(pxar::api_method_upload_pxar()))
+        .subdir(
+            "test-upload",
+            Router::new()
+                .upgrade(upload::api_method_upgrade_upload()))
         .subdir(
             "gc",
             Router::new()
                 .get(api_method_garbage_collection_status())
                 .post(api_method_start_garbage_collection()))
+        .subdir(
+            "files",
+            Router::new()
+                .get(
+                    ApiMethod::new(
+                        list_snapshot_files,
+                        ObjectSchema::new("List snapshot files.")
+                            .required("store", store_schema.clone())
+                            .required("backup-type", StringSchema::new("Backup type."))
+                            .required("backup-id", StringSchema::new("Backup ID."))
+                            .required("backup-time", IntegerSchema::new("Backup time (Unix epoch.)")
+                                      .minimum(1547797308))
+                    )
+                )
+        )
         .subdir(
             "groups",
             Router::new()