src/bin/proxmox-backup-client.rs

   1 extern crate proxmox_backup;
   2
   3 use failure::*;
   4 //use std::os::unix::io::AsRawFd;
   5 use chrono::{DateTime, Local, TimeZone};
   6 use std::path::{Path, PathBuf};
   7 use std::collections::HashMap;
   8
   9 use proxmox_backup::tools;
  10 use proxmox_backup::cli::*;
  11 use proxmox_backup::api_schema::*;
  12 use proxmox_backup::api_schema::router::*;
  13 use proxmox_backup::client::*;
  14 use proxmox_backup::backup::*;
  15 //use proxmox_backup::backup::image_index::*;
  16 //use proxmox_backup::config::datastore;
  17 //use proxmox_backup::catar::encoder::*;
  18 //use proxmox_backup::backup::datastore::*;
  19
  20 use serde_json::{json, Value};
  21 use hyper::Body;
  22 use std::sync::Arc;
  23 use regex::Regex;
  24 use xdg::BaseDirectories;
  25
  26 use lazy_static::lazy_static;
  27
  28 lazy_static! {
  29     static ref BACKUPSPEC_REGEX: Regex = Regex::new(r"^([a-zA-Z0-9_-]+\.(?:catar|raw)):(.+)$").unwrap();
  30 }
  31
  32
  33 fn record_repository(repo: &BackupRepository) {
  34
  35     let base = match BaseDirectories::with_prefix("proxmox-backup") {
  36         Ok(v) => v,
  37         _ => return,
  38     };
  39
  40     // usually $HOME/.cache/proxmox-backup/repo-list
  41     let path = match base.place_cache_file("repo-list") {
  42         Ok(v) => v,
  43         _ => return,
  44     };
  45
  46     let mut data = tools::file_get_json(&path).unwrap_or(json!({}));
  47
  48     let repo = repo.to_string();
  49
  50     data[&repo] = json!{ data[&repo].as_i64().unwrap_or(0) + 1 };
  51
  52     let mut map = serde_json::map::Map::new();
  53
  54     loop {
  55         let mut max_used = 0;
  56         let mut max_repo = None;
  57         for (repo, count) in data.as_object().unwrap() {
  58             if map.contains_key(repo) { continue; }
  59             if let Some(count) = count.as_i64() {
  60                 if count > max_used {
  61                     max_used = count;
  62                     max_repo = Some(repo);
  63                 }
  64             }
  65         }
  66         if let Some(repo) = max_repo {
  67             map.insert(repo.to_owned(), json!(max_used));
  68         } else {
  69             break;
  70         }
  71         if map.len() > 10 { // store max. 10 repos
  72             break;
  73         }
  74     }
  75
  76     let new_data = json!(map);
  77
  78     let _ = tools::file_set_contents(path, new_data.to_string().as_bytes(), None);
  79 }
  80
  81 fn complete_repository(_arg: &str, _param: &HashMap<String, String>) -> Vec<String> {
  82
  83     let mut result = vec![];
  84
  85     let base = match BaseDirectories::with_prefix("proxmox-backup") {
  86         Ok(v) => v,
  87         _ => return result,
  88     };
  89
  90     // usually $HOME/.cache/proxmox-backup/repo-list
  91     let path = match base.place_cache_file("repo-list") {
  92         Ok(v) => v,
  93         _ => return result,
  94     };
  95
  96     let data = tools::file_get_json(&path).unwrap_or(json!({}));
  97
  98     if let Some(map) = data.as_object() {
  99         for (repo, _count) in map {
 100             result.push(repo.to_owned());
 101         }
 102     }
 103
 104     result
 105 }
 106
 107 fn backup_directory<P: AsRef<Path>>(
 108     client: &mut HttpClient,
 109     repo: &BackupRepository,
 110     dir_path: P,
 111     archive_name: &str,
 112     backup_id: &str,
 113     backup_time: DateTime<Local>,
 114     chunk_size: Option<u64>,
 115     all_file_systems: bool,
 116     verbose: bool,
 117 ) -> Result<(), Error> {
 118
 119     let mut param = json!({
 120         "archive-name": archive_name,
 121         "backup-type": "host",
 122         "backup-id": backup_id,
 123         "backup-time": backup_time.timestamp(),
 124     });
 125
 126     if let Some(size) = chunk_size {
 127         param["chunk-size"] = size.into();
 128     }
 129
 130     let query = tools::json_object_to_query(param)?;
 131
 132     let path = format!("api2/json/admin/datastore/{}/catar?{}", repo.store(), query);
 133
 134     let stream = CaTarBackupStream::open(dir_path.as_ref(), all_file_systems, verbose)?;
 135
 136     let body = Body::wrap_stream(stream);
 137
 138     client.upload("application/x-proxmox-backup-catar", body, &path)?;
 139
 140     Ok(())
 141 }
 142
 143 /****
 144 fn backup_image(datastore: &DataStore, file: &std::fs::File, size: usize, target: &str, chunk_size: usize) -> Result<(), Error> {
 145
 146     let mut target = PathBuf::from(target);
 147
 148     if let Some(ext) = target.extension() {
 149         if ext != "fidx" {
 150             bail!("got wrong file extension - expected '.fidx'");
 151         }
 152     } else {
 153         target.set_extension("fidx");
 154     }
 155
 156     let mut index = datastore.create_image_writer(&target, size, chunk_size)?;
 157
 158     tools::file_chunker(file, chunk_size, |pos, chunk| {
 159         index.add_chunk(pos, chunk)?;
 160         Ok(true)
 161     })?;
 162
 163     index.close()?; // commit changes
 164
 165     Ok(())
 166 }
 167 */
 168
 169 fn strip_chunked_file_expenstions(list: Vec<String>) -> Vec<String> {
 170
 171     let mut result = vec![];
 172
 173     for file in list.into_iter() {
 174         if file.ends_with(".didx") {
 175             result.push(file[..file.len()-5].to_owned());
 176         } else if file.ends_with(".fidx") {
 177             result.push(file[..file.len()-5].to_owned());
 178         } else {
 179             result.push(file); // should not happen
 180         }
 181     }
 182
 183     result
 184 }
 185
 186 fn list_backups(
 187     param: Value,
 188     _info: &ApiMethod,
 189     _rpcenv: &mut RpcEnvironment,
 190 ) -> Result<Value, Error> {
 191
 192     let repo_url = tools::required_string_param(&param, "repository")?;
 193     let repo: BackupRepository = repo_url.parse()?;
 194
 195     let mut client = HttpClient::new(repo.host(), repo.user());
 196
 197     let path = format!("api2/json/admin/datastore/{}/backups", repo.store());
 198
 199     let result = client.get(&path)?;
 200
 201     record_repository(&repo);
 202
 203     // fixme: implement and use output formatter instead ..
 204     let list = result["data"].as_array().unwrap();
 205
 206     for item in list {
 207
 208         let id = item["backup-id"].as_str().unwrap();
 209         let btype = item["backup-type"].as_str().unwrap();
 210         let epoch = item["backup-time"].as_i64().unwrap();
 211
 212         let backup_dir = BackupDir::new(btype, id, epoch);
 213
 214         let files = item["files"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_owned()).collect();
 215         let files = strip_chunked_file_expenstions(files);
 216
 217         for filename in files {
 218             let path = backup_dir.relative_path().to_str().unwrap().to_owned();
 219             println!("{} | {}/{}", backup_dir.backup_time().format("%c"), path, filename);
 220         }
 221     }
 222
 223     //Ok(result)
 224     Ok(Value::Null)
 225 }
 226
 227 fn list_backup_groups(
 228     param: Value,
 229     _info: &ApiMethod,
 230     _rpcenv: &mut RpcEnvironment,
 231 ) -> Result<Value, Error> {
 232
 233     let repo_url = tools::required_string_param(&param, "repository")?;
 234     let repo: BackupRepository = repo_url.parse()?;
 235
 236     let mut client = HttpClient::new(repo.host(), repo.user());
 237
 238     let path = format!("api2/json/admin/datastore/{}/groups", repo.store());
 239
 240     let mut result = client.get(&path)?;
 241
 242     record_repository(&repo);
 243
 244     // fixme: implement and use output formatter instead ..
 245     let list = result["data"].as_array_mut().unwrap();
 246
 247     list.sort_unstable_by(|a, b| {
 248         let a_id = a["backup-id"].as_str().unwrap();
 249         let a_backup_type = a["backup-type"].as_str().unwrap();
 250         let b_id = b["backup-id"].as_str().unwrap();
 251         let b_backup_type = b["backup-type"].as_str().unwrap();
 252
 253         let type_order = a_backup_type.cmp(b_backup_type);
 254         if type_order == std::cmp::Ordering::Equal {
 255             a_id.cmp(b_id)
 256         } else {
 257             type_order
 258         }
 259     });
 260
 261     for item in list {
 262
 263         let id = item["backup-id"].as_str().unwrap();
 264         let btype = item["backup-type"].as_str().unwrap();
 265         let epoch = item["last-backup"].as_i64().unwrap();
 266         let last_backup = Local.timestamp(epoch, 0);
 267         let backup_count = item["backup-count"].as_u64().unwrap();
 268
 269         let group = BackupGroup::new(btype, id);
 270
 271         let path = group.group_path().to_str().unwrap().to_owned();
 272
 273         let files = item["files"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_owned()).collect();
 274         let files = strip_chunked_file_expenstions(files);
 275
 276         println!("{:20} | {} | {:5} | {}", path, last_backup.format("%c"),
 277                  backup_count, tools::join(&files, ' '));
 278     }
 279
 280     //Ok(result)
 281     Ok(Value::Null)
 282 }
 283
 284 fn list_snapshots(
 285     param: Value,
 286     _info: &ApiMethod,
 287     _rpcenv: &mut RpcEnvironment,
 288 ) -> Result<Value, Error> {
 289
 290     let repo_url = tools::required_string_param(&param, "repository")?;
 291     let repo: BackupRepository = repo_url.parse()?;
 292
 293     let path = tools::required_string_param(&param, "group")?;
 294     let group = BackupGroup::parse(path)?;
 295
 296     let query = tools::json_object_to_query(json!({
 297         "backup-type": group.backup_type(),
 298         "backup-id": group.backup_id(),
 299     }))?;
 300
 301     let mut client = HttpClient::new(repo.host(), repo.user());
 302
 303     let path = format!("api2/json/admin/datastore/{}/snapshots?{}", repo.store(), query);
 304
 305     // fixme: params
 306     let result = client.get(&path)?;
 307
 308     record_repository(&repo);
 309
 310     // fixme: implement and use output formatter instead ..
 311     let list = result["data"].as_array().unwrap();
 312
 313     for item in list {
 314
 315         let id = item["backup-id"].as_str().unwrap();
 316         let btype = item["backup-type"].as_str().unwrap();
 317         let epoch = item["backup-time"].as_i64().unwrap();
 318
 319         let snapshot = BackupDir::new(btype, id, epoch);
 320
 321         let path = snapshot.relative_path().to_str().unwrap().to_owned();
 322
 323         let files = item["files"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_owned()).collect();
 324         let files = strip_chunked_file_expenstions(files);
 325
 326         println!("{} | {} | {}", path, snapshot.backup_time().format("%c"), tools::join(&files, ' '));
 327     }
 328
 329     Ok(Value::Null)
 330 }
 331
 332 fn forget_snapshots(
 333     param: Value,
 334     _info: &ApiMethod,
 335     _rpcenv: &mut RpcEnvironment,
 336 ) -> Result<Value, Error> {
 337
 338     let repo_url = tools::required_string_param(&param, "repository")?;
 339     let repo: BackupRepository = repo_url.parse()?;
 340
 341     let path = tools::required_string_param(&param, "snapshot")?;
 342     let snapshot = BackupDir::parse(path)?;
 343
 344     let query = tools::json_object_to_query(json!({
 345         "backup-type": snapshot.group().backup_type(),
 346         "backup-id": snapshot.group().backup_id(),
 347         "backup-time": snapshot.backup_time().timestamp(),
 348     }))?;
 349
 350     let mut client = HttpClient::new(repo.host(), repo.user());
 351
 352     let path = format!("api2/json/admin/datastore/{}/snapshots?{}", repo.store(), query);
 353
 354     let result = client.delete(&path)?;
 355
 356     record_repository(&repo);
 357
 358     Ok(result)
 359 }
 360
 361 fn start_garbage_collection(
 362     param: Value,
 363     _info: &ApiMethod,
 364     _rpcenv: &mut RpcEnvironment,
 365 ) -> Result<Value, Error> {
 366
 367     let repo_url = tools::required_string_param(&param, "repository")?;
 368     let repo: BackupRepository = repo_url.parse()?;
 369
 370     let mut client = HttpClient::new(repo.host(), repo.user());
 371
 372     let path = format!("api2/json/admin/datastore/{}/gc", repo.store());
 373
 374     let result = client.post(&path)?;
 375
 376     record_repository(&repo);
 377
 378     Ok(result)
 379 }
 380
 381 fn parse_backupspec(value: &str) -> Result<(&str, &str), Error> {
 382
 383     if let Some(caps) = BACKUPSPEC_REGEX.captures(value) {
 384         return Ok((caps.get(1).unwrap().as_str(), caps.get(2).unwrap().as_str()));
 385     }
 386     bail!("unable to parse directory specification '{}'", value);
 387 }
 388
 389 fn create_backup(
 390     param: Value,
 391     _info: &ApiMethod,
 392     _rpcenv: &mut RpcEnvironment,
 393 ) -> Result<Value, Error> {
 394
 395     let repo_url = tools::required_string_param(&param, "repository")?;
 396
 397     let backupspec_list = tools::required_array_param(&param, "backupspec")?;
 398
 399     let repo: BackupRepository = repo_url.parse()?;
 400
 401     let all_file_systems = param["all-file-systems"].as_bool().unwrap_or(false);
 402
 403     let verbose = param["verbose"].as_bool().unwrap_or(false);
 404
 405     let chunk_size_opt = param["chunk-size"].as_u64().map(|v| v*1024);
 406
 407     if let Some(size) = chunk_size_opt {
 408         verify_chunk_size(size)?;
 409     }
 410
 411     let backup_id = param["host-id"].as_str().unwrap_or(&tools::nodename());
 412
 413     let mut upload_list = vec![];
 414
 415     for backupspec in backupspec_list {
 416         let (target, filename) = parse_backupspec(backupspec.as_str().unwrap())?;
 417
 418         let stat = match nix::sys::stat::stat(filename) {
 419             Ok(s) => s,
 420             Err(err) => bail!("unable to access '{}' - {}", filename, err),
 421         };
 422
 423         if (stat.st_mode & libc::S_IFDIR) != 0 {
 424
 425             upload_list.push((filename.to_owned(), target.to_owned()));
 426
 427         } else if (stat.st_mode & (libc::S_IFREG|libc::S_IFBLK)) != 0 {
 428             if stat.st_size <= 0 { bail!("got strange file size '{}'", stat.st_size); }
 429             let _size = stat.st_size as usize;
 430
 431             panic!("implement me");
 432
 433             //backup_image(&datastore, &file, size, &target, chunk_size)?;
 434
 435             // let idx = datastore.open_image_reader(target)?;
 436             // idx.print_info();
 437
 438         } else {
 439             bail!("unsupported file type (expected a directory, file or block device)");
 440         }
 441     }
 442
 443     let backup_time = Local.timestamp(Local::now().timestamp(), 0);
 444
 445     let mut client = HttpClient::new(repo.host(), repo.user());
 446
 447     client.login()?; // login before starting backup
 448
 449     record_repository(&repo);
 450
 451     println!("Starting backup");
 452     println!("Client name: {}", tools::nodename());
 453     println!("Start Time: {}", backup_time.to_rfc3339());
 454
 455     for (filename, target) in upload_list {
 456         println!("Upload '{}' to '{:?}' as {}", filename, repo, target);
 457         backup_directory(&mut client, &repo, &filename, &target, backup_id, backup_time,
 458                          chunk_size_opt, all_file_systems, verbose)?;
 459     }
 460
 461     let end_time = Local.timestamp(Local::now().timestamp(), 0);
 462     let elapsed = end_time.signed_duration_since(backup_time);
 463     println!("Duration: {}", elapsed);
 464
 465     println!("End Time: {}", end_time.to_rfc3339());
 466
 467     Ok(Value::Null)
 468 }
 469
 470 fn complete_backup_source(arg: &str, param: &HashMap<String, String>) -> Vec<String> {
 471
 472     let mut result = vec![];
 473
 474     let data: Vec<&str> = arg.splitn(2, ':').collect();
 475
 476     if data.len() != 2 {
 477         result.push(String::from("root.catar:/"));
 478         result.push(String::from("etc.catar:/etc"));
 479         return result;
 480     }
 481
 482     let files = tools::complete_file_name(data[1], param);
 483
 484     for file in files {
 485         result.push(format!("{}:{}", data[0], file));
 486     }
 487
 488     result
 489 }
 490
 491 fn restore(
 492     param: Value,
 493     _info: &ApiMethod,
 494     _rpcenv: &mut RpcEnvironment,
 495 ) -> Result<Value, Error> {
 496
 497     let repo_url = tools::required_string_param(&param, "repository")?;
 498     let repo: BackupRepository = repo_url.parse()?;
 499
 500     let archive_name = tools::required_string_param(&param, "archive-name")?;
 501
 502     let mut client = HttpClient::new(repo.host(), repo.user());
 503
 504     client.login()?; // login before starting
 505
 506     record_repository(&repo);
 507
 508     let path = tools::required_string_param(&param, "snapshot")?;
 509
 510     let query;
 511
 512     if path.matches('/').count() == 1 {
 513         let group = BackupGroup::parse(path)?;
 514
 515         let subquery = tools::json_object_to_query(json!({
 516             "backup-type": group.backup_type(),
 517             "backup-id": group.backup_id(),
 518         }))?;
 519
 520         let path = format!("api2/json/admin/datastore/{}/snapshots?{}", repo.store(), subquery);
 521         let result = client.get(&path)?;
 522
 523         let list = result["data"].as_array().unwrap();
 524         if list.len() == 0 {
 525             bail!("backup group '{}' does not contain any snapshots:", path);
 526         }
 527
 528         query = tools::json_object_to_query(json!({
 529             "backup-type": group.backup_type(),
 530             "backup-id": group.backup_id(),
 531             "backup-time": list[0]["backup-time"].as_i64().unwrap(),
 532             "archive-name": archive_name,
 533         }))?;
 534     } else {
 535         let snapshot = BackupDir::parse(path)?;
 536
 537         query = tools::json_object_to_query(json!({
 538             "backup-type": snapshot.group().backup_type(),
 539             "backup-id": snapshot.group().backup_id(),
 540             "backup-time": snapshot.backup_time().timestamp(),
 541             "archive-name": archive_name,
 542         }))?;
 543     }
 544
 545     let target = tools::required_string_param(&param, "target")?;
 546
 547     if archive_name.ends_with(".catar") {
 548         let path = format!("api2/json/admin/datastore/{}/catar?{}", repo.store(), query);
 549
 550         println!("DOWNLOAD FILE {} to {}", path, target);
 551
 552         let target = PathBuf::from(target);
 553         let writer = CaTarBackupWriter::new(&target, true)?;
 554         client.download(&path, Box::new(writer))?;
 555     } else {
 556         bail!("unknown file extensions - unable to download '{}'", archive_name);
 557     }
 558
 559     Ok(Value::Null)
 560 }
 561
 562 fn prune(
 563     mut param: Value,
 564     _info: &ApiMethod,
 565     _rpcenv: &mut RpcEnvironment,
 566 ) -> Result<Value, Error> {
 567
 568     let repo_url = tools::required_string_param(&param, "repository")?;
 569     let repo: BackupRepository = repo_url.parse()?;
 570
 571     let mut client = HttpClient::new(repo.host(), repo.user());
 572
 573     let path = format!("api2/json/admin/datastore/{}/prune", repo.store());
 574
 575     param.as_object_mut().unwrap().remove("repository");
 576
 577     let result = client.post_json(&path, param)?;
 578
 579     record_repository(&repo);
 580
 581     Ok(result)
 582 }
 583
 584 fn complete_backup_group(_arg: &str, param: &HashMap<String, String>) -> Vec<String> {
 585
 586     let mut result = vec![];
 587
 588     let repo_url = match param.get("repository") {
 589         Some(v) => v,
 590         _ => return result,
 591     };
 592
 593     let repo: BackupRepository = match repo_url.parse() {
 594         Ok(v) => v,
 595         _ => return result,
 596     };
 597
 598     let mut client = HttpClient::new(repo.host(), repo.user());
 599
 600     let path = format!("api2/json/admin/datastore/{}/groups", repo.store());
 601
 602     let resp = match client.try_get(&path) {
 603         Ok(v) => v,
 604         _ => return result,
 605     };
 606
 607     if let Some(list) = resp["data"].as_array() {
 608         for item in list {
 609             if let (Some(backup_id), Some(backup_type)) =
 610                 (item["backup-id"].as_str(), item["backup-type"].as_str())
 611             {
 612                 result.push(format!("{}/{}", backup_type, backup_id));
 613             }
 614         }
 615     }
 616
 617     result
 618 }
 619
 620 fn complete_chunk_size(_arg: &str, _param: &HashMap<String, String>) -> Vec<String> {
 621
 622     let mut result = vec![];
 623
 624     let mut size = 64;
 625     loop {
 626         result.push(size.to_string());
 627         size = size * 2;
 628         if size > 4096 { break; }
 629     }
 630
 631     result
 632 }
 633
 634 fn main() {
 635
 636     let repo_url_schema: Arc<Schema> = Arc::new(
 637         StringSchema::new("Repository URL.")
 638             .format(BACKUP_REPO_URL.clone())
 639             .max_length(256)
 640             .into()
 641     );
 642
 643     let backup_source_schema: Arc<Schema> = Arc::new(
 644         StringSchema::new("Backup source specification ([<label>:<path>]).")
 645             .format(Arc::new(ApiStringFormat::Pattern(&BACKUPSPEC_REGEX)))
 646             .into()
 647     );
 648
 649     let backup_cmd_def = CliCommand::new(
 650         ApiMethod::new(
 651             create_backup,
 652             ObjectSchema::new("Create (host) backup.")
 653                 .required("repository", repo_url_schema.clone())
 654                 .required(
 655                     "backupspec",
 656                     ArraySchema::new(
 657                         "List of backup source specifications ([<label.ext>:<path>] ...)",
 658                         backup_source_schema,
 659                     ).min_length(1)
 660                 )
 661                 .optional(
 662                     "verbose",
 663                     BooleanSchema::new("Verbose output.").default(false))
 664                 .optional(
 665                     "host-id",
 666                     StringSchema::new("Use specified ID for the backup group name ('host/<id>'). The default is the system hostname."))
 667                 .optional(
 668                     "chunk-size",
 669                     IntegerSchema::new("Chunk size in KB. Must be a power of 2.")
 670                         .minimum(64)
 671                         .maximum(4096)
 672                         .default(4096)
 673                 )
 674         ))
 675         .arg_param(vec!["repository", "backupspec"])
 676         .completion_cb("repository", complete_repository)
 677         .completion_cb("backupspec", complete_backup_source)
 678         .completion_cb("chunk-size", complete_chunk_size);
 679
 680     let list_cmd_def = CliCommand::new(
 681         ApiMethod::new(
 682             list_backup_groups,
 683             ObjectSchema::new("List backup groups.")
 684                 .required("repository", repo_url_schema.clone())
 685         ))
 686         .arg_param(vec!["repository"])
 687         .completion_cb("repository", complete_repository);
 688
 689     let snapshots_cmd_def = CliCommand::new(
 690         ApiMethod::new(
 691             list_snapshots,
 692             ObjectSchema::new("List backup snapshots.")
 693                 .required("repository", repo_url_schema.clone())
 694                 .required("group", StringSchema::new("Backup group."))
 695         ))
 696         .arg_param(vec!["repository", "group"])
 697         .completion_cb("group", complete_backup_group)
 698         .completion_cb("repository", complete_repository);
 699
 700     let forget_cmd_def = CliCommand::new(
 701         ApiMethod::new(
 702             forget_snapshots,
 703             ObjectSchema::new("Forget (remove) backup snapshots.")
 704                 .required("repository", repo_url_schema.clone())
 705                 .required("snapshot", StringSchema::new("Snapshot path."))
 706         ))
 707         .arg_param(vec!["repository", "snapshot"])
 708         .completion_cb("repository", complete_repository);
 709
 710     let garbage_collect_cmd_def = CliCommand::new(
 711         ApiMethod::new(
 712             start_garbage_collection,
 713             ObjectSchema::new("Start garbage collection for a specific repository.")
 714                 .required("repository", repo_url_schema.clone())
 715         ))
 716         .arg_param(vec!["repository"])
 717         .completion_cb("repository", complete_repository);
 718
 719     let restore_cmd_def = CliCommand::new(
 720         ApiMethod::new(
 721             restore,
 722             ObjectSchema::new("Restore backup repository.")
 723                 .required("repository", repo_url_schema.clone())
 724                 .required("snapshot", StringSchema::new("Group/Snapshot path."))
 725                 .required("archive-name", StringSchema::new("Backup archive name."))
 726                 .required("target", StringSchema::new("Target directory path."))
 727         ))
 728         .arg_param(vec!["repository", "snapshot", "archive-name", "target"])
 729         .completion_cb("repository", complete_repository);
 730
 731     let prune_cmd_def = CliCommand::new(
 732         ApiMethod::new(
 733             prune,
 734             proxmox_backup::api2::admin::datastore::add_common_prune_prameters(
 735                 ObjectSchema::new("Prune backup repository.")
 736                     .required("repository", repo_url_schema.clone())
 737             )
 738         ))
 739         .arg_param(vec!["repository"])
 740         .completion_cb("repository", complete_repository);
 741
 742     let cmd_def = CliCommandMap::new()
 743         .insert("backup".to_owned(), backup_cmd_def.into())
 744         .insert("forget".to_owned(), forget_cmd_def.into())
 745         .insert("garbage-collect".to_owned(), garbage_collect_cmd_def.into())
 746         .insert("list".to_owned(), list_cmd_def.into())
 747         .insert("prune".to_owned(), prune_cmd_def.into())
 748         .insert("restore".to_owned(), restore_cmd_def.into())
 749         .insert("snapshots".to_owned(), snapshots_cmd_def.into());
 750
 751     run_cli_command(cmd_def.into());
 752
 753 }