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::pxar::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 use futures::*;
  28 use tokio::sync::mpsc;
  29
  30 lazy_static! {
  31     static ref BACKUPSPEC_REGEX: Regex = Regex::new(r"^([a-zA-Z0-9_-]+\.(?:pxar|raw)):(.+)$").unwrap();
  32 }
  33
  34
  35 fn record_repository(repo: &BackupRepository) {
  36
  37     let base = match BaseDirectories::with_prefix("proxmox-backup") {
  38         Ok(v) => v,
  39         _ => return,
  40     };
  41
  42     // usually $HOME/.cache/proxmox-backup/repo-list
  43     let path = match base.place_cache_file("repo-list") {
  44         Ok(v) => v,
  45         _ => return,
  46     };
  47
  48     let mut data = tools::file_get_json(&path, None).unwrap_or(json!({}));
  49
  50     let repo = repo.to_string();
  51
  52     data[&repo] = json!{ data[&repo].as_i64().unwrap_or(0) + 1 };
  53
  54     let mut map = serde_json::map::Map::new();
  55
  56     loop {
  57         let mut max_used = 0;
  58         let mut max_repo = None;
  59         for (repo, count) in data.as_object().unwrap() {
  60             if map.contains_key(repo) { continue; }
  61             if let Some(count) = count.as_i64() {
  62                 if count > max_used {
  63                     max_used = count;
  64                     max_repo = Some(repo);
  65                 }
  66             }
  67         }
  68         if let Some(repo) = max_repo {
  69             map.insert(repo.to_owned(), json!(max_used));
  70         } else {
  71             break;
  72         }
  73         if map.len() > 10 { // store max. 10 repos
  74             break;
  75         }
  76     }
  77
  78     let new_data = json!(map);
  79
  80     let _ = tools::file_set_contents(path, new_data.to_string().as_bytes(), None);
  81 }
  82
  83 fn complete_repository(_arg: &str, _param: &HashMap<String, String>) -> Vec<String> {
  84
  85     let mut result = vec![];
  86
  87     let base = match BaseDirectories::with_prefix("proxmox-backup") {
  88         Ok(v) => v,
  89         _ => return result,
  90     };
  91
  92     // usually $HOME/.cache/proxmox-backup/repo-list
  93     let path = match base.place_cache_file("repo-list") {
  94         Ok(v) => v,
  95         _ => return result,
  96     };
  97
  98     let data = tools::file_get_json(&path, None).unwrap_or(json!({}));
  99
 100     if let Some(map) = data.as_object() {
 101         for (repo, _count) in map {
 102             result.push(repo.to_owned());
 103         }
 104     }
 105
 106     result
 107 }
 108
 109 fn backup_directory<P: AsRef<Path>>(
 110     client: &BackupClient,
 111     dir_path: P,
 112     archive_name: &str,
 113     chunk_size: Option<u64>,
 114     all_file_systems: bool,
 115     verbose: bool,
 116 ) -> Result<(), Error> {
 117
 118     if let Some(_size) = chunk_size {
 119         unimplemented!();
 120     }
 121
 122     let pxar_stream = PxarBackupStream::open(dir_path.as_ref(), all_file_systems, verbose)?;
 123     let chunk_stream = ChunkStream::new(pxar_stream);
 124
 125     let (tx, rx) = mpsc::channel(10); // allow to buffer 10 chunks
 126
 127     let stream = rx
 128         .map_err(Error::from)
 129         .and_then(|x| x); // flatten
 130
 131     // spawn chunker inside a separate task so that it can run parallel
 132     tokio::spawn(
 133         tx.send_all(chunk_stream.then(|r| Ok(r)))
 134             .map_err(|e| {}).map(|_| ())
 135     );
 136
 137     client.upload_stream(archive_name, stream, "dynamic", None).wait()?;
 138
 139     Ok(())
 140 }
 141
 142 /****
 143 fn backup_image(datastore: &DataStore, file: &std::fs::File, size: usize, target: &str, chunk_size: usize) -> Result<(), Error> {
 144
 145     let mut target = PathBuf::from(target);
 146
 147     if let Some(ext) = target.extension() {
 148         if ext != "fidx" {
 149             bail!("got wrong file extension - expected '.fidx'");
 150         }
 151     } else {
 152         target.set_extension("fidx");
 153     }
 154
 155     let mut index = datastore.create_image_writer(&target, size, chunk_size)?;
 156
 157     tools::file_chunker(file, chunk_size, |pos, chunk| {
 158         index.add_chunk(pos, chunk)?;
 159         Ok(true)
 160     })?;
 161
 162     index.close()?; // commit changes
 163
 164     Ok(())
 165 }
 166 */
 167
 168 fn strip_chunked_file_expenstions(list: Vec<String>) -> Vec<String> {
 169
 170     let mut result = vec![];
 171
 172     for file in list.into_iter() {
 173         if file.ends_with(".didx") {
 174             result.push(file[..file.len()-5].to_owned());
 175         } else if file.ends_with(".fidx") {
 176             result.push(file[..file.len()-5].to_owned());
 177         } else {
 178             result.push(file); // should not happen
 179         }
 180     }
 181
 182     result
 183 }
 184
 185 /* not used:
 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, None)?;
 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
 228 fn list_backup_groups(
 229     param: Value,
 230     _info: &ApiMethod,
 231     _rpcenv: &mut RpcEnvironment,
 232 ) -> Result<Value, Error> {
 233
 234     let repo_url = tools::required_string_param(&param, "repository")?;
 235     let repo: BackupRepository = repo_url.parse()?;
 236
 237     let client = HttpClient::new(repo.host(), repo.user())?;
 238
 239     let path = format!("api2/json/admin/datastore/{}/groups", repo.store());
 240
 241     let mut result = client.get(&path, None).wait()?;
 242
 243     record_repository(&repo);
 244
 245     // fixme: implement and use output formatter instead ..
 246     let list = result["data"].as_array_mut().unwrap();
 247
 248     list.sort_unstable_by(|a, b| {
 249         let a_id = a["backup-id"].as_str().unwrap();
 250         let a_backup_type = a["backup-type"].as_str().unwrap();
 251         let b_id = b["backup-id"].as_str().unwrap();
 252         let b_backup_type = b["backup-type"].as_str().unwrap();
 253
 254         let type_order = a_backup_type.cmp(b_backup_type);
 255         if type_order == std::cmp::Ordering::Equal {
 256             a_id.cmp(b_id)
 257         } else {
 258             type_order
 259         }
 260     });
 261
 262     for item in list {
 263
 264         let id = item["backup-id"].as_str().unwrap();
 265         let btype = item["backup-type"].as_str().unwrap();
 266         let epoch = item["last-backup"].as_i64().unwrap();
 267         let last_backup = Local.timestamp(epoch, 0);
 268         let backup_count = item["backup-count"].as_u64().unwrap();
 269
 270         let group = BackupGroup::new(btype, id);
 271
 272         let path = group.group_path().to_str().unwrap().to_owned();
 273
 274         let files = item["files"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_owned()).collect();
 275         let files = strip_chunked_file_expenstions(files);
 276
 277         println!("{:20} | {} | {:5} | {}", path, last_backup.format("%c"),
 278                  backup_count, tools::join(&files, ' '));
 279     }
 280
 281     //Ok(result)
 282     Ok(Value::Null)
 283 }
 284
 285 fn list_snapshots(
 286     param: Value,
 287     _info: &ApiMethod,
 288     _rpcenv: &mut RpcEnvironment,
 289 ) -> Result<Value, Error> {
 290
 291     let repo_url = tools::required_string_param(&param, "repository")?;
 292     let repo: BackupRepository = repo_url.parse()?;
 293
 294     let path = tools::required_string_param(&param, "group")?;
 295     let group = BackupGroup::parse(path)?;
 296
 297     let client = HttpClient::new(repo.host(), repo.user())?;
 298
 299     let path = format!("api2/json/admin/datastore/{}/snapshots", repo.store());
 300
 301     let result = client.get(&path, Some(json!({
 302         "backup-type": group.backup_type(),
 303         "backup-id": group.backup_id(),
 304     }))).wait()?;
 305
 306     record_repository(&repo);
 307
 308     // fixme: implement and use output formatter instead ..
 309     let list = result["data"].as_array().unwrap();
 310
 311     for item in list {
 312
 313         let id = item["backup-id"].as_str().unwrap();
 314         let btype = item["backup-type"].as_str().unwrap();
 315         let epoch = item["backup-time"].as_i64().unwrap();
 316
 317         let snapshot = BackupDir::new(btype, id, epoch);
 318
 319         let path = snapshot.relative_path().to_str().unwrap().to_owned();
 320
 321         let files = item["files"].as_array().unwrap().iter().map(|v| v.as_str().unwrap().to_owned()).collect();
 322         let files = strip_chunked_file_expenstions(files);
 323
 324         println!("{} | {} | {}", path, snapshot.backup_time().format("%c"), tools::join(&files, ' '));
 325     }
 326
 327     Ok(Value::Null)
 328 }
 329
 330 fn forget_snapshots(
 331     param: Value,
 332     _info: &ApiMethod,
 333     _rpcenv: &mut RpcEnvironment,
 334 ) -> Result<Value, Error> {
 335
 336     let repo_url = tools::required_string_param(&param, "repository")?;
 337     let repo: BackupRepository = repo_url.parse()?;
 338
 339     let path = tools::required_string_param(&param, "snapshot")?;
 340     let snapshot = BackupDir::parse(path)?;
 341
 342     let mut client = HttpClient::new(repo.host(), repo.user())?;
 343
 344     let path = format!("api2/json/admin/datastore/{}/snapshots", repo.store());
 345
 346     let result = client.delete(&path, Some(json!({
 347         "backup-type": snapshot.group().backup_type(),
 348         "backup-id": snapshot.group().backup_id(),
 349         "backup-time": snapshot.backup_time().timestamp(),
 350     }))).wait()?;
 351
 352     record_repository(&repo);
 353
 354     Ok(result)
 355 }
 356
 357 fn start_garbage_collection(
 358     param: Value,
 359     _info: &ApiMethod,
 360     _rpcenv: &mut RpcEnvironment,
 361 ) -> Result<Value, Error> {
 362
 363     let repo_url = tools::required_string_param(&param, "repository")?;
 364     let repo: BackupRepository = repo_url.parse()?;
 365
 366     let mut client = HttpClient::new(repo.host(), repo.user())?;
 367
 368     let path = format!("api2/json/admin/datastore/{}/gc", repo.store());
 369
 370     let result = client.post(&path, None).wait()?;
 371
 372     record_repository(&repo);
 373
 374     Ok(result)
 375 }
 376
 377 fn parse_backupspec(value: &str) -> Result<(&str, &str), Error> {
 378
 379     if let Some(caps) = BACKUPSPEC_REGEX.captures(value) {
 380         return Ok((caps.get(1).unwrap().as_str(), caps.get(2).unwrap().as_str()));
 381     }
 382     bail!("unable to parse directory specification '{}'", value);
 383 }
 384
 385 fn create_backup(
 386     param: Value,
 387     _info: &ApiMethod,
 388     _rpcenv: &mut RpcEnvironment,
 389 ) -> Result<Value, Error> {
 390
 391     let repo_url = tools::required_string_param(&param, "repository")?;
 392
 393     let backupspec_list = tools::required_array_param(&param, "backupspec")?;
 394
 395     let repo: BackupRepository = repo_url.parse()?;
 396
 397     let all_file_systems = param["all-file-systems"].as_bool().unwrap_or(false);
 398
 399     let verbose = param["verbose"].as_bool().unwrap_or(false);
 400
 401     let chunk_size_opt = param["chunk-size"].as_u64().map(|v| v*1024);
 402
 403     if let Some(size) = chunk_size_opt {
 404         verify_chunk_size(size)?;
 405     }
 406
 407     let backup_id = param["host-id"].as_str().unwrap_or(&tools::nodename());
 408
 409     let mut upload_list = vec![];
 410
 411     for backupspec in backupspec_list {
 412         let (target, filename) = parse_backupspec(backupspec.as_str().unwrap())?;
 413
 414         use std::os::unix::fs::FileTypeExt;
 415
 416         let metadata = match std::fs::metadata(filename) {
 417             Ok(m) => m,
 418             Err(err) => bail!("unable to access '{}' - {}", filename, err),
 419         };
 420         let file_type = metadata.file_type();
 421
 422         if file_type.is_dir() {
 423
 424             upload_list.push((filename.to_owned(), target.to_owned()));
 425
 426         } else if file_type.is_file() || file_type.is_block_device() {
 427
 428             let size = tools::image_size(&PathBuf::from(filename))?;
 429
 430             if size == 0 { bail!("got zero-sized file '{}'", filename); }
 431
 432             panic!("implement me");
 433
 434             //backup_image(&datastore, &file, size, &target, chunk_size)?;
 435
 436             // let idx = datastore.open_image_reader(target)?;
 437             // idx.print_info();
 438
 439         } else {
 440             bail!("unsupported file type (expected a directory, file or block device)");
 441         }
 442     }
 443
 444     let backup_time = Local.timestamp(Local::now().timestamp(), 0);
 445
 446     let client = HttpClient::new(repo.host(), repo.user())?;
 447     record_repository(&repo);
 448
 449     println!("Starting backup");
 450     println!("Client name: {}", tools::nodename());
 451     println!("Start Time: {}", backup_time.to_rfc3339());
 452
 453     let client = client.start_backup(repo.store(), "host", &backup_id, verbose).wait()?;
 454
 455     for (filename, target) in upload_list {
 456         println!("Upload '{}' to '{:?}' as {}", filename, repo, target);
 457         backup_directory(&client, &filename, &target, chunk_size_opt, all_file_systems, verbose)?;
 458     }
 459
 460     client.finish().wait()?;
 461
 462     let end_time = Local.timestamp(Local::now().timestamp(), 0);
 463     let elapsed = end_time.signed_duration_since(backup_time);
 464     println!("Duration: {}", elapsed);
 465
 466     println!("End Time: {}", end_time.to_rfc3339());
 467
 468     Ok(Value::Null)
 469 }
 470
 471 fn complete_backup_source(arg: &str, param: &HashMap<String, String>) -> Vec<String> {
 472
 473     let mut result = vec![];
 474
 475     let data: Vec<&str> = arg.splitn(2, ':').collect();
 476
 477     if data.len() != 2 {
 478         result.push(String::from("root.pxar:/"));
 479         result.push(String::from("etc.pxar:/etc"));
 480         return result;
 481     }
 482
 483     let files = tools::complete_file_name(data[1], param);
 484
 485     for file in files {
 486         result.push(format!("{}:{}", data[0], file));
 487     }
 488
 489     result
 490 }
 491
 492 fn restore(
 493     param: Value,
 494     _info: &ApiMethod,
 495     _rpcenv: &mut RpcEnvironment,
 496 ) -> Result<Value, Error> {
 497
 498     let repo_url = tools::required_string_param(&param, "repository")?;
 499     let repo: BackupRepository = repo_url.parse()?;
 500
 501     let archive_name = tools::required_string_param(&param, "archive-name")?;
 502
 503     let mut client = HttpClient::new(repo.host(), repo.user())?;
 504
 505     record_repository(&repo);
 506
 507     let path = tools::required_string_param(&param, "snapshot")?;
 508
 509     let query;
 510
 511     if path.matches('/').count() == 1 {
 512         let group = BackupGroup::parse(path)?;
 513
 514         let path = format!("api2/json/admin/datastore/{}/snapshots", repo.store());
 515         let result = client.get(&path, Some(json!({
 516             "backup-type": group.backup_type(),
 517             "backup-id": group.backup_id(),
 518         }))).wait()?;
 519
 520         let list = result["data"].as_array().unwrap();
 521         if list.len() == 0 {
 522             bail!("backup group '{}' does not contain any snapshots:", path);
 523         }
 524
 525         query = tools::json_object_to_query(json!({
 526             "backup-type": group.backup_type(),
 527             "backup-id": group.backup_id(),
 528             "backup-time": list[0]["backup-time"].as_i64().unwrap(),
 529             "archive-name": archive_name,
 530         }))?;
 531     } else {
 532         let snapshot = BackupDir::parse(path)?;
 533
 534         query = tools::json_object_to_query(json!({
 535             "backup-type": snapshot.group().backup_type(),
 536             "backup-id": snapshot.group().backup_id(),
 537             "backup-time": snapshot.backup_time().timestamp(),
 538             "archive-name": archive_name,
 539         }))?;
 540     }
 541
 542     let target = tools::required_string_param(&param, "target")?;
 543
 544     if archive_name.ends_with(".pxar") {
 545         let path = format!("api2/json/admin/datastore/{}/pxar?{}", repo.store(), query);
 546
 547         println!("DOWNLOAD FILE {} to {}", path, target);
 548
 549         let target = PathBuf::from(target);
 550         let writer = PxarDecodeWriter::new(&target, true)?;
 551         client.download(&path, Box::new(writer)).wait()?;
 552     } else {
 553         bail!("unknown file extensions - unable to download '{}'", archive_name);
 554     }
 555
 556     Ok(Value::Null)
 557 }
 558
 559 fn prune(
 560     mut param: Value,
 561     _info: &ApiMethod,
 562     _rpcenv: &mut RpcEnvironment,
 563 ) -> Result<Value, Error> {
 564
 565     let repo_url = tools::required_string_param(&param, "repository")?;
 566     let repo: BackupRepository = repo_url.parse()?;
 567
 568     let mut client = HttpClient::new(repo.host(), repo.user())?;
 569
 570     let path = format!("api2/json/admin/datastore/{}/prune", repo.store());
 571
 572     param.as_object_mut().unwrap().remove("repository");
 573
 574     let result = client.post(&path, Some(param)).wait()?;
 575
 576     record_repository(&repo);
 577
 578     Ok(result)
 579 }
 580
 581 // like get, but simply ignore errors and return Null instead
 582 fn try_get(repo: &BackupRepository, url: &str) -> Value {
 583
 584     let client = match HttpClient::new(repo.host(), repo.user()) {
 585         Ok(v) => v,
 586         _ => return Value::Null,
 587     };
 588
 589     let mut resp = match client.get(url, None).wait() {
 590         Ok(v) => v,
 591         _ => return Value::Null,
 592     };
 593
 594     if let Some(map) = resp.as_object_mut() {
 595         if let Some(data) = map.remove("data") {
 596             return data;
 597         }
 598     }
 599     Value::Null
 600 }
 601
 602 fn extract_repo(param: &HashMap<String, String>) -> Option<BackupRepository> {
 603
 604     let repo_url = match param.get("repository") {
 605         Some(v) => v,
 606         _ => return None,
 607     };
 608
 609     let repo: BackupRepository = match repo_url.parse() {
 610         Ok(v) => v,
 611         _ => return None,
 612     };
 613
 614     Some(repo)
 615 }
 616
 617 fn complete_backup_group(_arg: &str, param: &HashMap<String, String>) -> Vec<String> {
 618
 619     let mut result = vec![];
 620
 621     let repo = match extract_repo(param) {
 622         Some(v) => v,
 623         _ => return result,
 624     };
 625
 626     let path = format!("api2/json/admin/datastore/{}/groups", repo.store());
 627
 628     let data = try_get(&repo, &path);
 629
 630     if let Some(list) = data.as_array() {
 631         for item in list {
 632             if let (Some(backup_id), Some(backup_type)) =
 633                 (item["backup-id"].as_str(), item["backup-type"].as_str())
 634             {
 635                 result.push(format!("{}/{}", backup_type, backup_id));
 636             }
 637         }
 638     }
 639
 640     result
 641 }
 642
 643 fn complete_group_or_snapshot(arg: &str, param: &HashMap<String, String>) -> Vec<String> {
 644
 645     let mut result = vec![];
 646
 647      let repo = match extract_repo(param) {
 648         Some(v) => v,
 649         _ => return result,
 650     };
 651
 652     if arg.matches('/').count() < 2 {
 653         let groups = complete_backup_group(arg, param);
 654         for group in groups {
 655             result.push(group.to_string());
 656             result.push(format!("{}/", group));
 657         }
 658         return result;
 659     }
 660
 661     let mut parts = arg.split('/');
 662     let query = tools::json_object_to_query(json!({
 663         "backup-type": parts.next().unwrap(),
 664         "backup-id": parts.next().unwrap(),
 665     })).unwrap();
 666
 667     let path = format!("api2/json/admin/datastore/{}/snapshots?{}", repo.store(), query);
 668
 669     let data = try_get(&repo, &path);
 670
 671     if let Some(list) = data.as_array() {
 672         for item in list {
 673             if let (Some(backup_id), Some(backup_type), Some(backup_time)) =
 674                 (item["backup-id"].as_str(), item["backup-type"].as_str(), item["backup-time"].as_i64())
 675             {
 676                 let snapshot = BackupDir::new(backup_type, backup_id, backup_time);
 677                 result.push(snapshot.relative_path().to_str().unwrap().to_owned());
 678             }
 679         }
 680     }
 681
 682     result
 683 }
 684
 685 fn complete_archive_name(_arg: &str, param: &HashMap<String, String>) -> Vec<String> {
 686
 687     let mut result = vec![];
 688
 689     let repo = match extract_repo(param) {
 690         Some(v) => v,
 691         _ => return result,
 692     };
 693
 694     let snapshot = match param.get("snapshot") {
 695         Some(path) => {
 696             match BackupDir::parse(path) {
 697                 Ok(v) => v,
 698                 _ => return result,
 699             }
 700         }
 701         _ => return result,
 702     };
 703
 704     let query = tools::json_object_to_query(json!({
 705         "backup-type": snapshot.group().backup_type(),
 706         "backup-id": snapshot.group().backup_id(),
 707         "backup-time": snapshot.backup_time().timestamp(),
 708     })).unwrap();
 709
 710     let path = format!("api2/json/admin/datastore/{}/files?{}", repo.store(), query);
 711
 712     let data = try_get(&repo, &path);
 713
 714     if let Some(list) = data.as_array() {
 715         for item in list {
 716             if let Some(filename) = item.as_str() {
 717                 result.push(filename.to_owned());
 718             }
 719         }
 720     }
 721
 722     strip_chunked_file_expenstions(result)
 723 }
 724
 725 fn complete_chunk_size(_arg: &str, _param: &HashMap<String, String>) -> Vec<String> {
 726
 727     let mut result = vec![];
 728
 729     let mut size = 64;
 730     loop {
 731         result.push(size.to_string());
 732         size = size * 2;
 733         if size > 4096 { break; }
 734     }
 735
 736     result
 737 }
 738
 739 fn main() {
 740
 741     let repo_url_schema: Arc<Schema> = Arc::new(
 742         StringSchema::new("Repository URL.")
 743             .format(BACKUP_REPO_URL.clone())
 744             .max_length(256)
 745             .into()
 746     );
 747
 748     let backup_source_schema: Arc<Schema> = Arc::new(
 749         StringSchema::new("Backup source specification ([<label>:<path>]).")
 750             .format(Arc::new(ApiStringFormat::Pattern(&BACKUPSPEC_REGEX)))
 751             .into()
 752     );
 753
 754     let backup_cmd_def = CliCommand::new(
 755         ApiMethod::new(
 756             create_backup,
 757             ObjectSchema::new("Create (host) backup.")
 758                 .required("repository", repo_url_schema.clone())
 759                 .required(
 760                     "backupspec",
 761                     ArraySchema::new(
 762                         "List of backup source specifications ([<label.ext>:<path>] ...)",
 763                         backup_source_schema,
 764                     ).min_length(1)
 765                 )
 766                 .optional(
 767                     "verbose",
 768                     BooleanSchema::new("Verbose output.").default(false))
 769                 .optional(
 770                     "host-id",
 771                     StringSchema::new("Use specified ID for the backup group name ('host/<id>'). The default is the system hostname."))
 772                 .optional(
 773                     "chunk-size",
 774                     IntegerSchema::new("Chunk size in KB. Must be a power of 2.")
 775                         .minimum(64)
 776                         .maximum(4096)
 777                         .default(4096)
 778                 )
 779         ))
 780         .arg_param(vec!["repository", "backupspec"])
 781         .completion_cb("repository", complete_repository)
 782         .completion_cb("backupspec", complete_backup_source)
 783         .completion_cb("chunk-size", complete_chunk_size);
 784
 785     let list_cmd_def = CliCommand::new(
 786         ApiMethod::new(
 787             list_backup_groups,
 788             ObjectSchema::new("List backup groups.")
 789                 .required("repository", repo_url_schema.clone())
 790         ))
 791         .arg_param(vec!["repository"])
 792         .completion_cb("repository", complete_repository);
 793
 794     let snapshots_cmd_def = CliCommand::new(
 795         ApiMethod::new(
 796             list_snapshots,
 797             ObjectSchema::new("List backup snapshots.")
 798                 .required("repository", repo_url_schema.clone())
 799                 .required("group", StringSchema::new("Backup group."))
 800         ))
 801         .arg_param(vec!["repository", "group"])
 802         .completion_cb("group", complete_backup_group)
 803         .completion_cb("repository", complete_repository);
 804
 805     let forget_cmd_def = CliCommand::new(
 806         ApiMethod::new(
 807             forget_snapshots,
 808             ObjectSchema::new("Forget (remove) backup snapshots.")
 809                 .required("repository", repo_url_schema.clone())
 810                 .required("snapshot", StringSchema::new("Snapshot path."))
 811         ))
 812         .arg_param(vec!["repository", "snapshot"])
 813         .completion_cb("repository", complete_repository)
 814         .completion_cb("snapshot", complete_group_or_snapshot);
 815
 816     let garbage_collect_cmd_def = CliCommand::new(
 817         ApiMethod::new(
 818             start_garbage_collection,
 819             ObjectSchema::new("Start garbage collection for a specific repository.")
 820                 .required("repository", repo_url_schema.clone())
 821         ))
 822         .arg_param(vec!["repository"])
 823         .completion_cb("repository", complete_repository);
 824
 825     let restore_cmd_def = CliCommand::new(
 826         ApiMethod::new(
 827             restore,
 828             ObjectSchema::new("Restore backup repository.")
 829                 .required("repository", repo_url_schema.clone())
 830                 .required("snapshot", StringSchema::new("Group/Snapshot path."))
 831                 .required("archive-name", StringSchema::new("Backup archive name."))
 832                 .required("target", StringSchema::new("Target directory path."))
 833         ))
 834         .arg_param(vec!["repository", "snapshot", "archive-name", "target"])
 835         .completion_cb("repository", complete_repository)
 836         .completion_cb("snapshot", complete_group_or_snapshot)
 837         .completion_cb("archive-name", complete_archive_name)
 838         .completion_cb("target", tools::complete_file_name);
 839
 840     let prune_cmd_def = CliCommand::new(
 841         ApiMethod::new(
 842             prune,
 843             proxmox_backup::api2::admin::datastore::add_common_prune_prameters(
 844                 ObjectSchema::new("Prune backup repository.")
 845                     .required("repository", repo_url_schema.clone())
 846             )
 847         ))
 848         .arg_param(vec!["repository"])
 849         .completion_cb("repository", complete_repository);
 850
 851     let cmd_def = CliCommandMap::new()
 852         .insert("backup".to_owned(), backup_cmd_def.into())
 853         .insert("forget".to_owned(), forget_cmd_def.into())
 854         .insert("garbage-collect".to_owned(), garbage_collect_cmd_def.into())
 855         .insert("list".to_owned(), list_cmd_def.into())
 856         .insert("prune".to_owned(), prune_cmd_def.into())
 857         .insert("restore".to_owned(), restore_cmd_def.into())
 858         .insert("snapshots".to_owned(), snapshots_cmd_def.into());
 859
 860     hyper::rt::run(futures::future::lazy(move || {
 861         run_cli_command(cmd_def.into());
 862         Ok(())
 863     }));
 864
 865 }