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