src/catar/encoder.rs: add verbose flags

[proxmox-backup.git] / src / bin / proxmox-backup-client.rs

diff --git a/src/bin/proxmox-backup-client.rs b/src/bin/proxmox-backup-client.rs
index 2ffcb935ce8740c478e0232d922ba9a20a224fe8..dec64f1ef5c8242c9e802fed6978da9b24b6ca19 100644 (file)
--- a/src/bin/proxmox-backup-client.rs
+++ b/src/bin/proxmox-backup-client.rs
@@ -35,25 +35,25 @@ fn backup_directory<P: AsRef<Path>>(
     archive_name: &str,
     backup_time: DateTime<Utc>,
     chunk_size: Option<u64>,
+    verbose: bool,
 ) -> Result<(), Error> {
 
-    let mut query = url::form_urlencoded::Serializer::new(String::new());
-
-    query
-        .append_pair("archive-name", archive_name)
-        .append_pair("type", "host")
-        .append_pair("id", &tools::nodename())
-        .append_pair("time", &backup_time.timestamp().to_string());
+    let mut param = json!({
+        "archive-name": archive_name,
+        "backup-type": "host",
+        "backup-id": &tools::nodename(),
+        "backup-time": backup_time.timestamp(),
+    });
 
     if let Some(size) = chunk_size {
-        query.append_pair("chunk-size", &size.to_string());
+        param["chunk-size"] = size.into();
     }
 
-    let query = query.finish();
+    let query = tools::json_object_to_query(param)?;
 
     let path = format!("api2/json/admin/datastore/{}/catar?{}", repo.store, query);
 
-    let stream = CaTarBackupStream::open(dir_path.as_ref())?;
+    let stream = CaTarBackupStream::open(dir_path.as_ref(), verbose)?;
 
     let body = Body::wrap_stream(stream);
 
@@ -236,6 +236,33 @@ fn list_snapshots(
     Ok(Value::Null)
 }
 
+fn forget_snapshots(
+    param: Value,
+    _info: &ApiMethod,
+    _rpcenv: &mut RpcEnvironment,
+) -> Result<Value, Error> {
+
+    let repo_url = tools::required_string_param(&param, "repository")?;
+    let repo = BackupRepository::parse(repo_url)?;
+
+    let path = tools::required_string_param(&param, "snapshot")?;
+    let snapshot = BackupDir::parse(path)?;
+
+    let query = tools::json_object_to_query(json!({
+        "backup-type": &snapshot.group.backup_type,
+        "backup-id": &snapshot.group.backup_id,
+        "backup-time": snapshot.backup_time.timestamp(),
+    }))?;
+
+    let mut client = HttpClient::new(&repo.host, &repo.user);
+
+    let path = format!("api2/json/admin/datastore/{}/snapshots?{}", repo.store, query);
+
+    let result = client.delete(&path)?;
+
+    Ok(result)
+}
+
 fn start_garbage_collection(
     param: Value,
     _info: &ApiMethod,
@@ -274,6 +301,8 @@ fn create_backup(
 
     let repo = BackupRepository::parse(repo_url)?;
 
+    let verbose = param["verbose"].as_bool().unwrap_or(false);
+
     let chunk_size_opt = param["chunk-size"].as_u64().map(|v| v*1024);
 
     if let Some(size) = chunk_size_opt {
@@ -328,7 +357,7 @@ fn create_backup(
 
     for (filename, target) in upload_list {
         flog!(log, "Upload '{}' to '{:?}' as {}", filename, repo, target);
-        backup_directory(&mut client, &repo, &filename, &target, backup_time, chunk_size_opt)?;
+        backup_directory(&mut client, &repo, &filename, &target, backup_time, chunk_size_opt, verbose)?;
     }
 
     flog!(log, "Upload backup log");
@@ -394,10 +423,10 @@ fn main() {
             .into()
     );
 
-    let create_cmd_def = CliCommand::new(
+    let backup_cmd_def = CliCommand::new(
         ApiMethod::new(
             create_backup,
-            ObjectSchema::new("Create backup.")
+            ObjectSchema::new("Create (host) backup.")
                 .required("repository", repo_url_schema.clone())
                 .required(
                     "backupspec",
@@ -406,6 +435,9 @@ fn main() {
                         backup_source_schema,
                     ).min_length(1)
                 )
+                .optional(
+                    "verbose",
+                    BooleanSchema::new("Verbose output.").default(false))
                 .optional(
                     "chunk-size",
                     IntegerSchema::new("Chunk size in KB. Must be a power of 2.")
@@ -434,6 +466,15 @@ fn main() {
         ))
         .arg_param(vec!["repository", "group"]);
 
+    let forget_cmd_def = CliCommand::new(
+        ApiMethod::new(
+            forget_snapshots,
+            ObjectSchema::new("Forget (remove) backup snapshots.")
+                .required("repository", repo_url_schema.clone())
+                .required("snapshot", StringSchema::new("Snapshot path."))
+        ))
+        .arg_param(vec!["repository", "snapshot"]);
+
     let garbage_collect_cmd_def = CliCommand::new(
         ApiMethod::new(
             start_garbage_collection,
@@ -452,7 +493,8 @@ fn main() {
         ))
         .arg_param(vec!["repository"]);
     let cmd_def = CliCommandMap::new()
-        .insert("create".to_owned(), create_cmd_def.into())
+        .insert("backup".to_owned(), backup_cmd_def.into())
+        .insert("forget".to_owned(), forget_cmd_def.into())
         .insert("garbage-collect".to_owned(), garbage_collect_cmd_def.into())
         .insert("list".to_owned(), list_cmd_def.into())
         .insert("prune".to_owned(), prune_cmd_def.into())