src/bin/proxmox_tape/changer.rs

   1 use anyhow::{Error};
   2 use serde_json::Value;
   3
   4 use proxmox::{
   5     api::{
   6         api,
   7         cli::*,
   8         RpcEnvironment,
   9         ApiHandler,
  10     },
  11 };
  12
  13 use proxmox_backup::{
  14     api2::{
  15         self,
  16         types::{
  17             CHANGER_NAME_SCHEMA,
  18         },
  19     },
  20     tape::{
  21         complete_changer_path,
  22     },
  23     config::{
  24         drive::{
  25             complete_drive_name,
  26             complete_changer_name,
  27         }
  28     },
  29 };
  30
  31 pub fn changer_commands() -> CommandLineInterface {
  32
  33     let cmd_def = CliCommandMap::new()
  34         .insert("scan", CliCommand::new(&API_METHOD_SCAN_FOR_CHANGERS))
  35         .insert("list", CliCommand::new(&API_METHOD_LIST_CHANGERS))
  36         .insert("config",
  37                 CliCommand::new(&API_METHOD_GET_CONFIG)
  38                 .arg_param(&["name"])
  39                 .completion_cb("name", complete_changer_name)
  40         )
  41         .insert(
  42             "remove",
  43             CliCommand::new(&api2::config::changer::API_METHOD_DELETE_CHANGER)
  44                 .arg_param(&["name"])
  45                 .completion_cb("name", complete_changer_name)
  46         )
  47         .insert(
  48             "create",
  49             CliCommand::new(&api2::config::changer::API_METHOD_CREATE_CHANGER)
  50                 .arg_param(&["name"])
  51                 .completion_cb("name", complete_drive_name)
  52                 .completion_cb("path", complete_changer_path)
  53         )
  54         .insert(
  55             "update",
  56             CliCommand::new(&api2::config::changer::API_METHOD_UPDATE_CHANGER)
  57                 .arg_param(&["name"])
  58                 .completion_cb("name", complete_changer_name)
  59                 .completion_cb("path", complete_changer_path)
  60         )
  61         .insert("status",
  62                 CliCommand::new(&API_METHOD_GET_STATUS)
  63                 .arg_param(&["name"])
  64                 .completion_cb("name", complete_changer_name)
  65         )
  66         .insert("transfer",
  67                 CliCommand::new(&api2::tape::changer::API_METHOD_TRANSFER)
  68                 .arg_param(&["name"])
  69                 .completion_cb("name", complete_changer_name)
  70         )
  71         ;
  72
  73     cmd_def.into()
  74 }
  75
  76 #[api(
  77     input: {
  78         properties: {
  79             "output-format": {
  80                 schema: OUTPUT_FORMAT,
  81                 optional: true,
  82             },
  83         },
  84     },
  85 )]
  86 /// List changers
  87 fn list_changers(
  88     param: Value,
  89     rpcenv: &mut dyn RpcEnvironment,
  90 ) -> Result<(), Error> {
  91
  92     let output_format = get_output_format(&param);
  93     let info = &api2::config::changer::API_METHOD_LIST_CHANGERS;
  94     let mut data = match info.handler {
  95         ApiHandler::Sync(handler) => (handler)(param, info, rpcenv)?,
  96         _ => unreachable!(),
  97     };
  98
  99     let options = default_table_format_options()
 100         .column(ColumnConfig::new("name"))
 101         .column(ColumnConfig::new("path"))
 102         .column(ColumnConfig::new("vendor"))
 103         .column(ColumnConfig::new("model"))
 104         .column(ColumnConfig::new("serial"))
 105         ;
 106
 107     format_and_print_result_full(&mut data, &info.returns, &output_format, &options);
 108
 109     Ok(())
 110 }
 111
 112 #[api(
 113     input: {
 114         properties: {
 115             "output-format": {
 116                 schema: OUTPUT_FORMAT,
 117                 optional: true,
 118             },
 119         },
 120     },
 121 )]
 122 /// Scan for SCSI tape changers
 123 fn scan_for_changers(
 124     param: Value,
 125     rpcenv: &mut dyn RpcEnvironment,
 126 ) -> Result<(), Error> {
 127
 128     let output_format = get_output_format(&param);
 129     let info = &api2::tape::changer::API_METHOD_SCAN_CHANGERS;
 130     let mut data = match info.handler {
 131         ApiHandler::Sync(handler) => (handler)(param, info, rpcenv)?,
 132         _ => unreachable!(),
 133     };
 134
 135     let options = default_table_format_options()
 136         .column(ColumnConfig::new("path"))
 137         .column(ColumnConfig::new("vendor"))
 138         .column(ColumnConfig::new("model"))
 139         .column(ColumnConfig::new("serial"))
 140         ;
 141
 142     format_and_print_result_full(&mut data, &info.returns, &output_format, &options);
 143
 144     Ok(())
 145 }
 146
 147 #[api(
 148     input: {
 149         properties: {
 150             "output-format": {
 151                 schema: OUTPUT_FORMAT,
 152                 optional: true,
 153             },
 154             name: {
 155                 schema: CHANGER_NAME_SCHEMA,
 156             },
 157         },
 158     },
 159 )]
 160 /// Get tape changer configuration
 161 fn get_config(
 162     param: Value,
 163     rpcenv: &mut dyn RpcEnvironment,
 164 ) -> Result<(), Error> {
 165
 166     let output_format = get_output_format(&param);
 167     let info = &api2::config::changer::API_METHOD_GET_CONFIG;
 168     let mut data = match info.handler {
 169         ApiHandler::Sync(handler) => (handler)(param, info, rpcenv)?,
 170         _ => unreachable!(),
 171     };
 172
 173     let options = default_table_format_options()
 174         .column(ColumnConfig::new("name"))
 175         .column(ColumnConfig::new("path"))
 176         ;
 177
 178     format_and_print_result_full(&mut data, &info.returns, &output_format, &options);
 179
 180     Ok(())
 181 }
 182
 183 #[api(
 184     input: {
 185         properties: {
 186             "output-format": {
 187                 schema: OUTPUT_FORMAT,
 188                 optional: true,
 189             },
 190              name: {
 191                 schema: CHANGER_NAME_SCHEMA,
 192             },
 193         },
 194     },
 195 )]
 196 /// Get tape changer status
 197 async fn get_status(
 198     param: Value,
 199     rpcenv: &mut dyn RpcEnvironment,
 200 ) -> Result<(), Error> {
 201
 202     let output_format = get_output_format(&param);
 203     let info = &api2::tape::changer::API_METHOD_GET_STATUS;
 204     let mut data = match info.handler {
 205         ApiHandler::Async(handler) => (handler)(param, info, rpcenv).await?,
 206         _ => unreachable!(),
 207     };
 208
 209     let options = default_table_format_options()
 210         .column(ColumnConfig::new("entry-kind"))
 211         .column(ColumnConfig::new("entry-id"))
 212         .column(ColumnConfig::new("changer-id"))
 213         .column(ColumnConfig::new("loaded-slot"))
 214         ;
 215
 216     format_and_print_result_full(&mut data, &info.returns, &output_format, &options);
 217
 218     Ok(())
 219 }