src/api2/admin/datastore.rs

   1 //! Datastore Management
   2
   3 use std::collections::HashSet;
   4 use std::ffi::OsStr;
   5 use std::os::unix::ffi::OsStrExt;
   6 use std::path::PathBuf;
   7
   8 use anyhow::{bail, format_err, Error};
   9 use futures::*;
  10 use hyper::http::request::Parts;
  11 use hyper::{header, Body, Response, StatusCode};
  12 use serde_json::{json, Value};
  13 use tokio_stream::wrappers::ReceiverStream;
  14
  15 use proxmox::api::{
  16     api, ApiResponseFuture, ApiHandler, ApiMethod, Router,
  17     RpcEnvironment, RpcEnvironmentType, Permission
  18 };
  19 use proxmox::api::router::{ReturnType, SubdirMap};
  20 use proxmox::api::schema::*;
  21 use proxmox::tools::fs::{
  22     file_read_firstline, file_read_optional_string, replace_file, CreateOptions,
  23 };
  24 use proxmox::{http_err, identity, list_subdirs_api_method, sortable};
  25
  26 use pxar::accessor::aio::Accessor;
  27 use pxar::EntryKind;
  28
  29 use crate::api2::types::*;
  30 use crate::api2::node::rrd::create_value_from_rrd;
  31 use crate::api2::helpers;
  32 use crate::backup::*;
  33 use crate::config::datastore;
  34 use crate::config::cached_user_info::CachedUserInfo;
  35 use crate::pxar::create_zip;
  36
  37 use crate::server::{jobstate::Job, WorkerTask};
  38 use crate::tools::{
  39     self,
  40     AsyncChannelWriter, AsyncReaderStream, WrappedReaderStream,
  41 };
  42
  43 use crate::config::acl::{
  44     PRIV_DATASTORE_AUDIT,
  45     PRIV_DATASTORE_MODIFY,
  46     PRIV_DATASTORE_READ,
  47     PRIV_DATASTORE_PRUNE,
  48     PRIV_DATASTORE_BACKUP,
  49     PRIV_DATASTORE_VERIFY,
  50 };
  51
  52 const GROUP_NOTES_FILE_NAME: &str = "notes";
  53
  54 fn get_group_note_path(store: &DataStore, group: &BackupGroup) -> PathBuf {
  55     let mut note_path = store.base_path();
  56     note_path.push(group.group_path());
  57     note_path.push(GROUP_NOTES_FILE_NAME);
  58     note_path
  59 }
  60
  61 fn check_priv_or_backup_owner(
  62     store: &DataStore,
  63     group: &BackupGroup,
  64     auth_id: &Authid,
  65     required_privs: u64,
  66 ) -> Result<(), Error> {
  67     let user_info = CachedUserInfo::new()?;
  68     let privs = user_info.lookup_privs(&auth_id, &["datastore", store.name()]);
  69
  70     if privs & required_privs == 0 {
  71         let owner = store.get_owner(group)?;
  72         check_backup_owner(&owner, auth_id)?;
  73     }
  74     Ok(())
  75 }
  76
  77 fn check_backup_owner(
  78     owner: &Authid,
  79     auth_id: &Authid,
  80 ) -> Result<(), Error> {
  81     let correct_owner = owner == auth_id
  82         || (owner.is_token() && &Authid::from(owner.user().clone()) == auth_id);
  83     if !correct_owner {
  84         bail!("backup owner check failed ({} != {})", auth_id, owner);
  85     }
  86     Ok(())
  87 }
  88
  89 fn read_backup_index(
  90     store: &DataStore,
  91     backup_dir: &BackupDir,
  92 ) -> Result<(BackupManifest, Vec<BackupContent>), Error> {
  93
  94     let (manifest, index_size) = store.load_manifest(backup_dir)?;
  95
  96     let mut result = Vec::new();
  97     for item in manifest.files() {
  98         result.push(BackupContent {
  99             filename: item.filename.clone(),
 100             crypt_mode: Some(item.crypt_mode),
 101             size: Some(item.size),
 102         });
 103     }
 104
 105     result.push(BackupContent {
 106         filename: MANIFEST_BLOB_NAME.to_string(),
 107         crypt_mode: match manifest.signature {
 108             Some(_) => Some(CryptMode::SignOnly),
 109             None => Some(CryptMode::None),
 110         },
 111         size: Some(index_size),
 112     });
 113
 114     Ok((manifest, result))
 115 }
 116
 117 fn get_all_snapshot_files(
 118     store: &DataStore,
 119     info: &BackupInfo,
 120 ) -> Result<(BackupManifest, Vec<BackupContent>), Error> {
 121
 122     let (manifest, mut files) = read_backup_index(&store, &info.backup_dir)?;
 123
 124     let file_set = files.iter().fold(HashSet::new(), |mut acc, item| {
 125         acc.insert(item.filename.clone());
 126         acc
 127     });
 128
 129     for file in &info.files {
 130         if file_set.contains(file) { continue; }
 131         files.push(BackupContent {
 132             filename: file.to_string(),
 133             size: None,
 134             crypt_mode: None,
 135         });
 136     }
 137
 138     Ok((manifest, files))
 139 }
 140
 141 #[api(
 142     input: {
 143         properties: {
 144             store: {
 145                 schema: DATASTORE_SCHEMA,
 146             },
 147         },
 148     },
 149     returns: {
 150         type: Array,
 151         description: "Returns the list of backup groups.",
 152         items: {
 153             type: GroupListItem,
 154         }
 155     },
 156     access: {
 157         permission: &Permission::Privilege(
 158             &["datastore", "{store}"],
 159             PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_BACKUP,
 160             true),
 161     },
 162 )]
 163 /// List backup groups.
 164 pub fn list_groups(
 165     store: String,
 166     rpcenv: &mut dyn RpcEnvironment,
 167 ) -> Result<Vec<GroupListItem>, Error> {
 168
 169     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
 170     let user_info = CachedUserInfo::new()?;
 171     let user_privs = user_info.lookup_privs(&auth_id, &["datastore", &store]);
 172
 173     let datastore = DataStore::lookup_datastore(&store)?;
 174     let list_all = (user_privs & PRIV_DATASTORE_AUDIT) != 0;
 175
 176     let backup_groups = BackupInfo::list_backup_groups(&datastore.base_path())?;
 177
 178     let group_info = backup_groups
 179         .into_iter()
 180         .fold(Vec::new(), |mut group_info, group| {
 181             let owner = match datastore.get_owner(&group) {
 182                 Ok(auth_id) => auth_id,
 183                 Err(err) => {
 184                     eprintln!("Failed to get owner of group '{}/{}' - {}",
 185                              &store,
 186                              group,
 187                              err);
 188                     return group_info;
 189                 },
 190             };
 191             if !list_all && check_backup_owner(&owner, &auth_id).is_err() {
 192                 return group_info;
 193             }
 194
 195             let snapshots = match group.list_backups(&datastore.base_path()) {
 196                 Ok(snapshots) => snapshots,
 197                 Err(_) => {
 198                     return group_info;
 199                 },
 200             };
 201
 202             let backup_count: u64 = snapshots.len() as u64;
 203             if backup_count == 0 {
 204                 return group_info;
 205             }
 206
 207             let last_backup = snapshots
 208                 .iter()
 209                 .fold(&snapshots[0], |last, curr| {
 210                     if curr.is_finished()
 211                         && curr.backup_dir.backup_time() > last.backup_dir.backup_time() {
 212                         curr
 213                     } else {
 214                         last
 215                     }
 216                 })
 217                 .to_owned();
 218
 219             let note_path = get_group_note_path(&datastore, &group);
 220             let comment = file_read_firstline(&note_path).ok();
 221
 222             group_info.push(GroupListItem {
 223                 backup_type: group.backup_type().to_string(),
 224                 backup_id: group.backup_id().to_string(),
 225                 last_backup: last_backup.backup_dir.backup_time(),
 226                 owner: Some(owner),
 227                 backup_count,
 228                 files: last_backup.files,
 229                 comment,
 230             });
 231
 232             group_info
 233         });
 234
 235     Ok(group_info)
 236 }
 237
 238 #[api(
 239     input: {
 240         properties: {
 241             store: {
 242                 schema: DATASTORE_SCHEMA,
 243             },
 244             "backup-type": {
 245                 schema: BACKUP_TYPE_SCHEMA,
 246             },
 247             "backup-id": {
 248                 schema: BACKUP_ID_SCHEMA,
 249             },
 250         },
 251     },
 252     access: {
 253         permission: &Permission::Privilege(
 254             &["datastore", "{store}"],
 255             PRIV_DATASTORE_MODIFY| PRIV_DATASTORE_PRUNE,
 256             true),
 257     },
 258 )]
 259 /// Delete backup group including all snapshots.
 260 pub fn delete_group(
 261     store: String,
 262     backup_type: String,
 263     backup_id: String,
 264     _info: &ApiMethod,
 265     rpcenv: &mut dyn RpcEnvironment,
 266 ) -> Result<Value, Error> {
 267
 268     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
 269
 270     let group = BackupGroup::new(backup_type, backup_id);
 271     let datastore = DataStore::lookup_datastore(&store)?;
 272
 273     check_priv_or_backup_owner(&datastore, &group, &auth_id, PRIV_DATASTORE_MODIFY)?;
 274
 275     datastore.remove_backup_group(&group)?;
 276
 277     Ok(Value::Null)
 278 }
 279
 280 #[api(
 281     input: {
 282         properties: {
 283             store: {
 284                 schema: DATASTORE_SCHEMA,
 285             },
 286             "backup-type": {
 287                 schema: BACKUP_TYPE_SCHEMA,
 288             },
 289             "backup-id": {
 290                 schema: BACKUP_ID_SCHEMA,
 291             },
 292             "backup-time": {
 293                 schema: BACKUP_TIME_SCHEMA,
 294             },
 295         },
 296     },
 297     returns: {
 298         type: Array,
 299         description: "Returns the list of archive files inside a backup snapshots.",
 300         items: {
 301             type: BackupContent,
 302         }
 303     },
 304     access: {
 305         permission: &Permission::Privilege(
 306             &["datastore", "{store}"],
 307             PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP,
 308             true),
 309     },
 310 )]
 311 /// List snapshot files.
 312 pub fn list_snapshot_files(
 313     store: String,
 314     backup_type: String,
 315     backup_id: String,
 316     backup_time: i64,
 317     _info: &ApiMethod,
 318     rpcenv: &mut dyn RpcEnvironment,
 319 ) -> Result<Vec<BackupContent>, Error> {
 320
 321     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
 322     let datastore = DataStore::lookup_datastore(&store)?;
 323
 324     let snapshot = BackupDir::new(backup_type, backup_id, backup_time)?;
 325
 326     check_priv_or_backup_owner(&datastore, snapshot.group(), &auth_id, PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_READ)?;
 327
 328     let info = BackupInfo::new(&datastore.base_path(), snapshot)?;
 329
 330     let (_manifest, files) = get_all_snapshot_files(&datastore, &info)?;
 331
 332     Ok(files)
 333 }
 334
 335 #[api(
 336     input: {
 337         properties: {
 338             store: {
 339                 schema: DATASTORE_SCHEMA,
 340             },
 341             "backup-type": {
 342                 schema: BACKUP_TYPE_SCHEMA,
 343             },
 344             "backup-id": {
 345                 schema: BACKUP_ID_SCHEMA,
 346             },
 347             "backup-time": {
 348                 schema: BACKUP_TIME_SCHEMA,
 349             },
 350         },
 351     },
 352     access: {
 353         permission: &Permission::Privilege(
 354             &["datastore", "{store}"],
 355             PRIV_DATASTORE_MODIFY| PRIV_DATASTORE_PRUNE,
 356             true),
 357     },
 358 )]
 359 /// Delete backup snapshot.
 360 pub fn delete_snapshot(
 361     store: String,
 362     backup_type: String,
 363     backup_id: String,
 364     backup_time: i64,
 365     _info: &ApiMethod,
 366     rpcenv: &mut dyn RpcEnvironment,
 367 ) -> Result<Value, Error> {
 368
 369     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
 370
 371     let snapshot = BackupDir::new(backup_type, backup_id, backup_time)?;
 372     let datastore = DataStore::lookup_datastore(&store)?;
 373
 374     check_priv_or_backup_owner(&datastore, snapshot.group(), &auth_id, PRIV_DATASTORE_MODIFY)?;
 375
 376     datastore.remove_backup_dir(&snapshot, false)?;
 377
 378     Ok(Value::Null)
 379 }
 380
 381 #[api(
 382     input: {
 383         properties: {
 384             store: {
 385                 schema: DATASTORE_SCHEMA,
 386             },
 387             "backup-type": {
 388                 optional: true,
 389                 schema: BACKUP_TYPE_SCHEMA,
 390             },
 391             "backup-id": {
 392                 optional: true,
 393                 schema: BACKUP_ID_SCHEMA,
 394             },
 395         },
 396     },
 397     returns: {
 398         type: Array,
 399         description: "Returns the list of snapshots.",
 400         items: {
 401             type: SnapshotListItem,
 402         }
 403     },
 404     access: {
 405         permission: &Permission::Privilege(
 406             &["datastore", "{store}"],
 407             PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_BACKUP,
 408             true),
 409     },
 410 )]
 411 /// List backup snapshots.
 412 pub fn list_snapshots (
 413     store: String,
 414     backup_type: Option<String>,
 415     backup_id: Option<String>,
 416     _param: Value,
 417     _info: &ApiMethod,
 418     rpcenv: &mut dyn RpcEnvironment,
 419 ) -> Result<Vec<SnapshotListItem>, Error> {
 420
 421     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
 422     let user_info = CachedUserInfo::new()?;
 423     let user_privs = user_info.lookup_privs(&auth_id, &["datastore", &store]);
 424
 425     let list_all = (user_privs & PRIV_DATASTORE_AUDIT) != 0;
 426
 427     let datastore = DataStore::lookup_datastore(&store)?;
 428
 429     let base_path = datastore.base_path();
 430
 431     let groups = match (backup_type, backup_id) {
 432         (Some(backup_type), Some(backup_id)) => {
 433             let mut groups = Vec::with_capacity(1);
 434             groups.push(BackupGroup::new(backup_type, backup_id));
 435             groups
 436         },
 437         (Some(backup_type), None) => {
 438             BackupInfo::list_backup_groups(&base_path)?
 439                 .into_iter()
 440                 .filter(|group| group.backup_type() == backup_type)
 441                 .collect()
 442         },
 443         (None, Some(backup_id)) => {
 444             BackupInfo::list_backup_groups(&base_path)?
 445                 .into_iter()
 446                 .filter(|group| group.backup_id() == backup_id)
 447                 .collect()
 448         },
 449         _ => BackupInfo::list_backup_groups(&base_path)?,
 450     };
 451
 452     let info_to_snapshot_list_item = |group: &BackupGroup, owner, info: BackupInfo| {
 453         let backup_type = group.backup_type().to_string();
 454         let backup_id = group.backup_id().to_string();
 455         let backup_time = info.backup_dir.backup_time();
 456
 457         match get_all_snapshot_files(&datastore, &info) {
 458             Ok((manifest, files)) => {
 459                 // extract the first line from notes
 460                 let comment: Option<String> = manifest.unprotected["notes"]
 461                     .as_str()
 462                     .and_then(|notes| notes.lines().next())
 463                     .map(String::from);
 464
 465                 let fingerprint = match manifest.fingerprint() {
 466                     Ok(fp) => fp,
 467                     Err(err) => {
 468                         eprintln!("error parsing fingerprint: '{}'", err);
 469                         None
 470                     },
 471                 };
 472
 473                 let verification = manifest.unprotected["verify_state"].clone();
 474                 let verification: Option<SnapshotVerifyState> = match serde_json::from_value(verification) {
 475                     Ok(verify) => verify,
 476                     Err(err) => {
 477                         eprintln!("error parsing verification state : '{}'", err);
 478                         None
 479                     }
 480                 };
 481
 482                 let size = Some(files.iter().map(|x| x.size.unwrap_or(0)).sum());
 483
 484                 SnapshotListItem {
 485                     backup_type,
 486                     backup_id,
 487                     backup_time,
 488                     comment,
 489                     verification,
 490                     fingerprint,
 491                     files,
 492                     size,
 493                     owner,
 494                 }
 495             },
 496             Err(err) => {
 497                 eprintln!("error during snapshot file listing: '{}'", err);
 498                 let files = info
 499                         .files
 500                         .into_iter()
 501                         .map(|filename| BackupContent {
 502                             filename,
 503                             size: None,
 504                             crypt_mode: None,
 505                         })
 506                         .collect();
 507
 508                 SnapshotListItem {
 509                     backup_type,
 510                     backup_id,
 511                     backup_time,
 512                     comment: None,
 513                     verification: None,
 514                     fingerprint: None,
 515                     files,
 516                     size: None,
 517                     owner,
 518                 }
 519             },
 520         }
 521     };
 522
 523     groups
 524         .iter()
 525         .try_fold(Vec::new(), |mut snapshots, group| {
 526             let owner = match datastore.get_owner(group) {
 527                 Ok(auth_id) => auth_id,
 528                 Err(err) => {
 529                     eprintln!("Failed to get owner of group '{}/{}' - {}",
 530                               &store,
 531                               group,
 532                               err);
 533                     return Ok(snapshots);
 534                 },
 535             };
 536
 537             if !list_all && check_backup_owner(&owner, &auth_id).is_err() {
 538                 return Ok(snapshots);
 539             }
 540
 541             let group_backups = group.list_backups(&datastore.base_path())?;
 542
 543             snapshots.extend(
 544                 group_backups
 545                     .into_iter()
 546                     .map(|info| info_to_snapshot_list_item(&group, Some(owner.clone()), info))
 547             );
 548
 549             Ok(snapshots)
 550         })
 551 }
 552
 553 fn get_snapshots_count(store: &DataStore, filter_owner: Option<&Authid>) -> Result<Counts, Error> {
 554     let base_path = store.base_path();
 555     let groups = BackupInfo::list_backup_groups(&base_path)?;
 556
 557     groups.iter()
 558         .filter(|group| {
 559             let owner = match store.get_owner(&group) {
 560                 Ok(owner) => owner,
 561                 Err(err) => {
 562                     eprintln!("Failed to get owner of group '{}/{}' - {}",
 563                               store.name(),
 564                               group,
 565                               err);
 566                     return false;
 567                 },
 568             };
 569
 570             match filter_owner {
 571                 Some(filter) => check_backup_owner(&owner, filter).is_ok(),
 572                 None => true,
 573             }
 574         })
 575         .try_fold(Counts::default(), |mut counts, group| {
 576             let snapshot_count = group.list_backups(&base_path)?.len() as u64;
 577
 578             let type_count = match group.backup_type() {
 579                 "ct" => counts.ct.get_or_insert(Default::default()),
 580                 "vm" => counts.vm.get_or_insert(Default::default()),
 581                 "host" => counts.host.get_or_insert(Default::default()),
 582                 _ => counts.other.get_or_insert(Default::default()),
 583             };
 584
 585             type_count.groups += 1;
 586             type_count.snapshots += snapshot_count;
 587
 588             Ok(counts)
 589         })
 590 }
 591
 592 #[api(
 593     input: {
 594         properties: {
 595             store: {
 596                 schema: DATASTORE_SCHEMA,
 597             },
 598             verbose: {
 599                 type: bool,
 600                 default: false,
 601                 optional: true,
 602                 description: "Include additional information like snapshot counts and GC status.",
 603             },
 604         },
 605
 606     },
 607     returns: {
 608         type: DataStoreStatus,
 609     },
 610     access: {
 611         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_BACKUP, true),
 612     },
 613 )]
 614 /// Get datastore status.
 615 pub fn status(
 616     store: String,
 617     verbose: bool,
 618     _info: &ApiMethod,
 619     rpcenv: &mut dyn RpcEnvironment,
 620 ) -> Result<DataStoreStatus, Error> {
 621     let datastore = DataStore::lookup_datastore(&store)?;
 622     let storage = crate::tools::disks::disk_usage(&datastore.base_path())?;
 623     let (counts, gc_status) = if verbose {
 624         let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
 625         let user_info = CachedUserInfo::new()?;
 626
 627         let store_privs = user_info.lookup_privs(&auth_id, &["datastore", &store]);
 628         let filter_owner = if store_privs & PRIV_DATASTORE_AUDIT != 0 {
 629             None
 630         } else {
 631             Some(&auth_id)
 632         };
 633
 634         let counts = Some(get_snapshots_count(&datastore, filter_owner)?);
 635         let gc_status = Some(datastore.last_gc_status());
 636
 637         (counts, gc_status)
 638     } else {
 639         (None, None)
 640     };
 641
 642     Ok(DataStoreStatus {
 643         total: storage.total,
 644         used: storage.used,
 645         avail: storage.avail,
 646         gc_status,
 647         counts,
 648     })
 649 }
 650
 651 #[api(
 652     input: {
 653         properties: {
 654             store: {
 655                 schema: DATASTORE_SCHEMA,
 656             },
 657             "backup-type": {
 658                 schema: BACKUP_TYPE_SCHEMA,
 659                 optional: true,
 660             },
 661             "backup-id": {
 662                 schema: BACKUP_ID_SCHEMA,
 663                 optional: true,
 664             },
 665             "ignore-verified": {
 666                 schema: IGNORE_VERIFIED_BACKUPS_SCHEMA,
 667                 optional: true,
 668             },
 669             "outdated-after": {
 670                 schema: VERIFICATION_OUTDATED_AFTER_SCHEMA,
 671                 optional: true,
 672             },
 673             "backup-time": {
 674                 schema: BACKUP_TIME_SCHEMA,
 675                 optional: true,
 676             },
 677         },
 678     },
 679     returns: {
 680         schema: UPID_SCHEMA,
 681     },
 682     access: {
 683         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_VERIFY | PRIV_DATASTORE_BACKUP, true),
 684     },
 685 )]
 686 /// Verify backups.
 687 ///
 688 /// This function can verify a single backup snapshot, all backup from a backup group,
 689 /// or all backups in the datastore.
 690 pub fn verify(
 691     store: String,
 692     backup_type: Option<String>,
 693     backup_id: Option<String>,
 694     backup_time: Option<i64>,
 695     ignore_verified: Option<bool>,
 696     outdated_after: Option<i64>,
 697     rpcenv: &mut dyn RpcEnvironment,
 698 ) -> Result<Value, Error> {
 699     let datastore = DataStore::lookup_datastore(&store)?;
 700     let ignore_verified = ignore_verified.unwrap_or(true);
 701
 702     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
 703     let worker_id;
 704
 705     let mut backup_dir = None;
 706     let mut backup_group = None;
 707     let mut worker_type = "verify";
 708
 709     match (backup_type, backup_id, backup_time) {
 710         (Some(backup_type), Some(backup_id), Some(backup_time)) => {
 711             worker_id = format!("{}:{}/{}/{:08X}", store, backup_type, backup_id, backup_time);
 712             let dir = BackupDir::new(backup_type, backup_id, backup_time)?;
 713
 714             check_priv_or_backup_owner(&datastore, dir.group(), &auth_id, PRIV_DATASTORE_VERIFY)?;
 715
 716             backup_dir = Some(dir);
 717             worker_type = "verify_snapshot";
 718         }
 719         (Some(backup_type), Some(backup_id), None) => {
 720             worker_id = format!("{}:{}/{}", store, backup_type, backup_id);
 721             let group = BackupGroup::new(backup_type, backup_id);
 722
 723             check_priv_or_backup_owner(&datastore, &group, &auth_id, PRIV_DATASTORE_VERIFY)?;
 724
 725             backup_group = Some(group);
 726             worker_type = "verify_group";
 727         }
 728         (None, None, None) => {
 729             worker_id = store.clone();
 730         }
 731         _ => bail!("parameters do not specify a backup group or snapshot"),
 732     }
 733
 734     let to_stdout = rpcenv.env_type() == RpcEnvironmentType::CLI;
 735
 736     let upid_str = WorkerTask::new_thread(
 737         worker_type,
 738         Some(worker_id),
 739         auth_id.clone(),
 740         to_stdout,
 741         move |worker| {
 742             let verify_worker = crate::backup::VerifyWorker::new(worker.clone(), datastore);
 743             let failed_dirs = if let Some(backup_dir) = backup_dir {
 744                 let mut res = Vec::new();
 745                 if !verify_backup_dir(
 746                     &verify_worker,
 747                     &backup_dir,
 748                     worker.upid().clone(),
 749                     Some(&move |manifest| {
 750                         verify_filter(ignore_verified, outdated_after, manifest)
 751                     }),
 752                 )? {
 753                     res.push(backup_dir.to_string());
 754                 }
 755                 res
 756             } else if let Some(backup_group) = backup_group {
 757                 let failed_dirs = verify_backup_group(
 758                     &verify_worker,
 759                     &backup_group,
 760                     &mut StoreProgress::new(1),
 761                     worker.upid(),
 762                     Some(&move |manifest| {
 763                         verify_filter(ignore_verified, outdated_after, manifest)
 764                     }),
 765                 )?;
 766                 failed_dirs
 767             } else {
 768                 let privs = CachedUserInfo::new()?
 769                     .lookup_privs(&auth_id, &["datastore", &store]);
 770
 771                 let owner = if privs & PRIV_DATASTORE_VERIFY == 0 {
 772                     Some(auth_id)
 773                 } else {
 774                     None
 775                 };
 776
 777                 verify_all_backups(
 778                     &verify_worker,
 779                     worker.upid(),
 780                     owner,
 781                     Some(&move |manifest| {
 782                         verify_filter(ignore_verified, outdated_after, manifest)
 783                     }),
 784                 )?
 785             };
 786             if !failed_dirs.is_empty() {
 787                 worker.log("Failed to verify the following snapshots/groups:");
 788                 for dir in failed_dirs {
 789                     worker.log(format!("\t{}", dir));
 790                 }
 791                 bail!("verification failed - please check the log for details");
 792             }
 793             Ok(())
 794         },
 795     )?;
 796
 797     Ok(json!(upid_str))
 798 }
 799
 800 #[macro_export]
 801 macro_rules! add_common_prune_prameters {
 802     ( [ $( $list1:tt )* ] ) => {
 803         add_common_prune_prameters!([$( $list1 )* ] ,  [])
 804     };
 805     ( [ $( $list1:tt )* ] ,  [ $( $list2:tt )* ] ) => {
 806         [
 807             $( $list1 )*
 808             (
 809                 "keep-daily",
 810                 true,
 811                 &PRUNE_SCHEMA_KEEP_DAILY,
 812             ),
 813             (
 814                 "keep-hourly",
 815                 true,
 816                 &PRUNE_SCHEMA_KEEP_HOURLY,
 817             ),
 818             (
 819                 "keep-last",
 820                 true,
 821                 &PRUNE_SCHEMA_KEEP_LAST,
 822             ),
 823             (
 824                 "keep-monthly",
 825                 true,
 826                 &PRUNE_SCHEMA_KEEP_MONTHLY,
 827             ),
 828             (
 829                 "keep-weekly",
 830                 true,
 831                 &PRUNE_SCHEMA_KEEP_WEEKLY,
 832             ),
 833             (
 834                 "keep-yearly",
 835                 true,
 836                 &PRUNE_SCHEMA_KEEP_YEARLY,
 837             ),
 838             $( $list2 )*
 839         ]
 840     }
 841 }
 842
 843 pub const API_RETURN_SCHEMA_PRUNE: Schema = ArraySchema::new(
 844     "Returns the list of snapshots and a flag indicating if there are kept or removed.",
 845     &PruneListItem::API_SCHEMA
 846 ).schema();
 847
 848 pub const API_METHOD_PRUNE: ApiMethod = ApiMethod::new(
 849     &ApiHandler::Sync(&prune),
 850     &ObjectSchema::new(
 851         "Prune the datastore.",
 852         &add_common_prune_prameters!([
 853             ("backup-id", false, &BACKUP_ID_SCHEMA),
 854             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
 855             ("dry-run", true, &BooleanSchema::new(
 856                 "Just show what prune would do, but do not delete anything.")
 857              .schema()
 858             ),
 859         ],[
 860             ("store", false, &DATASTORE_SCHEMA),
 861         ])
 862     ))
 863     .returns(ReturnType::new(false, &API_RETURN_SCHEMA_PRUNE))
 864     .access(None, &Permission::Privilege(
 865     &["datastore", "{store}"],
 866     PRIV_DATASTORE_MODIFY | PRIV_DATASTORE_PRUNE,
 867     true)
 868 );
 869
 870 pub fn prune(
 871     param: Value,
 872     _info: &ApiMethod,
 873     rpcenv: &mut dyn RpcEnvironment,
 874 ) -> Result<Value, Error> {
 875
 876     let store = tools::required_string_param(&param, "store")?;
 877     let backup_type = tools::required_string_param(&param, "backup-type")?;
 878     let backup_id = tools::required_string_param(&param, "backup-id")?;
 879
 880     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
 881
 882     let dry_run = param["dry-run"].as_bool().unwrap_or(false);
 883
 884     let group = BackupGroup::new(backup_type, backup_id);
 885
 886     let datastore = DataStore::lookup_datastore(&store)?;
 887
 888     check_priv_or_backup_owner(&datastore, &group, &auth_id, PRIV_DATASTORE_MODIFY)?;
 889
 890     let prune_options = PruneOptions {
 891         keep_last: param["keep-last"].as_u64(),
 892         keep_hourly: param["keep-hourly"].as_u64(),
 893         keep_daily: param["keep-daily"].as_u64(),
 894         keep_weekly: param["keep-weekly"].as_u64(),
 895         keep_monthly: param["keep-monthly"].as_u64(),
 896         keep_yearly: param["keep-yearly"].as_u64(),
 897     };
 898
 899     let worker_id = format!("{}:{}/{}", store, backup_type, backup_id);
 900
 901     let mut prune_result = Vec::new();
 902
 903     let list = group.list_backups(&datastore.base_path())?;
 904
 905     let mut prune_info = compute_prune_info(list, &prune_options)?;
 906
 907     prune_info.reverse(); // delete older snapshots first
 908
 909     let keep_all = !prune_options.keeps_something();
 910
 911     if dry_run {
 912         for (info, mut keep) in prune_info {
 913             if keep_all { keep = true; }
 914
 915             let backup_time = info.backup_dir.backup_time();
 916             let group = info.backup_dir.group();
 917
 918             prune_result.push(json!({
 919                 "backup-type": group.backup_type(),
 920                 "backup-id": group.backup_id(),
 921                 "backup-time": backup_time,
 922                 "keep": keep,
 923             }));
 924         }
 925         return Ok(json!(prune_result));
 926     }
 927
 928
 929     // We use a WorkerTask just to have a task log, but run synchrounously
 930     let worker = WorkerTask::new("prune", Some(worker_id), auth_id, true)?;
 931
 932     if keep_all {
 933         worker.log("No prune selection - keeping all files.");
 934     } else {
 935         worker.log(format!("retention options: {}", prune_options.cli_options_string()));
 936         worker.log(format!("Starting prune on store \"{}\" group \"{}/{}\"",
 937                             store, backup_type, backup_id));
 938     }
 939
 940     for (info, mut keep) in prune_info {
 941         if keep_all { keep = true; }
 942
 943         let backup_time = info.backup_dir.backup_time();
 944         let timestamp = info.backup_dir.backup_time_string();
 945         let group = info.backup_dir.group();
 946
 947
 948         let msg = format!(
 949             "{}/{}/{} {}",
 950             group.backup_type(),
 951             group.backup_id(),
 952             timestamp,
 953             if keep { "keep" } else { "remove" },
 954         );
 955
 956         worker.log(msg);
 957
 958         prune_result.push(json!({
 959             "backup-type": group.backup_type(),
 960             "backup-id": group.backup_id(),
 961             "backup-time": backup_time,
 962             "keep": keep,
 963         }));
 964
 965         if !(dry_run || keep) {
 966             if let Err(err) = datastore.remove_backup_dir(&info.backup_dir, false) {
 967                 worker.warn(
 968                     format!(
 969                         "failed to remove dir {:?}: {}",
 970                         info.backup_dir.relative_path(), err
 971                     )
 972                 );
 973             }
 974         }
 975     }
 976
 977     worker.log_result(&Ok(()));
 978
 979     Ok(json!(prune_result))
 980 }
 981
 982 #[api(
 983     input: {
 984         properties: {
 985             store: {
 986                 schema: DATASTORE_SCHEMA,
 987             },
 988         },
 989     },
 990     returns: {
 991         schema: UPID_SCHEMA,
 992     },
 993     access: {
 994         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_MODIFY, false),
 995     },
 996 )]
 997 /// Start garbage collection.
 998 pub fn start_garbage_collection(
 999     store: String,
1000     _info: &ApiMethod,
1001     rpcenv: &mut dyn RpcEnvironment,
1002 ) -> Result<Value, Error> {
1003
1004     let datastore = DataStore::lookup_datastore(&store)?;
1005     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1006
1007     let job =  Job::new("garbage_collection", &store)
1008         .map_err(|_| format_err!("garbage collection already running"))?;
1009
1010     let to_stdout = rpcenv.env_type() == RpcEnvironmentType::CLI;
1011
1012     let upid_str = crate::server::do_garbage_collection_job(job, datastore, &auth_id, None, to_stdout)
1013         .map_err(|err| format_err!("unable to start garbage collection job on datastore {} - {}", store, err))?;
1014
1015     Ok(json!(upid_str))
1016 }
1017
1018 #[api(
1019     input: {
1020         properties: {
1021             store: {
1022                 schema: DATASTORE_SCHEMA,
1023             },
1024         },
1025     },
1026     returns: {
1027         type: GarbageCollectionStatus,
1028     },
1029     access: {
1030         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_AUDIT, false),
1031     },
1032 )]
1033 /// Garbage collection status.
1034 pub fn garbage_collection_status(
1035     store: String,
1036     _info: &ApiMethod,
1037     _rpcenv: &mut dyn RpcEnvironment,
1038 ) -> Result<GarbageCollectionStatus, Error> {
1039
1040     let datastore = DataStore::lookup_datastore(&store)?;
1041
1042     let status = datastore.last_gc_status();
1043
1044     Ok(status)
1045 }
1046
1047 #[api(
1048     returns: {
1049         description: "List the accessible datastores.",
1050         type: Array,
1051         items: { type: DataStoreListItem },
1052     },
1053     access: {
1054         permission: &Permission::Anybody,
1055     },
1056 )]
1057 /// Datastore list
1058 pub fn get_datastore_list(
1059     _param: Value,
1060     _info: &ApiMethod,
1061     rpcenv: &mut dyn RpcEnvironment,
1062 ) -> Result<Vec<DataStoreListItem>, Error> {
1063
1064     let (config, _digest) = datastore::config()?;
1065
1066     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1067     let user_info = CachedUserInfo::new()?;
1068
1069     let mut list = Vec::new();
1070
1071     for (store, (_, data)) in &config.sections {
1072         let user_privs = user_info.lookup_privs(&auth_id, &["datastore", &store]);
1073         let allowed = (user_privs & (PRIV_DATASTORE_AUDIT| PRIV_DATASTORE_BACKUP)) != 0;
1074         if allowed {
1075             list.push(
1076                 DataStoreListItem {
1077                     store: store.clone(),
1078                     comment: data["comment"].as_str().map(String::from),
1079                 }
1080             );
1081         }
1082     }
1083
1084     Ok(list)
1085 }
1086
1087 #[sortable]
1088 pub const API_METHOD_DOWNLOAD_FILE: ApiMethod = ApiMethod::new(
1089     &ApiHandler::AsyncHttp(&download_file),
1090     &ObjectSchema::new(
1091         "Download single raw file from backup snapshot.",
1092         &sorted!([
1093             ("store", false, &DATASTORE_SCHEMA),
1094             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
1095             ("backup-id", false,  &BACKUP_ID_SCHEMA),
1096             ("backup-time", false, &BACKUP_TIME_SCHEMA),
1097             ("file-name", false, &BACKUP_ARCHIVE_NAME_SCHEMA),
1098         ]),
1099     )
1100 ).access(None, &Permission::Privilege(
1101     &["datastore", "{store}"],
1102     PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP,
1103     true)
1104 );
1105
1106 pub fn download_file(
1107     _parts: Parts,
1108     _req_body: Body,
1109     param: Value,
1110     _info: &ApiMethod,
1111     rpcenv: Box<dyn RpcEnvironment>,
1112 ) -> ApiResponseFuture {
1113
1114     async move {
1115         let store = tools::required_string_param(&param, "store")?;
1116         let datastore = DataStore::lookup_datastore(store)?;
1117
1118         let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1119
1120         let file_name = tools::required_string_param(&param, "file-name")?.to_owned();
1121
1122         let backup_type = tools::required_string_param(&param, "backup-type")?;
1123         let backup_id = tools::required_string_param(&param, "backup-id")?;
1124         let backup_time = tools::required_integer_param(&param, "backup-time")?;
1125
1126         let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
1127
1128         check_priv_or_backup_owner(&datastore, backup_dir.group(), &auth_id, PRIV_DATASTORE_READ)?;
1129
1130         println!("Download {} from {} ({}/{})", file_name, store, backup_dir, file_name);
1131
1132         let mut path = datastore.base_path();
1133         path.push(backup_dir.relative_path());
1134         path.push(&file_name);
1135
1136         let file = tokio::fs::File::open(&path)
1137             .await
1138             .map_err(|err| http_err!(BAD_REQUEST, "File open failed: {}", err))?;
1139
1140         let payload = tokio_util::codec::FramedRead::new(file, tokio_util::codec::BytesCodec::new())
1141             .map_ok(|bytes| bytes.freeze())
1142             .map_err(move |err| {
1143                 eprintln!("error during streaming of '{:?}' - {}", &path, err);
1144                 err
1145             });
1146         let body = Body::wrap_stream(payload);
1147
1148         // fixme: set other headers ?
1149         Ok(Response::builder()
1150            .status(StatusCode::OK)
1151            .header(header::CONTENT_TYPE, "application/octet-stream")
1152            .body(body)
1153            .unwrap())
1154     }.boxed()
1155 }
1156
1157 #[sortable]
1158 pub const API_METHOD_DOWNLOAD_FILE_DECODED: ApiMethod = ApiMethod::new(
1159     &ApiHandler::AsyncHttp(&download_file_decoded),
1160     &ObjectSchema::new(
1161         "Download single decoded file from backup snapshot. Only works if it's not encrypted.",
1162         &sorted!([
1163             ("store", false, &DATASTORE_SCHEMA),
1164             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
1165             ("backup-id", false,  &BACKUP_ID_SCHEMA),
1166             ("backup-time", false, &BACKUP_TIME_SCHEMA),
1167             ("file-name", false, &BACKUP_ARCHIVE_NAME_SCHEMA),
1168         ]),
1169     )
1170 ).access(None, &Permission::Privilege(
1171     &["datastore", "{store}"],
1172     PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP,
1173     true)
1174 );
1175
1176 pub fn download_file_decoded(
1177     _parts: Parts,
1178     _req_body: Body,
1179     param: Value,
1180     _info: &ApiMethod,
1181     rpcenv: Box<dyn RpcEnvironment>,
1182 ) -> ApiResponseFuture {
1183
1184     async move {
1185         let store = tools::required_string_param(&param, "store")?;
1186         let datastore = DataStore::lookup_datastore(store)?;
1187
1188         let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1189
1190         let file_name = tools::required_string_param(&param, "file-name")?.to_owned();
1191
1192         let backup_type = tools::required_string_param(&param, "backup-type")?;
1193         let backup_id = tools::required_string_param(&param, "backup-id")?;
1194         let backup_time = tools::required_integer_param(&param, "backup-time")?;
1195
1196         let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
1197
1198         check_priv_or_backup_owner(&datastore, backup_dir.group(), &auth_id, PRIV_DATASTORE_READ)?;
1199
1200         let (manifest, files) = read_backup_index(&datastore, &backup_dir)?;
1201         for file in files {
1202             if file.filename == file_name && file.crypt_mode == Some(CryptMode::Encrypt) {
1203                 bail!("cannot decode '{}' - is encrypted", file_name);
1204             }
1205         }
1206
1207         println!("Download {} from {} ({}/{})", file_name, store, backup_dir, file_name);
1208
1209         let mut path = datastore.base_path();
1210         path.push(backup_dir.relative_path());
1211         path.push(&file_name);
1212
1213         let extension = file_name.rsplitn(2, '.').next().unwrap();
1214
1215         let body = match extension {
1216             "didx" => {
1217                 let index = DynamicIndexReader::open(&path)
1218                     .map_err(|err| format_err!("unable to read dynamic index '{:?}' - {}", &path, err))?;
1219                 let (csum, size) = index.compute_csum();
1220                 manifest.verify_file(&file_name, &csum, size)?;
1221
1222                 let chunk_reader = LocalChunkReader::new(datastore, None, CryptMode::None);
1223                 let reader = CachedChunkReader::new(chunk_reader, index, 1).seekable();
1224                 Body::wrap_stream(AsyncReaderStream::new(reader)
1225                     .map_err(move |err| {
1226                         eprintln!("error during streaming of '{:?}' - {}", path, err);
1227                         err
1228                     }))
1229             },
1230             "fidx" => {
1231                 let index = FixedIndexReader::open(&path)
1232                     .map_err(|err| format_err!("unable to read fixed index '{:?}' - {}", &path, err))?;
1233
1234                 let (csum, size) = index.compute_csum();
1235                 manifest.verify_file(&file_name, &csum, size)?;
1236
1237                 let chunk_reader = LocalChunkReader::new(datastore, None, CryptMode::None);
1238                 let reader = CachedChunkReader::new(chunk_reader, index, 1).seekable();
1239                 Body::wrap_stream(AsyncReaderStream::with_buffer_size(reader, 4*1024*1024)
1240                     .map_err(move |err| {
1241                         eprintln!("error during streaming of '{:?}' - {}", path, err);
1242                         err
1243                     }))
1244             },
1245             "blob" => {
1246                 let file = std::fs::File::open(&path)
1247                     .map_err(|err| http_err!(BAD_REQUEST, "File open failed: {}", err))?;
1248
1249                 // FIXME: load full blob to verify index checksum?
1250
1251                 Body::wrap_stream(
1252                     WrappedReaderStream::new(DataBlobReader::new(file, None)?)
1253                         .map_err(move |err| {
1254                             eprintln!("error during streaming of '{:?}' - {}", path, err);
1255                             err
1256                         })
1257                 )
1258             },
1259             extension => {
1260                 bail!("cannot download '{}' files", extension);
1261             },
1262         };
1263
1264         // fixme: set other headers ?
1265         Ok(Response::builder()
1266            .status(StatusCode::OK)
1267            .header(header::CONTENT_TYPE, "application/octet-stream")
1268            .body(body)
1269            .unwrap())
1270     }.boxed()
1271 }
1272
1273 #[sortable]
1274 pub const API_METHOD_UPLOAD_BACKUP_LOG: ApiMethod = ApiMethod::new(
1275     &ApiHandler::AsyncHttp(&upload_backup_log),
1276     &ObjectSchema::new(
1277         "Upload the client backup log file into a backup snapshot ('client.log.blob').",
1278         &sorted!([
1279             ("store", false, &DATASTORE_SCHEMA),
1280             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
1281             ("backup-id", false, &BACKUP_ID_SCHEMA),
1282             ("backup-time", false, &BACKUP_TIME_SCHEMA),
1283         ]),
1284     )
1285 ).access(
1286     Some("Only the backup creator/owner is allowed to do this."),
1287     &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_BACKUP, false)
1288 );
1289
1290 pub fn upload_backup_log(
1291     _parts: Parts,
1292     req_body: Body,
1293     param: Value,
1294     _info: &ApiMethod,
1295     rpcenv: Box<dyn RpcEnvironment>,
1296 ) -> ApiResponseFuture {
1297
1298     async move {
1299         let store = tools::required_string_param(&param, "store")?;
1300         let datastore = DataStore::lookup_datastore(store)?;
1301
1302         let file_name =  CLIENT_LOG_BLOB_NAME;
1303
1304         let backup_type = tools::required_string_param(&param, "backup-type")?;
1305         let backup_id = tools::required_string_param(&param, "backup-id")?;
1306         let backup_time = tools::required_integer_param(&param, "backup-time")?;
1307
1308         let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
1309
1310         let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1311         let owner = datastore.get_owner(backup_dir.group())?;
1312         check_backup_owner(&owner, &auth_id)?;
1313
1314         let mut path = datastore.base_path();
1315         path.push(backup_dir.relative_path());
1316         path.push(&file_name);
1317
1318         if path.exists() {
1319             bail!("backup already contains a log.");
1320         }
1321
1322         println!("Upload backup log to {}/{}/{}/{}/{}", store,
1323                  backup_type, backup_id, backup_dir.backup_time_string(), file_name);
1324
1325         let data = req_body
1326             .map_err(Error::from)
1327             .try_fold(Vec::new(), |mut acc, chunk| {
1328                 acc.extend_from_slice(&*chunk);
1329                 future::ok::<_, Error>(acc)
1330             })
1331             .await?;
1332
1333         // always verify blob/CRC at server side
1334         let blob = DataBlob::load_from_reader(&mut &data[..])?;
1335
1336         replace_file(&path, blob.raw_data(), CreateOptions::new())?;
1337
1338         // fixme: use correct formatter
1339         Ok(crate::server::formatter::json_response(Ok(Value::Null)))
1340     }.boxed()
1341 }
1342
1343 #[api(
1344     input: {
1345         properties: {
1346             store: {
1347                 schema: DATASTORE_SCHEMA,
1348             },
1349             "backup-type": {
1350                 schema: BACKUP_TYPE_SCHEMA,
1351             },
1352             "backup-id": {
1353                 schema: BACKUP_ID_SCHEMA,
1354             },
1355             "backup-time": {
1356                 schema: BACKUP_TIME_SCHEMA,
1357             },
1358             "filepath": {
1359                 description: "Base64 encoded path.",
1360                 type: String,
1361             }
1362         },
1363     },
1364     access: {
1365         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP, true),
1366     },
1367 )]
1368 /// Get the entries of the given path of the catalog
1369 pub fn catalog(
1370     store: String,
1371     backup_type: String,
1372     backup_id: String,
1373     backup_time: i64,
1374     filepath: String,
1375     rpcenv: &mut dyn RpcEnvironment,
1376 ) -> Result<Vec<ArchiveEntry>, Error> {
1377     let datastore = DataStore::lookup_datastore(&store)?;
1378
1379     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1380
1381     let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
1382
1383     check_priv_or_backup_owner(&datastore, backup_dir.group(), &auth_id, PRIV_DATASTORE_READ)?;
1384
1385     let file_name = CATALOG_NAME;
1386
1387     let (manifest, files) = read_backup_index(&datastore, &backup_dir)?;
1388     for file in files {
1389         if file.filename == file_name && file.crypt_mode == Some(CryptMode::Encrypt) {
1390             bail!("cannot decode '{}' - is encrypted", file_name);
1391         }
1392     }
1393
1394     let mut path = datastore.base_path();
1395     path.push(backup_dir.relative_path());
1396     path.push(file_name);
1397
1398     let index = DynamicIndexReader::open(&path)
1399         .map_err(|err| format_err!("unable to read dynamic index '{:?}' - {}", &path, err))?;
1400
1401     let (csum, size) = index.compute_csum();
1402     manifest.verify_file(&file_name, &csum, size)?;
1403
1404     let chunk_reader = LocalChunkReader::new(datastore, None, CryptMode::None);
1405     let reader = BufferedDynamicReader::new(index, chunk_reader);
1406
1407     let mut catalog_reader = CatalogReader::new(reader);
1408
1409     let path = if filepath != "root" && filepath != "/" {
1410         base64::decode(filepath)?
1411     } else {
1412         vec![b'/']
1413     };
1414
1415     helpers::list_dir_content(&mut catalog_reader, &path)
1416 }
1417
1418 #[sortable]
1419 pub const API_METHOD_PXAR_FILE_DOWNLOAD: ApiMethod = ApiMethod::new(
1420     &ApiHandler::AsyncHttp(&pxar_file_download),
1421     &ObjectSchema::new(
1422         "Download single file from pxar file of a backup snapshot. Only works if it's not encrypted.",
1423         &sorted!([
1424             ("store", false, &DATASTORE_SCHEMA),
1425             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
1426             ("backup-id", false,  &BACKUP_ID_SCHEMA),
1427             ("backup-time", false, &BACKUP_TIME_SCHEMA),
1428             ("filepath", false, &StringSchema::new("Base64 encoded path").schema()),
1429         ]),
1430     )
1431 ).access(None, &Permission::Privilege(
1432     &["datastore", "{store}"],
1433     PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP,
1434     true)
1435 );
1436
1437 pub fn pxar_file_download(
1438     _parts: Parts,
1439     _req_body: Body,
1440     param: Value,
1441     _info: &ApiMethod,
1442     rpcenv: Box<dyn RpcEnvironment>,
1443 ) -> ApiResponseFuture {
1444
1445     async move {
1446         let store = tools::required_string_param(&param, "store")?;
1447         let datastore = DataStore::lookup_datastore(&store)?;
1448
1449         let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1450
1451         let filepath = tools::required_string_param(&param, "filepath")?.to_owned();
1452
1453         let backup_type = tools::required_string_param(&param, "backup-type")?;
1454         let backup_id = tools::required_string_param(&param, "backup-id")?;
1455         let backup_time = tools::required_integer_param(&param, "backup-time")?;
1456
1457         let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
1458
1459         check_priv_or_backup_owner(&datastore, backup_dir.group(), &auth_id, PRIV_DATASTORE_READ)?;
1460
1461         let mut components = base64::decode(&filepath)?;
1462         if !components.is_empty() && components[0] == b'/' {
1463             components.remove(0);
1464         }
1465
1466         let mut split = components.splitn(2, |c| *c == b'/');
1467         let pxar_name = std::str::from_utf8(split.next().unwrap())?;
1468         let file_path = split.next().unwrap_or(b"/");
1469         let (manifest, files) = read_backup_index(&datastore, &backup_dir)?;
1470         for file in files {
1471             if file.filename == pxar_name && file.crypt_mode == Some(CryptMode::Encrypt) {
1472                 bail!("cannot decode '{}' - is encrypted", pxar_name);
1473             }
1474         }
1475
1476         let mut path = datastore.base_path();
1477         path.push(backup_dir.relative_path());
1478         path.push(pxar_name);
1479
1480         let index = DynamicIndexReader::open(&path)
1481             .map_err(|err| format_err!("unable to read dynamic index '{:?}' - {}", &path, err))?;
1482
1483         let (csum, size) = index.compute_csum();
1484         manifest.verify_file(&pxar_name, &csum, size)?;
1485
1486         let chunk_reader = LocalChunkReader::new(datastore, None, CryptMode::None);
1487         let reader = BufferedDynamicReader::new(index, chunk_reader);
1488         let archive_size = reader.archive_size();
1489         let reader = LocalDynamicReadAt::new(reader);
1490
1491         let decoder = Accessor::new(reader, archive_size).await?;
1492         let root = decoder.open_root().await?;
1493         let path = OsStr::from_bytes(file_path).to_os_string();
1494         let file = root
1495             .lookup(&path).await?
1496             .ok_or_else(|| format_err!("error opening '{:?}'", path))?;
1497
1498         let body = match file.kind() {
1499             EntryKind::File { .. } => Body::wrap_stream(
1500                 AsyncReaderStream::new(file.contents().await?).map_err(move |err| {
1501                     eprintln!("error during streaming of file '{:?}' - {}", filepath, err);
1502                     err
1503                 }),
1504             ),
1505             EntryKind::Hardlink(_) => Body::wrap_stream(
1506                 AsyncReaderStream::new(decoder.follow_hardlink(&file).await?.contents().await?)
1507                     .map_err(move |err| {
1508                         eprintln!(
1509                             "error during streaming of hardlink '{:?}' - {}",
1510                             path, err
1511                         );
1512                         err
1513                     }),
1514             ),
1515             EntryKind::Directory => {
1516                 let (sender, receiver) = tokio::sync::mpsc::channel(100);
1517                 let channelwriter = AsyncChannelWriter::new(sender, 1024 * 1024);
1518                 crate::server::spawn_internal_task(
1519                     create_zip(channelwriter, decoder, path.clone(), false)
1520                 );
1521                 Body::wrap_stream(ReceiverStream::new(receiver).map_err(move |err| {
1522                     eprintln!("error during streaming of zip '{:?}' - {}", path, err);
1523                     err
1524                 }))
1525             }
1526             other => bail!("cannot download file of type {:?}", other),
1527         };
1528
1529         // fixme: set other headers ?
1530         Ok(Response::builder()
1531            .status(StatusCode::OK)
1532            .header(header::CONTENT_TYPE, "application/octet-stream")
1533            .body(body)
1534            .unwrap())
1535     }.boxed()
1536 }
1537
1538 #[api(
1539     input: {
1540         properties: {
1541             store: {
1542                 schema: DATASTORE_SCHEMA,
1543             },
1544             timeframe: {
1545                 type: RRDTimeFrameResolution,
1546             },
1547             cf: {
1548                 type: RRDMode,
1549             },
1550         },
1551     },
1552     access: {
1553         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_BACKUP, true),
1554     },
1555 )]
1556 /// Read datastore stats
1557 pub fn get_rrd_stats(
1558     store: String,
1559     timeframe: RRDTimeFrameResolution,
1560     cf: RRDMode,
1561     _param: Value,
1562 ) -> Result<Value, Error> {
1563
1564     create_value_from_rrd(
1565         &format!("datastore/{}", store),
1566         &[
1567             "total", "used",
1568             "read_ios", "read_bytes",
1569             "write_ios", "write_bytes",
1570             "io_ticks",
1571         ],
1572         timeframe,
1573         cf,
1574     )
1575 }
1576
1577 #[api(
1578     input: {
1579         properties: {
1580             store: {
1581                 schema: DATASTORE_SCHEMA,
1582             },
1583             "backup-type": {
1584                 schema: BACKUP_TYPE_SCHEMA,
1585             },
1586             "backup-id": {
1587                 schema: BACKUP_ID_SCHEMA,
1588             },
1589         },
1590     },
1591     access: {
1592         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_BACKUP, true),
1593     },
1594 )]
1595 /// Get "notes" for a backup group
1596 pub fn get_group_notes(
1597     store: String,
1598     backup_type: String,
1599     backup_id: String,
1600     rpcenv: &mut dyn RpcEnvironment,
1601 ) -> Result<String, Error> {
1602     let datastore = DataStore::lookup_datastore(&store)?;
1603
1604     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1605     let backup_group = BackupGroup::new(backup_type, backup_id);
1606
1607     check_priv_or_backup_owner(&datastore, &backup_group, &auth_id, PRIV_DATASTORE_AUDIT)?;
1608
1609     let note_path = get_group_note_path(&datastore, &backup_group);
1610     Ok(file_read_optional_string(note_path)?.unwrap_or_else(|| "".to_owned()))
1611 }
1612
1613 #[api(
1614     input: {
1615         properties: {
1616             store: {
1617                 schema: DATASTORE_SCHEMA,
1618             },
1619             "backup-type": {
1620                 schema: BACKUP_TYPE_SCHEMA,
1621             },
1622             "backup-id": {
1623                 schema: BACKUP_ID_SCHEMA,
1624             },
1625             notes: {
1626                 description: "A multiline text.",
1627             },
1628         },
1629     },
1630     access: {
1631         permission: &Permission::Privilege(&["datastore", "{store}"],
1632                                            PRIV_DATASTORE_MODIFY | PRIV_DATASTORE_BACKUP,
1633                                            true),
1634     },
1635 )]
1636 /// Set "notes" for a backup group
1637 pub fn set_group_notes(
1638     store: String,
1639     backup_type: String,
1640     backup_id: String,
1641     notes: String,
1642     rpcenv: &mut dyn RpcEnvironment,
1643 ) -> Result<(), Error> {
1644     let datastore = DataStore::lookup_datastore(&store)?;
1645
1646     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1647     let backup_group = BackupGroup::new(backup_type, backup_id);
1648
1649     check_priv_or_backup_owner(&datastore, &backup_group, &auth_id, PRIV_DATASTORE_MODIFY)?;
1650
1651     let note_path = get_group_note_path(&datastore, &backup_group);
1652     replace_file(note_path, notes.as_bytes(), CreateOptions::new())?;
1653
1654     Ok(())
1655 }
1656
1657 #[api(
1658     input: {
1659         properties: {
1660             store: {
1661                 schema: DATASTORE_SCHEMA,
1662             },
1663             "backup-type": {
1664                 schema: BACKUP_TYPE_SCHEMA,
1665             },
1666             "backup-id": {
1667                 schema: BACKUP_ID_SCHEMA,
1668             },
1669             "backup-time": {
1670                 schema: BACKUP_TIME_SCHEMA,
1671             },
1672         },
1673     },
1674     access: {
1675         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_BACKUP, true),
1676     },
1677 )]
1678 /// Get "notes" for a specific backup
1679 pub fn get_notes(
1680     store: String,
1681     backup_type: String,
1682     backup_id: String,
1683     backup_time: i64,
1684     rpcenv: &mut dyn RpcEnvironment,
1685 ) -> Result<String, Error> {
1686     let datastore = DataStore::lookup_datastore(&store)?;
1687
1688     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1689     let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
1690
1691     check_priv_or_backup_owner(&datastore, backup_dir.group(), &auth_id, PRIV_DATASTORE_AUDIT)?;
1692
1693     let (manifest, _) = datastore.load_manifest(&backup_dir)?;
1694
1695     let notes = manifest.unprotected["notes"]
1696         .as_str()
1697         .unwrap_or("");
1698
1699     Ok(String::from(notes))
1700 }
1701
1702 #[api(
1703     input: {
1704         properties: {
1705             store: {
1706                 schema: DATASTORE_SCHEMA,
1707             },
1708             "backup-type": {
1709                 schema: BACKUP_TYPE_SCHEMA,
1710             },
1711             "backup-id": {
1712                 schema: BACKUP_ID_SCHEMA,
1713             },
1714             "backup-time": {
1715                 schema: BACKUP_TIME_SCHEMA,
1716             },
1717             notes: {
1718                 description: "A multiline text.",
1719             },
1720         },
1721     },
1722     access: {
1723         permission: &Permission::Privilege(&["datastore", "{store}"],
1724                                            PRIV_DATASTORE_MODIFY | PRIV_DATASTORE_BACKUP,
1725                                            true),
1726     },
1727 )]
1728 /// Set "notes" for a specific backup
1729 pub fn set_notes(
1730     store: String,
1731     backup_type: String,
1732     backup_id: String,
1733     backup_time: i64,
1734     notes: String,
1735     rpcenv: &mut dyn RpcEnvironment,
1736 ) -> Result<(), Error> {
1737     let datastore = DataStore::lookup_datastore(&store)?;
1738
1739     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1740     let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
1741
1742     check_priv_or_backup_owner(&datastore, backup_dir.group(), &auth_id, PRIV_DATASTORE_MODIFY)?;
1743
1744     datastore.update_manifest(&backup_dir,|manifest| {
1745         manifest.unprotected["notes"] = notes.into();
1746     }).map_err(|err| format_err!("unable to update manifest blob - {}", err))?;
1747
1748     Ok(())
1749 }
1750
1751 #[api(
1752     input: {
1753         properties: {
1754             store: {
1755                 schema: DATASTORE_SCHEMA,
1756             },
1757             "backup-type": {
1758                 schema: BACKUP_TYPE_SCHEMA,
1759             },
1760             "backup-id": {
1761                 schema: BACKUP_ID_SCHEMA,
1762             },
1763             "new-owner": {
1764                 type: Authid,
1765             },
1766         },
1767     },
1768     access: {
1769         permission: &Permission::Anybody,
1770         description: "Datastore.Modify on whole datastore, or changing ownership between user and a user's token for owned backups with Datastore.Backup"
1771     },
1772 )]
1773 /// Change owner of a backup group
1774 pub fn set_backup_owner(
1775     store: String,
1776     backup_type: String,
1777     backup_id: String,
1778     new_owner: Authid,
1779     rpcenv: &mut dyn RpcEnvironment,
1780 ) -> Result<(), Error> {
1781
1782     let datastore = DataStore::lookup_datastore(&store)?;
1783
1784     let backup_group = BackupGroup::new(backup_type, backup_id);
1785
1786     let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
1787
1788     let user_info = CachedUserInfo::new()?;
1789
1790     let privs = user_info.lookup_privs(&auth_id, &["datastore", &store]);
1791
1792     let allowed = if (privs & PRIV_DATASTORE_MODIFY) != 0 {
1793         // High-privilege user/token
1794         true
1795     } else if (privs & PRIV_DATASTORE_BACKUP) != 0 {
1796         let owner = datastore.get_owner(&backup_group)?;
1797
1798         match (owner.is_token(), new_owner.is_token()) {
1799             (true, true) => {
1800                 // API token to API token, owned by same user
1801                 let owner = owner.user();
1802                 let new_owner = new_owner.user();
1803                 owner == new_owner && Authid::from(owner.clone()) == auth_id
1804             },
1805             (true, false) => {
1806                 // API token to API token owner
1807                 Authid::from(owner.user().clone()) == auth_id
1808                     && new_owner == auth_id
1809             },
1810             (false, true) => {
1811                 // API token owner to API token
1812                 owner == auth_id
1813                     && Authid::from(new_owner.user().clone()) == auth_id
1814             },
1815             (false, false) => {
1816                 // User to User, not allowed for unprivileged users
1817                 false
1818             },
1819         }
1820     } else {
1821         false
1822     };
1823
1824     if !allowed {
1825         return Err(http_err!(UNAUTHORIZED,
1826                   "{} does not have permission to change owner of backup group '{}' to {}",
1827                   auth_id,
1828                   backup_group,
1829                   new_owner,
1830         ));
1831     }
1832
1833     if !user_info.is_active_auth_id(&new_owner) {
1834         bail!("{} '{}' is inactive or non-existent",
1835               if new_owner.is_token() {
1836                   "API token".to_string()
1837               } else {
1838                   "user".to_string()
1839               },
1840               new_owner);
1841     }
1842
1843     datastore.set_owner(&backup_group, &new_owner, true)?;
1844
1845     Ok(())
1846 }
1847
1848 #[sortable]
1849 const DATASTORE_INFO_SUBDIRS: SubdirMap = &[
1850     (
1851         "catalog",
1852         &Router::new()
1853             .get(&API_METHOD_CATALOG)
1854     ),
1855     (
1856         "change-owner",
1857         &Router::new()
1858             .post(&API_METHOD_SET_BACKUP_OWNER)
1859     ),
1860     (
1861         "download",
1862         &Router::new()
1863             .download(&API_METHOD_DOWNLOAD_FILE)
1864     ),
1865     (
1866         "download-decoded",
1867         &Router::new()
1868             .download(&API_METHOD_DOWNLOAD_FILE_DECODED)
1869     ),
1870     (
1871         "files",
1872         &Router::new()
1873             .get(&API_METHOD_LIST_SNAPSHOT_FILES)
1874     ),
1875     (
1876         "gc",
1877         &Router::new()
1878             .get(&API_METHOD_GARBAGE_COLLECTION_STATUS)
1879             .post(&API_METHOD_START_GARBAGE_COLLECTION)
1880     ),
1881     (
1882         "group-notes",
1883         &Router::new()
1884             .get(&API_METHOD_GET_GROUP_NOTES)
1885             .put(&API_METHOD_SET_GROUP_NOTES)
1886     ),
1887     (
1888         "groups",
1889         &Router::new()
1890             .get(&API_METHOD_LIST_GROUPS)
1891             .delete(&API_METHOD_DELETE_GROUP)
1892     ),
1893     (
1894         "notes",
1895         &Router::new()
1896             .get(&API_METHOD_GET_NOTES)
1897             .put(&API_METHOD_SET_NOTES)
1898     ),
1899     (
1900         "prune",
1901         &Router::new()
1902             .post(&API_METHOD_PRUNE)
1903     ),
1904     (
1905         "pxar-file-download",
1906         &Router::new()
1907             .download(&API_METHOD_PXAR_FILE_DOWNLOAD)
1908     ),
1909     (
1910         "rrd",
1911         &Router::new()
1912             .get(&API_METHOD_GET_RRD_STATS)
1913     ),
1914     (
1915         "snapshots",
1916         &Router::new()
1917             .get(&API_METHOD_LIST_SNAPSHOTS)
1918             .delete(&API_METHOD_DELETE_SNAPSHOT)
1919     ),
1920     (
1921         "status",
1922         &Router::new()
1923             .get(&API_METHOD_STATUS)
1924     ),
1925     (
1926         "upload-backup-log",
1927         &Router::new()
1928             .upload(&API_METHOD_UPLOAD_BACKUP_LOG)
1929     ),
1930     (
1931         "verify",
1932         &Router::new()
1933             .post(&API_METHOD_VERIFY)
1934     ),
1935 ];
1936
1937 const DATASTORE_INFO_ROUTER: Router = Router::new()
1938     .get(&list_subdirs_api_method!(DATASTORE_INFO_SUBDIRS))
1939     .subdirs(DATASTORE_INFO_SUBDIRS);
1940
1941
1942 pub const ROUTER: Router = Router::new()
1943     .get(&API_METHOD_GET_DATASTORE_LIST)
1944     .match_all("store", &DATASTORE_INFO_ROUTER);