src/bin/proxmox_backup_client/task.rs

   1 use anyhow::{Error};
   2 use serde_json::{json, Value};
   3
   4 use proxmox::api::{api, cli::*};
   5
   6 use pbs_client::display_task_log;
   7 use pbs_tools::percent_encoding::percent_encode_component;
   8 use pbs_tools::json::required_string_param;
   9
  10 use pbs_api_types::UPID;
  11
  12 use crate::{
  13     REPO_URL_SCHEMA,
  14     extract_repository_from_value,
  15     complete_repository,
  16     connect,
  17 };
  18
  19 #[api(
  20     input: {
  21         properties: {
  22             repository: {
  23                 schema: REPO_URL_SCHEMA,
  24                 optional: true,
  25             },
  26             limit: {
  27                 description: "The maximal number of tasks to list.",
  28                 type: Integer,
  29                 optional: true,
  30                 minimum: 1,
  31                 maximum: 1000,
  32                 default: 50,
  33             },
  34             "output-format": {
  35                 schema: OUTPUT_FORMAT,
  36                 optional: true,
  37             },
  38             all: {
  39                 type: Boolean,
  40                 description: "Also list stopped tasks.",
  41                 optional: true,
  42             },
  43         }
  44     }
  45 )]
  46 /// List running server tasks for this repo user
  47 async fn task_list(param: Value) -> Result<Value, Error> {
  48
  49     let output_format = get_output_format(&param);
  50
  51     let repo = extract_repository_from_value(&param)?;
  52     let client = connect(&repo)?;
  53
  54     let limit = param["limit"].as_u64().unwrap_or(50) as usize;
  55     let running = !param["all"].as_bool().unwrap_or(false);
  56
  57     let args = json!({
  58         "running": running,
  59         "start": 0,
  60         "limit": limit,
  61         "userfilter": repo.auth_id(),
  62         "store": repo.store(),
  63     });
  64
  65     let mut result = client.get("api2/json/nodes/localhost/tasks", Some(args)).await?;
  66     let mut data = result["data"].take();
  67
  68     let return_type = &proxmox_backup::api2::node::tasks::API_METHOD_LIST_TASKS.returns;
  69
  70     use pbs_tools::format::{render_epoch, render_task_status};
  71     let options = default_table_format_options()
  72         .column(ColumnConfig::new("starttime").right_align(false).renderer(render_epoch))
  73         .column(ColumnConfig::new("endtime").right_align(false).renderer(render_epoch))
  74         .column(ColumnConfig::new("upid"))
  75         .column(ColumnConfig::new("status").renderer(render_task_status));
  76
  77     format_and_print_result_full(&mut data, return_type, &output_format, &options);
  78
  79     Ok(Value::Null)
  80 }
  81
  82 #[api(
  83     input: {
  84         properties: {
  85             repository: {
  86                 schema: REPO_URL_SCHEMA,
  87                 optional: true,
  88             },
  89             upid: {
  90                 type: UPID,
  91             },
  92         }
  93     }
  94 )]
  95 /// Display the task log.
  96 async fn task_log(param: Value) -> Result<Value, Error> {
  97
  98     let repo = extract_repository_from_value(&param)?;
  99     let upid =  required_string_param(&param, "upid")?;
 100
 101     let mut client = connect(&repo)?;
 102
 103     display_task_log(&mut client, upid, true).await?;
 104
 105     Ok(Value::Null)
 106 }
 107
 108 #[api(
 109     input: {
 110         properties: {
 111             repository: {
 112                 schema: REPO_URL_SCHEMA,
 113                 optional: true,
 114             },
 115             upid: {
 116                 type: UPID,
 117             },
 118         }
 119     }
 120 )]
 121 /// Try to stop a specific task.
 122 async fn task_stop(param: Value) -> Result<Value, Error> {
 123
 124     let repo = extract_repository_from_value(&param)?;
 125     let upid_str =  required_string_param(&param, "upid")?;
 126
 127     let mut client = connect(&repo)?;
 128
 129     let path = format!("api2/json/nodes/localhost/tasks/{}", percent_encode_component(upid_str));
 130     let _ = client.delete(&path, None).await?;
 131
 132     Ok(Value::Null)
 133 }
 134
 135 pub fn task_mgmt_cli() -> CliCommandMap {
 136
 137     let task_list_cmd_def = CliCommand::new(&API_METHOD_TASK_LIST)
 138         .completion_cb("repository", complete_repository);
 139
 140     let task_log_cmd_def = CliCommand::new(&API_METHOD_TASK_LOG)
 141         .arg_param(&["upid"]);
 142
 143     let task_stop_cmd_def = CliCommand::new(&API_METHOD_TASK_STOP)
 144         .arg_param(&["upid"]);
 145
 146     CliCommandMap::new()
 147         .insert("log", task_log_cmd_def)
 148         .insert("list", task_list_cmd_def)
 149         .insert("stop", task_stop_cmd_def)
 150 }