src/api2/admin/datastore.rs

   1 use std::collections::{HashSet, HashMap};
   2 use std::ffi::OsStr;
   3 use std::os::unix::ffi::OsStrExt;
   4
   5 use anyhow::{bail, format_err, Error};
   6 use futures::*;
   7 use hyper::http::request::Parts;
   8 use hyper::{header, Body, Response, StatusCode};
   9 use serde_json::{json, Value};
  10
  11 use proxmox::api::{
  12     api, ApiResponseFuture, ApiHandler, ApiMethod, Router,
  13     RpcEnvironment, RpcEnvironmentType, Permission
  14 };
  15 use proxmox::api::router::SubdirMap;
  16 use proxmox::api::schema::*;
  17 use proxmox::tools::fs::{replace_file, CreateOptions};
  18 use proxmox::try_block;
  19 use proxmox::{http_err, identity, list_subdirs_api_method, sortable};
  20
  21 use pxar::accessor::aio::Accessor;
  22 use pxar::EntryKind;
  23
  24 use crate::api2::types::*;
  25 use crate::api2::node::rrd::create_value_from_rrd;
  26 use crate::backup::*;
  27 use crate::config::datastore;
  28 use crate::config::cached_user_info::CachedUserInfo;
  29
  30 use crate::server::WorkerTask;
  31 use crate::tools::{self, AsyncReaderStream, WrappedReaderStream};
  32 use crate::config::acl::{
  33     PRIV_DATASTORE_AUDIT,
  34     PRIV_DATASTORE_MODIFY,
  35     PRIV_DATASTORE_READ,
  36     PRIV_DATASTORE_PRUNE,
  37     PRIV_DATASTORE_BACKUP,
  38 };
  39
  40 fn check_backup_owner(
  41     store: &DataStore,
  42     group: &BackupGroup,
  43     userid: &Userid,
  44 ) -> Result<(), Error> {
  45     let owner = store.get_owner(group)?;
  46     if &owner != userid {
  47         bail!("backup owner check failed ({} != {})", userid, owner);
  48     }
  49     Ok(())
  50 }
  51
  52 fn read_backup_index(
  53     store: &DataStore,
  54     backup_dir: &BackupDir,
  55 ) -> Result<(BackupManifest, Vec<BackupContent>), Error> {
  56
  57     let (manifest, index_size) = store.load_manifest(backup_dir)?;
  58
  59     let mut result = Vec::new();
  60     for item in manifest.files() {
  61         result.push(BackupContent {
  62             filename: item.filename.clone(),
  63             crypt_mode: Some(item.crypt_mode),
  64             size: Some(item.size),
  65         });
  66     }
  67
  68     result.push(BackupContent {
  69         filename: MANIFEST_BLOB_NAME.to_string(),
  70         crypt_mode: Some(CryptMode::None),
  71         size: Some(index_size),
  72     });
  73
  74     Ok((manifest, result))
  75 }
  76
  77 fn get_all_snapshot_files(
  78     store: &DataStore,
  79     info: &BackupInfo,
  80 ) -> Result<(BackupManifest, Vec<BackupContent>), Error> {
  81
  82     let (manifest, mut files) = read_backup_index(&store, &info.backup_dir)?;
  83
  84     let file_set = files.iter().fold(HashSet::new(), |mut acc, item| {
  85         acc.insert(item.filename.clone());
  86         acc
  87     });
  88
  89     for file in &info.files {
  90         if file_set.contains(file) { continue; }
  91         files.push(BackupContent {
  92             filename: file.to_string(),
  93             size: None,
  94             crypt_mode: None,
  95         });
  96     }
  97
  98     Ok((manifest, files))
  99 }
 100
 101 fn group_backups(backup_list: Vec<BackupInfo>) -> HashMap<String, Vec<BackupInfo>> {
 102
 103     let mut group_hash = HashMap::new();
 104
 105     for info in backup_list {
 106         let group_id = info.backup_dir.group().group_path().to_str().unwrap().to_owned();
 107         let time_list = group_hash.entry(group_id).or_insert(vec![]);
 108         time_list.push(info);
 109     }
 110
 111     group_hash
 112 }
 113
 114 #[api(
 115     input: {
 116         properties: {
 117             store: {
 118                 schema: DATASTORE_SCHEMA,
 119             },
 120         },
 121     },
 122     returns: {
 123         type: Array,
 124         description: "Returns the list of backup groups.",
 125         items: {
 126             type: GroupListItem,
 127         }
 128     },
 129     access: {
 130         permission: &Permission::Privilege(
 131             &["datastore", "{store}"],
 132             PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_BACKUP,
 133             true),
 134     },
 135 )]
 136 /// List backup groups.
 137 fn list_groups(
 138     store: String,
 139     rpcenv: &mut dyn RpcEnvironment,
 140 ) -> Result<Vec<GroupListItem>, Error> {
 141
 142     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
 143     let user_info = CachedUserInfo::new()?;
 144     let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
 145
 146     let datastore = DataStore::lookup_datastore(&store)?;
 147
 148     let backup_list = BackupInfo::list_backups(&datastore.base_path())?;
 149
 150     let group_hash = group_backups(backup_list);
 151
 152     let mut groups = Vec::new();
 153
 154     for (_group_id, mut list) in group_hash {
 155
 156         BackupInfo::sort_list(&mut list, false);
 157
 158         let info = &list[0];
 159
 160         let group = info.backup_dir.group();
 161
 162         let list_all = (user_privs & PRIV_DATASTORE_AUDIT) != 0;
 163         let owner = datastore.get_owner(group)?;
 164         if !list_all {
 165             if owner != userid { continue; }
 166         }
 167
 168         let result_item = GroupListItem {
 169             backup_type: group.backup_type().to_string(),
 170             backup_id: group.backup_id().to_string(),
 171             last_backup: info.backup_dir.backup_time().timestamp(),
 172             backup_count: list.len() as u64,
 173             files: info.files.clone(),
 174             owner: Some(owner),
 175         };
 176         groups.push(result_item);
 177     }
 178
 179     Ok(groups)
 180 }
 181
 182 #[api(
 183     input: {
 184         properties: {
 185             store: {
 186                 schema: DATASTORE_SCHEMA,
 187             },
 188             "backup-type": {
 189                 schema: BACKUP_TYPE_SCHEMA,
 190             },
 191             "backup-id": {
 192                 schema: BACKUP_ID_SCHEMA,
 193             },
 194             "backup-time": {
 195                 schema: BACKUP_TIME_SCHEMA,
 196             },
 197         },
 198     },
 199     returns: {
 200         type: Array,
 201         description: "Returns the list of archive files inside a backup snapshots.",
 202         items: {
 203             type: BackupContent,
 204         }
 205     },
 206     access: {
 207         permission: &Permission::Privilege(
 208             &["datastore", "{store}"],
 209             PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP,
 210             true),
 211     },
 212 )]
 213 /// List snapshot files.
 214 pub fn list_snapshot_files(
 215     store: String,
 216     backup_type: String,
 217     backup_id: String,
 218     backup_time: i64,
 219     _info: &ApiMethod,
 220     rpcenv: &mut dyn RpcEnvironment,
 221 ) -> Result<Vec<BackupContent>, Error> {
 222
 223     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
 224     let user_info = CachedUserInfo::new()?;
 225     let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
 226
 227     let datastore = DataStore::lookup_datastore(&store)?;
 228
 229     let snapshot = BackupDir::new(backup_type, backup_id, backup_time);
 230
 231     let allowed = (user_privs & (PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_READ)) != 0;
 232     if !allowed { check_backup_owner(&datastore, snapshot.group(), &userid)?; }
 233
 234     let info = BackupInfo::new(&datastore.base_path(), snapshot)?;
 235
 236     let (_manifest, files) = get_all_snapshot_files(&datastore, &info)?;
 237
 238     Ok(files)
 239 }
 240
 241 #[api(
 242     input: {
 243         properties: {
 244             store: {
 245                 schema: DATASTORE_SCHEMA,
 246             },
 247             "backup-type": {
 248                 schema: BACKUP_TYPE_SCHEMA,
 249             },
 250             "backup-id": {
 251                 schema: BACKUP_ID_SCHEMA,
 252             },
 253             "backup-time": {
 254                 schema: BACKUP_TIME_SCHEMA,
 255             },
 256         },
 257     },
 258     access: {
 259         permission: &Permission::Privilege(
 260             &["datastore", "{store}"],
 261             PRIV_DATASTORE_MODIFY| PRIV_DATASTORE_PRUNE,
 262             true),
 263     },
 264 )]
 265 /// Delete backup snapshot.
 266 fn delete_snapshot(
 267     store: String,
 268     backup_type: String,
 269     backup_id: String,
 270     backup_time: i64,
 271     _info: &ApiMethod,
 272     rpcenv: &mut dyn RpcEnvironment,
 273 ) -> Result<Value, Error> {
 274
 275     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
 276     let user_info = CachedUserInfo::new()?;
 277     let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
 278
 279     let snapshot = BackupDir::new(backup_type, backup_id, backup_time);
 280
 281     let datastore = DataStore::lookup_datastore(&store)?;
 282
 283     let allowed = (user_privs & PRIV_DATASTORE_MODIFY) != 0;
 284     if !allowed { check_backup_owner(&datastore, snapshot.group(), &userid)?; }
 285
 286     datastore.remove_backup_dir(&snapshot, false)?;
 287
 288     Ok(Value::Null)
 289 }
 290
 291 #[api(
 292     input: {
 293         properties: {
 294             store: {
 295                 schema: DATASTORE_SCHEMA,
 296             },
 297             "backup-type": {
 298                 optional: true,
 299                 schema: BACKUP_TYPE_SCHEMA,
 300             },
 301             "backup-id": {
 302                 optional: true,
 303                 schema: BACKUP_ID_SCHEMA,
 304             },
 305         },
 306     },
 307     returns: {
 308         type: Array,
 309         description: "Returns the list of snapshots.",
 310         items: {
 311             type: SnapshotListItem,
 312         }
 313     },
 314     access: {
 315         permission: &Permission::Privilege(
 316             &["datastore", "{store}"],
 317             PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_BACKUP,
 318             true),
 319     },
 320 )]
 321 /// List backup snapshots.
 322 pub fn list_snapshots (
 323     store: String,
 324     backup_type: Option<String>,
 325     backup_id: Option<String>,
 326     _param: Value,
 327     _info: &ApiMethod,
 328     rpcenv: &mut dyn RpcEnvironment,
 329 ) -> Result<Vec<SnapshotListItem>, Error> {
 330
 331     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
 332     let user_info = CachedUserInfo::new()?;
 333     let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
 334
 335     let datastore = DataStore::lookup_datastore(&store)?;
 336
 337     let base_path = datastore.base_path();
 338
 339     let backup_list = BackupInfo::list_backups(&base_path)?;
 340
 341     let mut snapshots = vec![];
 342
 343     for info in backup_list {
 344         let group = info.backup_dir.group();
 345         if let Some(ref backup_type) = backup_type {
 346             if backup_type != group.backup_type() { continue; }
 347         }
 348         if let Some(ref backup_id) = backup_id {
 349             if backup_id != group.backup_id() { continue; }
 350         }
 351
 352         let list_all = (user_privs & PRIV_DATASTORE_AUDIT) != 0;
 353         let owner = datastore.get_owner(group)?;
 354
 355         if !list_all {
 356             if owner != userid { continue; }
 357         }
 358
 359         let mut size = None;
 360
 361         let (comment, files) = match get_all_snapshot_files(&datastore, &info) {
 362             Ok((manifest, files)) => {
 363                 size = Some(files.iter().map(|x| x.size.unwrap_or(0)).sum());
 364                 // extract the first line from notes
 365                 let comment: Option<String> = manifest.unprotected["notes"]
 366                     .as_str()
 367                     .and_then(|notes| notes.lines().next())
 368                     .map(String::from);
 369
 370                 (comment, files)
 371             },
 372             Err(err) => {
 373                 eprintln!("error during snapshot file listing: '{}'", err);
 374                 (
 375                     None,
 376                     info
 377                         .files
 378                         .iter()
 379                         .map(|x| BackupContent {
 380                             filename: x.to_string(),
 381                             size: None,
 382                             crypt_mode: None,
 383                         })
 384                         .collect()
 385                 )
 386             },
 387         };
 388
 389         let result_item = SnapshotListItem {
 390             backup_type: group.backup_type().to_string(),
 391             backup_id: group.backup_id().to_string(),
 392             backup_time: info.backup_dir.backup_time().timestamp(),
 393             comment,
 394             files,
 395             size,
 396             owner: Some(owner),
 397         };
 398
 399         snapshots.push(result_item);
 400     }
 401
 402     Ok(snapshots)
 403 }
 404
 405 #[api(
 406     input: {
 407         properties: {
 408             store: {
 409                 schema: DATASTORE_SCHEMA,
 410             },
 411         },
 412     },
 413     returns: {
 414         type: StorageStatus,
 415     },
 416     access: {
 417         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_BACKUP, true),
 418     },
 419 )]
 420 /// Get datastore status.
 421 pub fn status(
 422     store: String,
 423     _info: &ApiMethod,
 424     _rpcenv: &mut dyn RpcEnvironment,
 425 ) -> Result<StorageStatus, Error> {
 426     let datastore = DataStore::lookup_datastore(&store)?;
 427     crate::tools::disks::disk_usage(&datastore.base_path())
 428 }
 429
 430 #[api(
 431     input: {
 432         properties: {
 433             store: {
 434                 schema: DATASTORE_SCHEMA,
 435             },
 436             "backup-type": {
 437                 schema: BACKUP_TYPE_SCHEMA,
 438                 optional: true,
 439             },
 440             "backup-id": {
 441                 schema: BACKUP_ID_SCHEMA,
 442                 optional: true,
 443             },
 444             "backup-time": {
 445                 schema: BACKUP_TIME_SCHEMA,
 446                 optional: true,
 447             },
 448         },
 449     },
 450     returns: {
 451         schema: UPID_SCHEMA,
 452     },
 453     access: {
 454         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP, true), // fixme
 455     },
 456 )]
 457 /// Verify backups.
 458 ///
 459 /// This function can verify a single backup snapshot, all backup from a backup group,
 460 /// or all backups in the datastore.
 461 pub fn verify(
 462     store: String,
 463     backup_type: Option<String>,
 464     backup_id: Option<String>,
 465     backup_time: Option<i64>,
 466     rpcenv: &mut dyn RpcEnvironment,
 467 ) -> Result<Value, Error> {
 468     let datastore = DataStore::lookup_datastore(&store)?;
 469
 470     let worker_id;
 471
 472     let mut backup_dir = None;
 473     let mut backup_group = None;
 474
 475     match (backup_type, backup_id, backup_time) {
 476         (Some(backup_type), Some(backup_id), Some(backup_time)) => {
 477             worker_id = format!("{}_{}_{}_{:08X}", store, backup_type, backup_id, backup_time);
 478             let dir = BackupDir::new(backup_type, backup_id, backup_time);
 479             backup_dir = Some(dir);
 480         }
 481         (Some(backup_type), Some(backup_id), None) => {
 482             worker_id = format!("{}_{}_{}", store, backup_type, backup_id);
 483             let group = BackupGroup::new(backup_type, backup_id);
 484             backup_group = Some(group);
 485         }
 486         (None, None, None) => {
 487             worker_id = store.clone();
 488         }
 489         _ => bail!("parameters do not spefify a backup group or snapshot"),
 490     }
 491
 492     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
 493     let to_stdout = if rpcenv.env_type() == RpcEnvironmentType::CLI { true } else { false };
 494
 495     let upid_str = WorkerTask::new_thread(
 496         "verify",
 497         Some(worker_id.clone()),
 498         userid,
 499         to_stdout,
 500         move |worker| {
 501             let failed_dirs = if let Some(backup_dir) = backup_dir {
 502                 let mut verified_chunks = HashSet::with_capacity(1024*16);
 503                 let mut corrupt_chunks = HashSet::with_capacity(64);
 504                 let mut res = Vec::new();
 505                 if !verify_backup_dir(&datastore, &backup_dir, &mut verified_chunks, &mut corrupt_chunks, &worker)? {
 506                     res.push(backup_dir.to_string());
 507                 }
 508                 res
 509             } else if let Some(backup_group) = backup_group {
 510                 verify_backup_group(&datastore, &backup_group, &worker)?
 511             } else {
 512                 verify_all_backups(&datastore, &worker)?
 513             };
 514             if failed_dirs.len() > 0 {
 515                 worker.log("Failed to verify following snapshots:");
 516                 for dir in failed_dirs {
 517                     worker.log(format!("\t{}", dir));
 518                 }
 519                 bail!("verfication failed - please check the log for details");
 520             }
 521             Ok(())
 522         },
 523     )?;
 524
 525     Ok(json!(upid_str))
 526 }
 527
 528 #[macro_export]
 529 macro_rules! add_common_prune_prameters {
 530     ( [ $( $list1:tt )* ] ) => {
 531         add_common_prune_prameters!([$( $list1 )* ] ,  [])
 532     };
 533     ( [ $( $list1:tt )* ] ,  [ $( $list2:tt )* ] ) => {
 534         [
 535             $( $list1 )*
 536             (
 537                 "keep-daily",
 538                 true,
 539                 &PRUNE_SCHEMA_KEEP_DAILY,
 540             ),
 541             (
 542                 "keep-hourly",
 543                 true,
 544                 &PRUNE_SCHEMA_KEEP_HOURLY,
 545             ),
 546             (
 547                 "keep-last",
 548                 true,
 549                 &PRUNE_SCHEMA_KEEP_LAST,
 550             ),
 551             (
 552                 "keep-monthly",
 553                 true,
 554                 &PRUNE_SCHEMA_KEEP_MONTHLY,
 555             ),
 556             (
 557                 "keep-weekly",
 558                 true,
 559                 &PRUNE_SCHEMA_KEEP_WEEKLY,
 560             ),
 561             (
 562                 "keep-yearly",
 563                 true,
 564                 &PRUNE_SCHEMA_KEEP_YEARLY,
 565             ),
 566             $( $list2 )*
 567         ]
 568     }
 569 }
 570
 571 pub const API_RETURN_SCHEMA_PRUNE: Schema = ArraySchema::new(
 572     "Returns the list of snapshots and a flag indicating if there are kept or removed.",
 573     &PruneListItem::API_SCHEMA
 574 ).schema();
 575
 576 const API_METHOD_PRUNE: ApiMethod = ApiMethod::new(
 577     &ApiHandler::Sync(&prune),
 578     &ObjectSchema::new(
 579         "Prune the datastore.",
 580         &add_common_prune_prameters!([
 581             ("backup-id", false, &BACKUP_ID_SCHEMA),
 582             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
 583             ("dry-run", true, &BooleanSchema::new(
 584                 "Just show what prune would do, but do not delete anything.")
 585              .schema()
 586             ),
 587         ],[
 588             ("store", false, &DATASTORE_SCHEMA),
 589         ])
 590     ))
 591     .returns(&API_RETURN_SCHEMA_PRUNE)
 592     .access(None, &Permission::Privilege(
 593     &["datastore", "{store}"],
 594     PRIV_DATASTORE_MODIFY | PRIV_DATASTORE_PRUNE,
 595     true)
 596 );
 597
 598 fn prune(
 599     param: Value,
 600     _info: &ApiMethod,
 601     rpcenv: &mut dyn RpcEnvironment,
 602 ) -> Result<Value, Error> {
 603
 604     let store = tools::required_string_param(&param, "store")?;
 605     let backup_type = tools::required_string_param(&param, "backup-type")?;
 606     let backup_id = tools::required_string_param(&param, "backup-id")?;
 607
 608     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
 609     let user_info = CachedUserInfo::new()?;
 610     let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
 611
 612     let dry_run = param["dry-run"].as_bool().unwrap_or(false);
 613
 614     let group = BackupGroup::new(backup_type, backup_id);
 615
 616     let datastore = DataStore::lookup_datastore(&store)?;
 617
 618     let allowed = (user_privs & PRIV_DATASTORE_MODIFY) != 0;
 619     if !allowed { check_backup_owner(&datastore, &group, &userid)?; }
 620
 621     let prune_options = PruneOptions {
 622         keep_last: param["keep-last"].as_u64(),
 623         keep_hourly: param["keep-hourly"].as_u64(),
 624         keep_daily: param["keep-daily"].as_u64(),
 625         keep_weekly: param["keep-weekly"].as_u64(),
 626         keep_monthly: param["keep-monthly"].as_u64(),
 627         keep_yearly: param["keep-yearly"].as_u64(),
 628     };
 629
 630     let worker_id = format!("{}_{}_{}", store, backup_type, backup_id);
 631
 632     let mut prune_result = Vec::new();
 633
 634     let list = group.list_backups(&datastore.base_path())?;
 635
 636     let mut prune_info = compute_prune_info(list, &prune_options)?;
 637
 638     prune_info.reverse(); // delete older snapshots first
 639
 640     let keep_all = !prune_options.keeps_something();
 641
 642     if dry_run {
 643         for (info, mut keep) in prune_info {
 644             if keep_all { keep = true; }
 645
 646             let backup_time = info.backup_dir.backup_time();
 647             let group = info.backup_dir.group();
 648
 649             prune_result.push(json!({
 650                 "backup-type": group.backup_type(),
 651                 "backup-id": group.backup_id(),
 652                 "backup-time": backup_time.timestamp(),
 653                 "keep": keep,
 654             }));
 655         }
 656         return Ok(json!(prune_result));
 657     }
 658
 659
 660     // We use a WorkerTask just to have a task log, but run synchrounously
 661     let worker = WorkerTask::new("prune", Some(worker_id), Userid::root_userid().clone(), true)?;
 662
 663     let result = try_block! {
 664         if keep_all {
 665             worker.log("No prune selection - keeping all files.");
 666         } else {
 667             worker.log(format!("retention options: {}", prune_options.cli_options_string()));
 668             worker.log(format!("Starting prune on store \"{}\" group \"{}/{}\"",
 669                                store, backup_type, backup_id));
 670         }
 671
 672         for (info, mut keep) in prune_info {
 673             if keep_all { keep = true; }
 674
 675             let backup_time = info.backup_dir.backup_time();
 676             let timestamp = BackupDir::backup_time_to_string(backup_time);
 677             let group = info.backup_dir.group();
 678
 679
 680             let msg = format!(
 681                 "{}/{}/{} {}",
 682                 group.backup_type(),
 683                 group.backup_id(),
 684                 timestamp,
 685                 if keep { "keep" } else { "remove" },
 686             );
 687
 688             worker.log(msg);
 689
 690             prune_result.push(json!({
 691                 "backup-type": group.backup_type(),
 692                 "backup-id": group.backup_id(),
 693                 "backup-time": backup_time.timestamp(),
 694                 "keep": keep,
 695             }));
 696
 697             if !(dry_run || keep) {
 698                 datastore.remove_backup_dir(&info.backup_dir, true)?;
 699             }
 700         }
 701
 702         Ok(())
 703     };
 704
 705     worker.log_result(&result);
 706
 707     if let Err(err) = result {
 708         bail!("prune failed - {}", err);
 709     };
 710
 711     Ok(json!(prune_result))
 712 }
 713
 714 #[api(
 715     input: {
 716         properties: {
 717             store: {
 718                 schema: DATASTORE_SCHEMA,
 719             },
 720         },
 721     },
 722     returns: {
 723         schema: UPID_SCHEMA,
 724     },
 725     access: {
 726         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_MODIFY, false),
 727     },
 728 )]
 729 /// Start garbage collection.
 730 fn start_garbage_collection(
 731     store: String,
 732     _info: &ApiMethod,
 733     rpcenv: &mut dyn RpcEnvironment,
 734 ) -> Result<Value, Error> {
 735
 736     let datastore = DataStore::lookup_datastore(&store)?;
 737
 738     println!("Starting garbage collection on store {}", store);
 739
 740     let to_stdout = if rpcenv.env_type() == RpcEnvironmentType::CLI { true } else { false };
 741
 742     let upid_str = WorkerTask::new_thread(
 743         "garbage_collection",
 744         Some(store.clone()),
 745         Userid::root_userid().clone(),
 746         to_stdout,
 747         move |worker| {
 748             worker.log(format!("starting garbage collection on store {}", store));
 749             datastore.garbage_collection(&worker)
 750         },
 751     )?;
 752
 753     Ok(json!(upid_str))
 754 }
 755
 756 #[api(
 757     input: {
 758         properties: {
 759             store: {
 760                 schema: DATASTORE_SCHEMA,
 761             },
 762         },
 763     },
 764     returns: {
 765         type: GarbageCollectionStatus,
 766     },
 767     access: {
 768         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_AUDIT, false),
 769     },
 770 )]
 771 /// Garbage collection status.
 772 pub fn garbage_collection_status(
 773     store: String,
 774     _info: &ApiMethod,
 775     _rpcenv: &mut dyn RpcEnvironment,
 776 ) -> Result<GarbageCollectionStatus, Error> {
 777
 778     let datastore = DataStore::lookup_datastore(&store)?;
 779
 780     let status = datastore.last_gc_status();
 781
 782     Ok(status)
 783 }
 784
 785 #[api(
 786     returns: {
 787         description: "List the accessible datastores.",
 788         type: Array,
 789         items: {
 790             description: "Datastore name and description.",
 791             properties: {
 792                 store: {
 793                     schema: DATASTORE_SCHEMA,
 794                 },
 795                 comment: {
 796                     optional: true,
 797                     schema: SINGLE_LINE_COMMENT_SCHEMA,
 798                 },
 799             },
 800         },
 801     },
 802     access: {
 803         permission: &Permission::Anybody,
 804     },
 805 )]
 806 /// Datastore list
 807 fn get_datastore_list(
 808     _param: Value,
 809     _info: &ApiMethod,
 810     rpcenv: &mut dyn RpcEnvironment,
 811 ) -> Result<Value, Error> {
 812
 813     let (config, _digest) = datastore::config()?;
 814
 815     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
 816     let user_info = CachedUserInfo::new()?;
 817
 818     let mut list = Vec::new();
 819
 820     for (store, (_, data)) in &config.sections {
 821         let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
 822         let allowed = (user_privs & (PRIV_DATASTORE_AUDIT| PRIV_DATASTORE_BACKUP)) != 0;
 823         if allowed {
 824             let mut entry = json!({ "store": store });
 825             if let Some(comment) = data["comment"].as_str() {
 826                 entry["comment"] = comment.into();
 827             }
 828             list.push(entry);
 829         }
 830     }
 831
 832     Ok(list.into())
 833 }
 834
 835 #[sortable]
 836 pub const API_METHOD_DOWNLOAD_FILE: ApiMethod = ApiMethod::new(
 837     &ApiHandler::AsyncHttp(&download_file),
 838     &ObjectSchema::new(
 839         "Download single raw file from backup snapshot.",
 840         &sorted!([
 841             ("store", false, &DATASTORE_SCHEMA),
 842             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
 843             ("backup-id", false,  &BACKUP_ID_SCHEMA),
 844             ("backup-time", false, &BACKUP_TIME_SCHEMA),
 845             ("file-name", false, &BACKUP_ARCHIVE_NAME_SCHEMA),
 846         ]),
 847     )
 848 ).access(None, &Permission::Privilege(
 849     &["datastore", "{store}"],
 850     PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP,
 851     true)
 852 );
 853
 854 fn download_file(
 855     _parts: Parts,
 856     _req_body: Body,
 857     param: Value,
 858     _info: &ApiMethod,
 859     rpcenv: Box<dyn RpcEnvironment>,
 860 ) -> ApiResponseFuture {
 861
 862     async move {
 863         let store = tools::required_string_param(&param, "store")?;
 864         let datastore = DataStore::lookup_datastore(store)?;
 865
 866         let userid: Userid = rpcenv.get_user().unwrap().parse()?;
 867         let user_info = CachedUserInfo::new()?;
 868         let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
 869
 870         let file_name = tools::required_string_param(&param, "file-name")?.to_owned();
 871
 872         let backup_type = tools::required_string_param(&param, "backup-type")?;
 873         let backup_id = tools::required_string_param(&param, "backup-id")?;
 874         let backup_time = tools::required_integer_param(&param, "backup-time")?;
 875
 876         let backup_dir = BackupDir::new(backup_type, backup_id, backup_time);
 877
 878         let allowed = (user_privs & PRIV_DATASTORE_READ) != 0;
 879         if !allowed { check_backup_owner(&datastore, backup_dir.group(), &userid)?; }
 880
 881         println!("Download {} from {} ({}/{})", file_name, store, backup_dir, file_name);
 882
 883         let mut path = datastore.base_path();
 884         path.push(backup_dir.relative_path());
 885         path.push(&file_name);
 886
 887         let file = tokio::fs::File::open(&path)
 888             .await
 889             .map_err(|err| http_err!(BAD_REQUEST, "File open failed: {}", err))?;
 890
 891         let payload = tokio_util::codec::FramedRead::new(file, tokio_util::codec::BytesCodec::new())
 892             .map_ok(|bytes| hyper::body::Bytes::from(bytes.freeze()))
 893             .map_err(move |err| {
 894                 eprintln!("error during streaming of '{:?}' - {}", &path, err);
 895                 err
 896             });
 897         let body = Body::wrap_stream(payload);
 898
 899         // fixme: set other headers ?
 900         Ok(Response::builder()
 901            .status(StatusCode::OK)
 902            .header(header::CONTENT_TYPE, "application/octet-stream")
 903            .body(body)
 904            .unwrap())
 905     }.boxed()
 906 }
 907
 908 #[sortable]
 909 pub const API_METHOD_DOWNLOAD_FILE_DECODED: ApiMethod = ApiMethod::new(
 910     &ApiHandler::AsyncHttp(&download_file_decoded),
 911     &ObjectSchema::new(
 912         "Download single decoded file from backup snapshot. Only works if it's not encrypted.",
 913         &sorted!([
 914             ("store", false, &DATASTORE_SCHEMA),
 915             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
 916             ("backup-id", false,  &BACKUP_ID_SCHEMA),
 917             ("backup-time", false, &BACKUP_TIME_SCHEMA),
 918             ("file-name", false, &BACKUP_ARCHIVE_NAME_SCHEMA),
 919         ]),
 920     )
 921 ).access(None, &Permission::Privilege(
 922     &["datastore", "{store}"],
 923     PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP,
 924     true)
 925 );
 926
 927 fn download_file_decoded(
 928     _parts: Parts,
 929     _req_body: Body,
 930     param: Value,
 931     _info: &ApiMethod,
 932     rpcenv: Box<dyn RpcEnvironment>,
 933 ) -> ApiResponseFuture {
 934
 935     async move {
 936         let store = tools::required_string_param(&param, "store")?;
 937         let datastore = DataStore::lookup_datastore(store)?;
 938
 939         let userid: Userid = rpcenv.get_user().unwrap().parse()?;
 940         let user_info = CachedUserInfo::new()?;
 941         let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
 942
 943         let file_name = tools::required_string_param(&param, "file-name")?.to_owned();
 944
 945         let backup_type = tools::required_string_param(&param, "backup-type")?;
 946         let backup_id = tools::required_string_param(&param, "backup-id")?;
 947         let backup_time = tools::required_integer_param(&param, "backup-time")?;
 948
 949         let backup_dir = BackupDir::new(backup_type, backup_id, backup_time);
 950
 951         let allowed = (user_privs & PRIV_DATASTORE_READ) != 0;
 952         if !allowed { check_backup_owner(&datastore, backup_dir.group(), &userid)?; }
 953
 954         let (_manifest, files) = read_backup_index(&datastore, &backup_dir)?;
 955         for file in files {
 956             if file.filename == file_name && file.crypt_mode == Some(CryptMode::Encrypt) {
 957                 bail!("cannot decode '{}' - is encrypted", file_name);
 958             }
 959         }
 960
 961         println!("Download {} from {} ({}/{})", file_name, store, backup_dir, file_name);
 962
 963         let mut path = datastore.base_path();
 964         path.push(backup_dir.relative_path());
 965         path.push(&file_name);
 966
 967         let extension = file_name.rsplitn(2, '.').next().unwrap();
 968
 969         let body = match extension {
 970             "didx" => {
 971                 let index = DynamicIndexReader::open(&path)
 972                     .map_err(|err| format_err!("unable to read dynamic index '{:?}' - {}", &path, err))?;
 973
 974                 let chunk_reader = LocalChunkReader::new(datastore, None);
 975                 let reader = AsyncIndexReader::new(index, chunk_reader);
 976                 Body::wrap_stream(AsyncReaderStream::new(reader)
 977                     .map_err(move |err| {
 978                         eprintln!("error during streaming of '{:?}' - {}", path, err);
 979                         err
 980                     }))
 981             },
 982             "fidx" => {
 983                 let index = FixedIndexReader::open(&path)
 984                     .map_err(|err| format_err!("unable to read fixed index '{:?}' - {}", &path, err))?;
 985
 986                 let chunk_reader = LocalChunkReader::new(datastore, None);
 987                 let reader = AsyncIndexReader::new(index, chunk_reader);
 988                 Body::wrap_stream(AsyncReaderStream::with_buffer_size(reader, 4*1024*1024)
 989                     .map_err(move |err| {
 990                         eprintln!("error during streaming of '{:?}' - {}", path, err);
 991                         err
 992                     }))
 993             },
 994             "blob" => {
 995                 let file = std::fs::File::open(&path)
 996                     .map_err(|err| http_err!(BAD_REQUEST, "File open failed: {}", err))?;
 997
 998                 Body::wrap_stream(
 999                     WrappedReaderStream::new(DataBlobReader::new(file, None)?)
1000                         .map_err(move |err| {
1001                             eprintln!("error during streaming of '{:?}' - {}", path, err);
1002                             err
1003                         })
1004                 )
1005             },
1006             extension => {
1007                 bail!("cannot download '{}' files", extension);
1008             },
1009         };
1010
1011         // fixme: set other headers ?
1012         Ok(Response::builder()
1013            .status(StatusCode::OK)
1014            .header(header::CONTENT_TYPE, "application/octet-stream")
1015            .body(body)
1016            .unwrap())
1017     }.boxed()
1018 }
1019
1020 #[sortable]
1021 pub const API_METHOD_UPLOAD_BACKUP_LOG: ApiMethod = ApiMethod::new(
1022     &ApiHandler::AsyncHttp(&upload_backup_log),
1023     &ObjectSchema::new(
1024         "Upload the client backup log file into a backup snapshot ('client.log.blob').",
1025         &sorted!([
1026             ("store", false, &DATASTORE_SCHEMA),
1027             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
1028             ("backup-id", false, &BACKUP_ID_SCHEMA),
1029             ("backup-time", false, &BACKUP_TIME_SCHEMA),
1030         ]),
1031     )
1032 ).access(
1033     Some("Only the backup creator/owner is allowed to do this."),
1034     &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_BACKUP, false)
1035 );
1036
1037 fn upload_backup_log(
1038     _parts: Parts,
1039     req_body: Body,
1040     param: Value,
1041     _info: &ApiMethod,
1042     rpcenv: Box<dyn RpcEnvironment>,
1043 ) -> ApiResponseFuture {
1044
1045     async move {
1046         let store = tools::required_string_param(&param, "store")?;
1047         let datastore = DataStore::lookup_datastore(store)?;
1048
1049         let file_name =  CLIENT_LOG_BLOB_NAME;
1050
1051         let backup_type = tools::required_string_param(&param, "backup-type")?;
1052         let backup_id = tools::required_string_param(&param, "backup-id")?;
1053         let backup_time = tools::required_integer_param(&param, "backup-time")?;
1054
1055         let backup_dir = BackupDir::new(backup_type, backup_id, backup_time);
1056
1057         let userid: Userid = rpcenv.get_user().unwrap().parse()?;
1058         check_backup_owner(&datastore, backup_dir.group(), &userid)?;
1059
1060         let mut path = datastore.base_path();
1061         path.push(backup_dir.relative_path());
1062         path.push(&file_name);
1063
1064         if path.exists() {
1065             bail!("backup already contains a log.");
1066         }
1067
1068         println!("Upload backup log to {}/{}/{}/{}/{}", store,
1069                  backup_type, backup_id, BackupDir::backup_time_to_string(backup_dir.backup_time()), file_name);
1070
1071         let data = req_body
1072             .map_err(Error::from)
1073             .try_fold(Vec::new(), |mut acc, chunk| {
1074                 acc.extend_from_slice(&*chunk);
1075                 future::ok::<_, Error>(acc)
1076             })
1077             .await?;
1078
1079         // always verify blob/CRC at server side
1080         let blob = DataBlob::load_from_reader(&mut &data[..])?;
1081
1082         replace_file(&path, blob.raw_data(), CreateOptions::new())?;
1083
1084         // fixme: use correct formatter
1085         Ok(crate::server::formatter::json_response(Ok(Value::Null)))
1086     }.boxed()
1087 }
1088
1089 #[api(
1090     input: {
1091         properties: {
1092             store: {
1093                 schema: DATASTORE_SCHEMA,
1094             },
1095             "backup-type": {
1096                 schema: BACKUP_TYPE_SCHEMA,
1097             },
1098             "backup-id": {
1099                 schema: BACKUP_ID_SCHEMA,
1100             },
1101             "backup-time": {
1102                 schema: BACKUP_TIME_SCHEMA,
1103             },
1104             "filepath": {
1105                 description: "Base64 encoded path.",
1106                 type: String,
1107             }
1108         },
1109     },
1110     access: {
1111         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP, true),
1112     },
1113 )]
1114 /// Get the entries of the given path of the catalog
1115 fn catalog(
1116     store: String,
1117     backup_type: String,
1118     backup_id: String,
1119     backup_time: i64,
1120     filepath: String,
1121     _param: Value,
1122     _info: &ApiMethod,
1123     rpcenv: &mut dyn RpcEnvironment,
1124 ) -> Result<Value, Error> {
1125     let datastore = DataStore::lookup_datastore(&store)?;
1126
1127     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
1128     let user_info = CachedUserInfo::new()?;
1129     let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
1130
1131     let backup_dir = BackupDir::new(backup_type, backup_id, backup_time);
1132
1133     let allowed = (user_privs & PRIV_DATASTORE_READ) != 0;
1134     if !allowed { check_backup_owner(&datastore, backup_dir.group(), &userid)?; }
1135
1136     let file_name = CATALOG_NAME;
1137
1138     let (_manifest, files) = read_backup_index(&datastore, &backup_dir)?;
1139     for file in files {
1140         if file.filename == file_name && file.crypt_mode == Some(CryptMode::Encrypt) {
1141             bail!("cannot decode '{}' - is encrypted", file_name);
1142         }
1143     }
1144
1145     let mut path = datastore.base_path();
1146     path.push(backup_dir.relative_path());
1147     path.push(file_name);
1148
1149     let index = DynamicIndexReader::open(&path)
1150         .map_err(|err| format_err!("unable to read dynamic index '{:?}' - {}", &path, err))?;
1151
1152     let chunk_reader = LocalChunkReader::new(datastore, None);
1153     let reader = BufferedDynamicReader::new(index, chunk_reader);
1154
1155     let mut catalog_reader = CatalogReader::new(reader);
1156     let mut current = catalog_reader.root()?;
1157     let mut components = vec![];
1158
1159
1160     if filepath != "root" {
1161         components = base64::decode(filepath)?;
1162         if components.len() > 0 && components[0] == '/' as u8 {
1163             components.remove(0);
1164         }
1165         for component in components.split(|c| *c == '/' as u8) {
1166             if let Some(entry) = catalog_reader.lookup(&current, component)? {
1167                 current = entry;
1168             } else {
1169                 bail!("path {:?} not found in catalog", &String::from_utf8_lossy(&components));
1170             }
1171         }
1172     }
1173
1174     let mut res = Vec::new();
1175
1176     for direntry in catalog_reader.read_dir(&current)? {
1177         let mut components = components.clone();
1178         components.push('/' as u8);
1179         components.extend(&direntry.name);
1180         let path = base64::encode(components);
1181         let text = String::from_utf8_lossy(&direntry.name);
1182         let mut entry = json!({
1183             "filepath": path,
1184             "text": text,
1185             "type": CatalogEntryType::from(&direntry.attr).to_string(),
1186             "leaf": true,
1187         });
1188         match direntry.attr {
1189             DirEntryAttribute::Directory { start: _ } => {
1190                 entry["leaf"] = false.into();
1191             },
1192             DirEntryAttribute::File { size, mtime } => {
1193                 entry["size"] = size.into();
1194                 entry["mtime"] = mtime.into();
1195             },
1196             _ => {},
1197         }
1198         res.push(entry);
1199     }
1200
1201     Ok(res.into())
1202 }
1203
1204 #[sortable]
1205 pub const API_METHOD_PXAR_FILE_DOWNLOAD: ApiMethod = ApiMethod::new(
1206     &ApiHandler::AsyncHttp(&pxar_file_download),
1207     &ObjectSchema::new(
1208         "Download single file from pxar file of a bacup snapshot. Only works if it's not encrypted.",
1209         &sorted!([
1210             ("store", false, &DATASTORE_SCHEMA),
1211             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
1212             ("backup-id", false,  &BACKUP_ID_SCHEMA),
1213             ("backup-time", false, &BACKUP_TIME_SCHEMA),
1214             ("filepath", false, &StringSchema::new("Base64 encoded path").schema()),
1215         ]),
1216     )
1217 ).access(None, &Permission::Privilege(
1218     &["datastore", "{store}"],
1219     PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP,
1220     true)
1221 );
1222
1223 fn pxar_file_download(
1224     _parts: Parts,
1225     _req_body: Body,
1226     param: Value,
1227     _info: &ApiMethod,
1228     rpcenv: Box<dyn RpcEnvironment>,
1229 ) -> ApiResponseFuture {
1230
1231     async move {
1232         let store = tools::required_string_param(&param, "store")?;
1233         let datastore = DataStore::lookup_datastore(&store)?;
1234
1235         let userid: Userid = rpcenv.get_user().unwrap().parse()?;
1236         let user_info = CachedUserInfo::new()?;
1237         let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
1238
1239         let filepath = tools::required_string_param(&param, "filepath")?.to_owned();
1240
1241         let backup_type = tools::required_string_param(&param, "backup-type")?;
1242         let backup_id = tools::required_string_param(&param, "backup-id")?;
1243         let backup_time = tools::required_integer_param(&param, "backup-time")?;
1244
1245         let backup_dir = BackupDir::new(backup_type, backup_id, backup_time);
1246
1247         let allowed = (user_privs & PRIV_DATASTORE_READ) != 0;
1248         if !allowed { check_backup_owner(&datastore, backup_dir.group(), &userid)?; }
1249
1250         let mut components = base64::decode(&filepath)?;
1251         if components.len() > 0 && components[0] == '/' as u8 {
1252             components.remove(0);
1253         }
1254
1255         let mut split = components.splitn(2, |c| *c == '/' as u8);
1256         let pxar_name = std::str::from_utf8(split.next().unwrap())?;
1257         let file_path = split.next().ok_or(format_err!("filepath looks strange '{}'", filepath))?;
1258         let (_manifest, files) = read_backup_index(&datastore, &backup_dir)?;
1259         for file in files {
1260             if file.filename == pxar_name && file.crypt_mode == Some(CryptMode::Encrypt) {
1261                 bail!("cannot decode '{}' - is encrypted", pxar_name);
1262             }
1263         }
1264
1265         let mut path = datastore.base_path();
1266         path.push(backup_dir.relative_path());
1267         path.push(pxar_name);
1268
1269         let index = DynamicIndexReader::open(&path)
1270             .map_err(|err| format_err!("unable to read dynamic index '{:?}' - {}", &path, err))?;
1271
1272         let chunk_reader = LocalChunkReader::new(datastore, None);
1273         let reader = BufferedDynamicReader::new(index, chunk_reader);
1274         let archive_size = reader.archive_size();
1275         let reader = LocalDynamicReadAt::new(reader);
1276
1277         let decoder = Accessor::new(reader, archive_size).await?;
1278         let root = decoder.open_root().await?;
1279         let file = root
1280             .lookup(OsStr::from_bytes(file_path)).await?
1281             .ok_or(format_err!("error opening '{:?}'", file_path))?;
1282
1283         let file = match file.kind() {
1284             EntryKind::File { .. } => file,
1285             EntryKind::Hardlink(_) => {
1286                 decoder.follow_hardlink(&file).await?
1287             },
1288             // TODO symlink
1289             other => bail!("cannot download file of type {:?}", other),
1290         };
1291
1292         let body = Body::wrap_stream(
1293             AsyncReaderStream::new(file.contents().await?)
1294                 .map_err(move |err| {
1295                     eprintln!("error during streaming of '{:?}' - {}", filepath, err);
1296                     err
1297                 })
1298         );
1299
1300         // fixme: set other headers ?
1301         Ok(Response::builder()
1302            .status(StatusCode::OK)
1303            .header(header::CONTENT_TYPE, "application/octet-stream")
1304            .body(body)
1305            .unwrap())
1306     }.boxed()
1307 }
1308
1309 #[api(
1310     input: {
1311         properties: {
1312             store: {
1313                 schema: DATASTORE_SCHEMA,
1314             },
1315             timeframe: {
1316                 type: RRDTimeFrameResolution,
1317             },
1318             cf: {
1319                 type: RRDMode,
1320             },
1321         },
1322     },
1323     access: {
1324         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_BACKUP, true),
1325     },
1326 )]
1327 /// Read datastore stats
1328 fn get_rrd_stats(
1329     store: String,
1330     timeframe: RRDTimeFrameResolution,
1331     cf: RRDMode,
1332     _param: Value,
1333 ) -> Result<Value, Error> {
1334
1335     create_value_from_rrd(
1336         &format!("datastore/{}", store),
1337         &[
1338             "total", "used",
1339             "read_ios", "read_bytes",
1340             "write_ios", "write_bytes",
1341             "io_ticks",
1342         ],
1343         timeframe,
1344         cf,
1345     )
1346 }
1347
1348 #[api(
1349     input: {
1350         properties: {
1351             store: {
1352                 schema: DATASTORE_SCHEMA,
1353             },
1354             "backup-type": {
1355                 schema: BACKUP_TYPE_SCHEMA,
1356             },
1357             "backup-id": {
1358                 schema: BACKUP_ID_SCHEMA,
1359             },
1360             "backup-time": {
1361                 schema: BACKUP_TIME_SCHEMA,
1362             },
1363         },
1364     },
1365     access: {
1366         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_READ | PRIV_DATASTORE_BACKUP, true),
1367     },
1368 )]
1369 /// Get "notes" for a specific backup
1370 fn get_notes(
1371     store: String,
1372     backup_type: String,
1373     backup_id: String,
1374     backup_time: i64,
1375     rpcenv: &mut dyn RpcEnvironment,
1376 ) -> Result<String, Error> {
1377     let datastore = DataStore::lookup_datastore(&store)?;
1378
1379     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
1380     let user_info = CachedUserInfo::new()?;
1381     let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
1382
1383     let backup_dir = BackupDir::new(backup_type, backup_id, backup_time);
1384
1385     let allowed = (user_privs & PRIV_DATASTORE_READ) != 0;
1386     if !allowed { check_backup_owner(&datastore, backup_dir.group(), &userid)?; }
1387
1388     let manifest = datastore.load_manifest_json(&backup_dir)?;
1389
1390     let notes = manifest["unprotected"]["notes"]
1391         .as_str()
1392         .unwrap_or("");
1393
1394     Ok(String::from(notes))
1395 }
1396
1397 #[api(
1398     input: {
1399         properties: {
1400             store: {
1401                 schema: DATASTORE_SCHEMA,
1402             },
1403             "backup-type": {
1404                 schema: BACKUP_TYPE_SCHEMA,
1405             },
1406             "backup-id": {
1407                 schema: BACKUP_ID_SCHEMA,
1408             },
1409             "backup-time": {
1410                 schema: BACKUP_TIME_SCHEMA,
1411             },
1412             notes: {
1413                 description: "A multiline text.",
1414             },
1415         },
1416     },
1417     access: {
1418         permission: &Permission::Privilege(&["datastore", "{store}"], PRIV_DATASTORE_MODIFY, true),
1419     },
1420 )]
1421 /// Set "notes" for a specific backup
1422 fn set_notes(
1423     store: String,
1424     backup_type: String,
1425     backup_id: String,
1426     backup_time: i64,
1427     notes: String,
1428     rpcenv: &mut dyn RpcEnvironment,
1429 ) -> Result<(), Error> {
1430     let datastore = DataStore::lookup_datastore(&store)?;
1431
1432     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
1433     let user_info = CachedUserInfo::new()?;
1434     let user_privs = user_info.lookup_privs(&userid, &["datastore", &store]);
1435
1436     let backup_dir = BackupDir::new(backup_type, backup_id, backup_time);
1437
1438     let allowed = (user_privs & PRIV_DATASTORE_READ) != 0;
1439     if !allowed { check_backup_owner(&datastore, backup_dir.group(), &userid)?; }
1440
1441     let mut manifest = datastore.load_manifest_json(&backup_dir)?;
1442
1443     manifest["unprotected"]["notes"] = notes.into();
1444
1445     datastore.store_manifest(&backup_dir, manifest)?;
1446
1447     Ok(())
1448 }
1449
1450 #[sortable]
1451 const DATASTORE_INFO_SUBDIRS: SubdirMap = &[
1452     (
1453         "catalog",
1454         &Router::new()
1455             .get(&API_METHOD_CATALOG)
1456     ),
1457     (
1458         "download",
1459         &Router::new()
1460             .download(&API_METHOD_DOWNLOAD_FILE)
1461     ),
1462     (
1463         "download-decoded",
1464         &Router::new()
1465             .download(&API_METHOD_DOWNLOAD_FILE_DECODED)
1466     ),
1467     (
1468         "files",
1469         &Router::new()
1470             .get(&API_METHOD_LIST_SNAPSHOT_FILES)
1471     ),
1472     (
1473         "gc",
1474         &Router::new()
1475             .get(&API_METHOD_GARBAGE_COLLECTION_STATUS)
1476             .post(&API_METHOD_START_GARBAGE_COLLECTION)
1477     ),
1478     (
1479         "groups",
1480         &Router::new()
1481             .get(&API_METHOD_LIST_GROUPS)
1482     ),
1483     (
1484         "notes",
1485         &Router::new()
1486             .get(&API_METHOD_GET_NOTES)
1487             .put(&API_METHOD_SET_NOTES)
1488     ),
1489     (
1490         "prune",
1491         &Router::new()
1492             .post(&API_METHOD_PRUNE)
1493     ),
1494     (
1495         "pxar-file-download",
1496         &Router::new()
1497             .download(&API_METHOD_PXAR_FILE_DOWNLOAD)
1498     ),
1499     (
1500         "rrd",
1501         &Router::new()
1502             .get(&API_METHOD_GET_RRD_STATS)
1503     ),
1504     (
1505         "snapshots",
1506         &Router::new()
1507             .get(&API_METHOD_LIST_SNAPSHOTS)
1508             .delete(&API_METHOD_DELETE_SNAPSHOT)
1509     ),
1510     (
1511         "status",
1512         &Router::new()
1513             .get(&API_METHOD_STATUS)
1514     ),
1515     (
1516         "upload-backup-log",
1517         &Router::new()
1518             .upload(&API_METHOD_UPLOAD_BACKUP_LOG)
1519     ),
1520     (
1521         "verify",
1522         &Router::new()
1523             .post(&API_METHOD_VERIFY)
1524     ),
1525 ];
1526
1527 const DATASTORE_INFO_ROUTER: Router = Router::new()
1528     .get(&list_subdirs_api_method!(DATASTORE_INFO_SUBDIRS))
1529     .subdirs(DATASTORE_INFO_SUBDIRS);
1530
1531
1532 pub const ROUTER: Router = Router::new()
1533     .get(&API_METHOD_GET_DATASTORE_LIST)
1534     .match_all("store", &DATASTORE_INFO_ROUTER);