src/api2/backup.rs

   1 use anyhow::{bail, format_err, Error};
   2 use futures::*;
   3 use hyper::header::{HeaderValue, UPGRADE};
   4 use hyper::http::request::Parts;
   5 use hyper::{Body, Response, StatusCode};
   6 use serde_json::{json, Value};
   7
   8 use proxmox::{sortable, identity, list_subdirs_api_method};
   9 use proxmox::api::{ApiResponseFuture, ApiHandler, ApiMethod, Router, RpcEnvironment, Permission};
  10 use proxmox::api::router::SubdirMap;
  11 use proxmox::api::schema::*;
  12
  13 use crate::tools;
  14 use crate::server::{WorkerTask, H2Service};
  15 use crate::backup::*;
  16 use crate::api2::types::*;
  17 use crate::config::acl::PRIV_DATASTORE_BACKUP;
  18 use crate::config::cached_user_info::CachedUserInfo;
  19 use crate::tools::fs::lock_dir_noblock_shared;
  20
  21 mod environment;
  22 use environment::*;
  23
  24 mod upload_chunk;
  25 use upload_chunk::*;
  26
  27 pub const ROUTER: Router = Router::new()
  28     .upgrade(&API_METHOD_UPGRADE_BACKUP);
  29
  30 #[sortable]
  31 pub const API_METHOD_UPGRADE_BACKUP: ApiMethod = ApiMethod::new(
  32     &ApiHandler::AsyncHttp(&upgrade_to_backup_protocol),
  33     &ObjectSchema::new(
  34         concat!("Upgraded to backup protocol ('", PROXMOX_BACKUP_PROTOCOL_ID_V1!(), "')."),
  35         &sorted!([
  36             ("store", false, &DATASTORE_SCHEMA),
  37             ("backup-type", false, &BACKUP_TYPE_SCHEMA),
  38             ("backup-id", false, &BACKUP_ID_SCHEMA),
  39             ("backup-time", false, &BACKUP_TIME_SCHEMA),
  40             ("debug", true, &BooleanSchema::new("Enable verbose debug logging.").schema()),
  41             ("benchmark", true, &BooleanSchema::new("Job is a benchmark (do not keep data).").schema()),
  42         ]),
  43     )
  44 ).access(
  45     // Note: parameter 'store' is no uri parameter, so we need to test inside function body
  46     Some("The user needs Datastore.Backup privilege on /datastore/{store} and needs to own the backup group."),
  47     &Permission::Anybody
  48 );
  49
  50 fn upgrade_to_backup_protocol(
  51     parts: Parts,
  52     req_body: Body,
  53     param: Value,
  54     _info: &ApiMethod,
  55     rpcenv: Box<dyn RpcEnvironment>,
  56 ) -> ApiResponseFuture {
  57
  58 async move {
  59     let debug = param["debug"].as_bool().unwrap_or(false);
  60     let benchmark = param["benchmark"].as_bool().unwrap_or(false);
  61
  62     let userid: Userid = rpcenv.get_user().unwrap().parse()?;
  63
  64     let store = tools::required_string_param(&param, "store")?.to_owned();
  65
  66     let user_info = CachedUserInfo::new()?;
  67     user_info.check_privs(&userid, &["datastore", &store], PRIV_DATASTORE_BACKUP, false)?;
  68
  69     let datastore = DataStore::lookup_datastore(&store)?;
  70
  71     let backup_type = tools::required_string_param(&param, "backup-type")?;
  72     let backup_id = tools::required_string_param(&param, "backup-id")?;
  73     let backup_time = tools::required_integer_param(&param, "backup-time")?;
  74
  75     let protocols = parts
  76         .headers
  77         .get("UPGRADE")
  78         .ok_or_else(|| format_err!("missing Upgrade header"))?
  79         .to_str()?;
  80
  81     if protocols != PROXMOX_BACKUP_PROTOCOL_ID_V1!() {
  82         bail!("invalid protocol name");
  83     }
  84
  85     if parts.version >=  http::version::Version::HTTP_2 {
  86         bail!("unexpected http version '{:?}' (expected version < 2)", parts.version);
  87     }
  88
  89     let worker_id = format!("{}_{}_{}", store, backup_type, backup_id);
  90
  91     let env_type = rpcenv.env_type();
  92
  93     let backup_group = BackupGroup::new(backup_type, backup_id);
  94
  95     let worker_type = if backup_type == "host" && backup_id == "benchmark" {
  96         if !benchmark {
  97             bail!("unable to run benchmark without --benchmark flags");
  98         }
  99         "benchmark"
 100     } else {
 101         if benchmark {
 102             bail!("benchmark flags is only allowed on 'host/benchmark'");
 103         }
 104         "backup"
 105     };
 106
 107     // lock backup group to only allow one backup per group at a time
 108     let (owner, _group_guard) = datastore.create_locked_backup_group(&backup_group, &userid)?;
 109
 110     // permission check
 111     if owner != userid && worker_type != "benchmark" {
 112         // only the owner is allowed to create additional snapshots
 113         bail!("backup owner check failed ({} != {})", userid, owner);
 114     }
 115
 116     let last_backup = {
 117         let info = BackupInfo::last_backup(&datastore.base_path(), &backup_group, true).unwrap_or(None);
 118         if let Some(info) = info {
 119             let (manifest, _) = datastore.load_manifest(&info.backup_dir)?;
 120             let verify = manifest.unprotected["verify_state"].clone();
 121             match serde_json::from_value::<SnapshotVerifyState>(verify) {
 122                 Ok(verify) => {
 123                     match verify.state {
 124                         VerifyState::Ok => Some(info),
 125                         VerifyState::Failed => None,
 126                     }
 127                 },
 128                 Err(_) => {
 129                     // no verify state found, treat as valid
 130                     Some(info)
 131                 }
 132             }
 133         } else {
 134             None
 135         }
 136     };
 137
 138     let backup_dir = BackupDir::with_group(backup_group.clone(), backup_time)?;
 139
 140     let _last_guard = if let Some(last) = &last_backup {
 141         if backup_dir.backup_time() <= last.backup_dir.backup_time() {
 142             bail!("backup timestamp is older than last backup.");
 143         }
 144
 145         // lock last snapshot to prevent forgetting/pruning it during backup
 146         let full_path = datastore.snapshot_path(&last.backup_dir);
 147         Some(lock_dir_noblock_shared(&full_path, "snapshot", "base snapshot is already locked by another operation")?)
 148     } else {
 149         None
 150     };
 151
 152     let (path, is_new, _snap_guard) = datastore.create_locked_backup_dir(&backup_dir)?;
 153     if !is_new { bail!("backup directory already exists."); }
 154
 155
 156     WorkerTask::spawn(worker_type, Some(worker_id), userid.clone(), true, move |worker| {
 157         let mut env = BackupEnvironment::new(
 158             env_type, userid, worker.clone(), datastore, backup_dir);
 159
 160         env.debug = debug;
 161         env.last_backup = last_backup;
 162
 163         env.log(format!("starting new {} on datastore '{}': {:?}", worker_type, store, path));
 164
 165         let service = H2Service::new(env.clone(), worker.clone(), &BACKUP_API_ROUTER, debug);
 166
 167         let abort_future = worker.abort_future();
 168
 169         let env2 = env.clone();
 170
 171         let mut req_fut = req_body
 172             .on_upgrade()
 173             .map_err(Error::from)
 174             .and_then(move |conn| {
 175                 env2.debug("protocol upgrade done");
 176
 177                 let mut http = hyper::server::conn::Http::new();
 178                 http.http2_only(true);
 179                 // increase window size: todo - find optiomal size
 180                 let window_size = 32*1024*1024; // max = (1 << 31) - 2
 181                 http.http2_initial_stream_window_size(window_size);
 182                 http.http2_initial_connection_window_size(window_size);
 183                 http.http2_max_frame_size(4*1024*1024);
 184
 185                 http.serve_connection(conn, service)
 186                     .map_err(Error::from)
 187             });
 188         let mut abort_future = abort_future
 189             .map(|_| Err(format_err!("task aborted")));
 190
 191         async move {
 192             // keep flock until task ends
 193             let _group_guard = _group_guard;
 194             let _snap_guard = _snap_guard;
 195             let _last_guard = _last_guard;
 196
 197             let res = select!{
 198                 req = req_fut => req,
 199                 abrt = abort_future => abrt,
 200             };
 201             if benchmark {
 202                 env.log("benchmark finished successfully");
 203                 tools::runtime::block_in_place(|| env.remove_backup())?;
 204                 return Ok(());
 205             }
 206             match (res, env.ensure_finished()) {
 207                 (Ok(_), Ok(())) => {
 208                     env.log("backup finished successfully");
 209                     Ok(())
 210                 },
 211                 (Err(err), Ok(())) => {
 212                     // ignore errors after finish
 213                     env.log(format!("backup had errors but finished: {}", err));
 214                     Ok(())
 215                 },
 216                 (Ok(_), Err(err)) => {
 217                     env.log(format!("backup ended and finish failed: {}", err));
 218                     env.log("removing unfinished backup");
 219                     env.remove_backup()?;
 220                     Err(err)
 221                 },
 222                 (Err(err), Err(_)) => {
 223                     env.log(format!("backup failed: {}", err));
 224                     env.log("removing failed backup");
 225                     tools::runtime::block_in_place(|| env.remove_backup())?;
 226                     Err(err)
 227                 },
 228             }
 229         }
 230     })?;
 231
 232     let response = Response::builder()
 233         .status(StatusCode::SWITCHING_PROTOCOLS)
 234         .header(UPGRADE, HeaderValue::from_static(PROXMOX_BACKUP_PROTOCOL_ID_V1!()))
 235         .body(Body::empty())?;
 236
 237     Ok(response)
 238     }.boxed()
 239 }
 240
 241 pub const BACKUP_API_SUBDIRS: SubdirMap = &[
 242     (
 243         "blob", &Router::new()
 244             .upload(&API_METHOD_UPLOAD_BLOB)
 245     ),
 246     (
 247         "dynamic_chunk", &Router::new()
 248             .upload(&API_METHOD_UPLOAD_DYNAMIC_CHUNK)
 249     ),
 250     (
 251         "dynamic_close", &Router::new()
 252             .post(&API_METHOD_CLOSE_DYNAMIC_INDEX)
 253     ),
 254     (
 255         "dynamic_index", &Router::new()
 256             .post(&API_METHOD_CREATE_DYNAMIC_INDEX)
 257             .put(&API_METHOD_DYNAMIC_APPEND)
 258     ),
 259     (
 260         "finish", &Router::new()
 261             .post(
 262                 &ApiMethod::new(
 263                     &ApiHandler::Sync(&finish_backup),
 264                     &ObjectSchema::new("Mark backup as finished.", &[])
 265                 )
 266             )
 267     ),
 268     (
 269         "fixed_chunk", &Router::new()
 270             .upload(&API_METHOD_UPLOAD_FIXED_CHUNK)
 271     ),
 272     (
 273         "fixed_close", &Router::new()
 274             .post(&API_METHOD_CLOSE_FIXED_INDEX)
 275     ),
 276     (
 277         "fixed_index", &Router::new()
 278             .post(&API_METHOD_CREATE_FIXED_INDEX)
 279             .put(&API_METHOD_FIXED_APPEND)
 280     ),
 281     (
 282         "previous", &Router::new()
 283             .download(&API_METHOD_DOWNLOAD_PREVIOUS)
 284     ),
 285     (
 286         "speedtest", &Router::new()
 287             .upload(&API_METHOD_UPLOAD_SPEEDTEST)
 288     ),
 289 ];
 290
 291 pub const BACKUP_API_ROUTER: Router = Router::new()
 292     .get(&list_subdirs_api_method!(BACKUP_API_SUBDIRS))
 293     .subdirs(BACKUP_API_SUBDIRS);
 294
 295 #[sortable]
 296 pub const API_METHOD_CREATE_DYNAMIC_INDEX: ApiMethod = ApiMethod::new(
 297     &ApiHandler::Sync(&create_dynamic_index),
 298     &ObjectSchema::new(
 299         "Create dynamic chunk index file.",
 300         &sorted!([
 301             ("archive-name", false, &crate::api2::types::BACKUP_ARCHIVE_NAME_SCHEMA),
 302         ]),
 303     )
 304 );
 305
 306 fn create_dynamic_index(
 307     param: Value,
 308     _info: &ApiMethod,
 309     rpcenv: &mut dyn RpcEnvironment,
 310 ) -> Result<Value, Error> {
 311
 312     let env: &BackupEnvironment = rpcenv.as_ref();
 313
 314     let name = tools::required_string_param(&param, "archive-name")?.to_owned();
 315
 316     let archive_name = name.clone();
 317     if !archive_name.ends_with(".didx") {
 318         bail!("wrong archive extension: '{}'", archive_name);
 319     }
 320
 321     let mut path = env.backup_dir.relative_path();
 322     path.push(archive_name);
 323
 324     let index = env.datastore.create_dynamic_writer(&path)?;
 325     let wid = env.register_dynamic_writer(index, name)?;
 326
 327     env.log(format!("created new dynamic index {} ({:?})", wid, path));
 328
 329     Ok(json!(wid))
 330 }
 331
 332 #[sortable]
 333 pub const API_METHOD_CREATE_FIXED_INDEX: ApiMethod = ApiMethod::new(
 334     &ApiHandler::Sync(&create_fixed_index),
 335     &ObjectSchema::new(
 336         "Create fixed chunk index file.",
 337         &sorted!([
 338             ("archive-name", false, &crate::api2::types::BACKUP_ARCHIVE_NAME_SCHEMA),
 339             ("size", false, &IntegerSchema::new("File size.")
 340              .minimum(1)
 341              .schema()
 342             ),
 343             ("reuse-csum", true, &StringSchema::new("If set, compare last backup's \
 344                 csum and reuse index for incremental backup if it matches.").schema()),
 345         ]),
 346     )
 347 );
 348
 349 fn create_fixed_index(
 350     param: Value,
 351     _info: &ApiMethod,
 352     rpcenv: &mut dyn RpcEnvironment,
 353 ) -> Result<Value, Error> {
 354
 355     let env: &BackupEnvironment = rpcenv.as_ref();
 356
 357     let name = tools::required_string_param(&param, "archive-name")?.to_owned();
 358     let size = tools::required_integer_param(&param, "size")? as usize;
 359     let reuse_csum = param["reuse-csum"].as_str();
 360
 361     let archive_name = name.clone();
 362     if !archive_name.ends_with(".fidx") {
 363         bail!("wrong archive extension: '{}'", archive_name);
 364     }
 365
 366     let mut path = env.backup_dir.relative_path();
 367     path.push(&archive_name);
 368
 369     let chunk_size = 4096*1024; // todo: ??
 370
 371     // do incremental backup if csum is set
 372     let mut reader = None;
 373     let mut incremental = false;
 374     if let Some(csum) = reuse_csum {
 375         incremental = true;
 376         let last_backup = match &env.last_backup {
 377             Some(info) => info,
 378             None => {
 379                 bail!("cannot reuse index - no valid previous backup exists");
 380             }
 381         };
 382
 383         let mut last_path = last_backup.backup_dir.relative_path();
 384         last_path.push(&archive_name);
 385
 386         let index = match env.datastore.open_fixed_reader(last_path) {
 387             Ok(index) => index,
 388             Err(_) => {
 389                 bail!("cannot reuse index - no previous backup exists for archive");
 390             }
 391         };
 392
 393         let (old_csum, _) = index.compute_csum();
 394         let old_csum = proxmox::tools::digest_to_hex(&old_csum);
 395         if old_csum != csum {
 396             bail!("expected csum ({}) doesn't match last backup's ({}), cannot do incremental backup",
 397                 csum, old_csum);
 398         }
 399
 400         reader = Some(index);
 401     }
 402
 403     let mut writer = env.datastore.create_fixed_writer(&path, size, chunk_size)?;
 404
 405     if let Some(reader) = reader {
 406         writer.clone_data_from(&reader)?;
 407     }
 408
 409     let wid = env.register_fixed_writer(writer, name, size, chunk_size as u32, incremental)?;
 410
 411     env.log(format!("created new fixed index {} ({:?})", wid, path));
 412
 413     Ok(json!(wid))
 414 }
 415
 416 #[sortable]
 417 pub const API_METHOD_DYNAMIC_APPEND: ApiMethod = ApiMethod::new(
 418     &ApiHandler::Sync(&dynamic_append),
 419     &ObjectSchema::new(
 420         "Append chunk to dynamic index writer.",
 421         &sorted!([
 422             (
 423                 "wid",
 424                 false,
 425                 &IntegerSchema::new("Dynamic writer ID.")
 426                     .minimum(1)
 427                     .maximum(256)
 428                     .schema()
 429             ),
 430             (
 431                 "digest-list",
 432                 false,
 433                 &ArraySchema::new("Chunk digest list.", &CHUNK_DIGEST_SCHEMA).schema()
 434             ),
 435             (
 436                 "offset-list",
 437                 false,
 438                 &ArraySchema::new(
 439                     "Chunk offset list.",
 440                     &IntegerSchema::new("Corresponding chunk offsets.")
 441                         .minimum(0)
 442                         .schema()
 443                 ).schema()
 444             ),
 445         ]),
 446     )
 447 );
 448
 449 fn dynamic_append (
 450     param: Value,
 451     _info: &ApiMethod,
 452     rpcenv: &mut dyn RpcEnvironment,
 453 ) -> Result<Value, Error> {
 454
 455     let wid = tools::required_integer_param(&param, "wid")? as usize;
 456     let digest_list = tools::required_array_param(&param, "digest-list")?;
 457     let offset_list = tools::required_array_param(&param, "offset-list")?;
 458
 459     if offset_list.len() != digest_list.len() {
 460         bail!("offset list has wrong length ({} != {})", offset_list.len(), digest_list.len());
 461     }
 462
 463     let env: &BackupEnvironment = rpcenv.as_ref();
 464
 465     env.debug(format!("dynamic_append {} chunks", digest_list.len()));
 466
 467     for (i, item) in digest_list.iter().enumerate() {
 468         let digest_str = item.as_str().unwrap();
 469         let digest = proxmox::tools::hex_to_digest(digest_str)?;
 470         let offset = offset_list[i].as_u64().unwrap();
 471         let size = env.lookup_chunk(&digest).ok_or_else(|| format_err!("no such chunk {}", digest_str))?;
 472
 473         env.dynamic_writer_append_chunk(wid, offset, size, &digest)?;
 474
 475         env.debug(format!("successfully added chunk {} to dynamic index {} (offset {}, size {})", digest_str, wid, offset, size));
 476     }
 477
 478     Ok(Value::Null)
 479 }
 480
 481 #[sortable]
 482 pub const API_METHOD_FIXED_APPEND: ApiMethod = ApiMethod::new(
 483     &ApiHandler::Sync(&fixed_append),
 484     &ObjectSchema::new(
 485         "Append chunk to fixed index writer.",
 486         &sorted!([
 487             (
 488                 "wid",
 489                 false,
 490                 &IntegerSchema::new("Fixed writer ID.")
 491                     .minimum(1)
 492                     .maximum(256)
 493                     .schema()
 494             ),
 495             (
 496                 "digest-list",
 497                 false,
 498                 &ArraySchema::new("Chunk digest list.", &CHUNK_DIGEST_SCHEMA).schema()
 499             ),
 500             (
 501                 "offset-list",
 502                 false,
 503                 &ArraySchema::new(
 504                     "Chunk offset list.",
 505                     &IntegerSchema::new("Corresponding chunk offsets.")
 506                         .minimum(0)
 507                         .schema()
 508                 ).schema()
 509             )
 510         ]),
 511     )
 512 );
 513
 514 fn fixed_append (
 515     param: Value,
 516     _info: &ApiMethod,
 517     rpcenv: &mut dyn RpcEnvironment,
 518 ) -> Result<Value, Error> {
 519
 520     let wid = tools::required_integer_param(&param, "wid")? as usize;
 521     let digest_list = tools::required_array_param(&param, "digest-list")?;
 522     let offset_list = tools::required_array_param(&param, "offset-list")?;
 523
 524     if offset_list.len() != digest_list.len() {
 525         bail!("offset list has wrong length ({} != {})", offset_list.len(), digest_list.len());
 526     }
 527
 528     let env: &BackupEnvironment = rpcenv.as_ref();
 529
 530     env.debug(format!("fixed_append {} chunks", digest_list.len()));
 531
 532     for (i, item) in digest_list.iter().enumerate() {
 533         let digest_str = item.as_str().unwrap();
 534         let digest = proxmox::tools::hex_to_digest(digest_str)?;
 535         let offset = offset_list[i].as_u64().unwrap();
 536         let size = env.lookup_chunk(&digest).ok_or_else(|| format_err!("no such chunk {}", digest_str))?;
 537
 538         env.fixed_writer_append_chunk(wid, offset, size, &digest)?;
 539
 540         env.debug(format!("successfully added chunk {} to fixed index {} (offset {}, size {})", digest_str, wid, offset, size));
 541     }
 542
 543     Ok(Value::Null)
 544 }
 545
 546 #[sortable]
 547 pub const API_METHOD_CLOSE_DYNAMIC_INDEX: ApiMethod = ApiMethod::new(
 548     &ApiHandler::Sync(&close_dynamic_index),
 549     &ObjectSchema::new(
 550         "Close dynamic index writer.",
 551         &sorted!([
 552             (
 553                 "wid",
 554                 false,
 555                 &IntegerSchema::new("Dynamic writer ID.")
 556                     .minimum(1)
 557                     .maximum(256)
 558                     .schema()
 559             ),
 560             (
 561                 "chunk-count",
 562                 false,
 563                 &IntegerSchema::new("Chunk count. This is used to verify that the server got all chunks.")
 564                     .minimum(1)
 565                     .schema()
 566             ),
 567             (
 568                 "size",
 569                 false,
 570                 &IntegerSchema::new("File size. This is used to verify that the server got all data.")
 571                     .minimum(1)
 572                     .schema()
 573             ),
 574             ("csum", false, &StringSchema::new("Digest list checksum.").schema()),
 575         ]),
 576     )
 577 );
 578
 579 fn close_dynamic_index (
 580     param: Value,
 581     _info: &ApiMethod,
 582     rpcenv: &mut dyn RpcEnvironment,
 583 ) -> Result<Value, Error> {
 584
 585     let wid = tools::required_integer_param(&param, "wid")? as usize;
 586     let chunk_count = tools::required_integer_param(&param, "chunk-count")? as u64;
 587     let size = tools::required_integer_param(&param, "size")? as u64;
 588     let csum_str = tools::required_string_param(&param, "csum")?;
 589     let csum = proxmox::tools::hex_to_digest(csum_str)?;
 590
 591     let env: &BackupEnvironment = rpcenv.as_ref();
 592
 593     env.dynamic_writer_close(wid, chunk_count, size, csum)?;
 594
 595     env.log(format!("successfully closed dynamic index {}", wid));
 596
 597     Ok(Value::Null)
 598 }
 599
 600 #[sortable]
 601 pub const API_METHOD_CLOSE_FIXED_INDEX: ApiMethod = ApiMethod::new(
 602     &ApiHandler::Sync(&close_fixed_index),
 603     &ObjectSchema::new(
 604         "Close fixed index writer.",
 605         &sorted!([
 606             (
 607                 "wid",
 608                 false,
 609                 &IntegerSchema::new("Fixed writer ID.")
 610                     .minimum(1)
 611                     .maximum(256)
 612                     .schema()
 613             ),
 614             (
 615                 "chunk-count",
 616                 false,
 617                 &IntegerSchema::new("Chunk count. This is used to verify that the server got all chunks. Ignored for incremental backups.")
 618                     .minimum(0)
 619                     .schema()
 620             ),
 621             (
 622                 "size",
 623                 false,
 624                 &IntegerSchema::new("File size. This is used to verify that the server got all data. Ignored for incremental backups.")
 625                     .minimum(0)
 626                     .schema()
 627             ),
 628             ("csum", false, &StringSchema::new("Digest list checksum.").schema()),
 629         ]),
 630     )
 631 );
 632
 633 fn close_fixed_index (
 634     param: Value,
 635     _info: &ApiMethod,
 636     rpcenv: &mut dyn RpcEnvironment,
 637 ) -> Result<Value, Error> {
 638
 639     let wid = tools::required_integer_param(&param, "wid")? as usize;
 640     let chunk_count = tools::required_integer_param(&param, "chunk-count")? as u64;
 641     let size = tools::required_integer_param(&param, "size")? as u64;
 642     let csum_str = tools::required_string_param(&param, "csum")?;
 643     let csum = proxmox::tools::hex_to_digest(csum_str)?;
 644
 645     let env: &BackupEnvironment = rpcenv.as_ref();
 646
 647     env.fixed_writer_close(wid, chunk_count, size, csum)?;
 648
 649     env.log(format!("successfully closed fixed index {}", wid));
 650
 651     Ok(Value::Null)
 652 }
 653
 654 fn finish_backup (
 655     _param: Value,
 656     _info: &ApiMethod,
 657     rpcenv: &mut dyn RpcEnvironment,
 658 ) -> Result<Value, Error> {
 659
 660     let env: &BackupEnvironment = rpcenv.as_ref();
 661
 662     env.finish_backup()?;
 663     env.log("successfully finished backup");
 664
 665     Ok(Value::Null)
 666 }
 667
 668 #[sortable]
 669 pub const API_METHOD_DOWNLOAD_PREVIOUS: ApiMethod = ApiMethod::new(
 670     &ApiHandler::AsyncHttp(&download_previous),
 671     &ObjectSchema::new(
 672         "Download archive from previous backup.",
 673         &sorted!([
 674             ("archive-name", false, &crate::api2::types::BACKUP_ARCHIVE_NAME_SCHEMA)
 675         ]),
 676     )
 677 );
 678
 679 fn download_previous(
 680     _parts: Parts,
 681     _req_body: Body,
 682     param: Value,
 683     _info: &ApiMethod,
 684     rpcenv: Box<dyn RpcEnvironment>,
 685 ) -> ApiResponseFuture {
 686
 687     async move {
 688         let env: &BackupEnvironment = rpcenv.as_ref();
 689
 690         let archive_name = tools::required_string_param(&param, "archive-name")?.to_owned();
 691
 692         let last_backup = match &env.last_backup {
 693             Some(info) => info,
 694             None => bail!("no valid previous backup"),
 695         };
 696
 697         let mut path = env.datastore.snapshot_path(&last_backup.backup_dir);
 698         path.push(&archive_name);
 699
 700         {
 701             let index: Option<Box<dyn IndexFile>> = match archive_type(&archive_name)? {
 702                 ArchiveType::FixedIndex => {
 703                     let index = env.datastore.open_fixed_reader(&path)?;
 704                     Some(Box::new(index))
 705                 }
 706                 ArchiveType::DynamicIndex => {
 707                     let index = env.datastore.open_dynamic_reader(&path)?;
 708                     Some(Box::new(index))
 709                 }
 710                 _ => { None }
 711             };
 712             if let Some(index) = index {
 713                 env.log(format!("register chunks in '{}' from previous backup.", archive_name));
 714
 715                 for pos in 0..index.index_count() {
 716                     let info = index.chunk_info(pos).unwrap();
 717                     let size = info.range.end - info.range.start;
 718                     env.register_chunk(info.digest, size as u32)?;
 719                 }
 720             }
 721         }
 722
 723         env.log(format!("download '{}' from previous backup.", archive_name));
 724         crate::api2::helpers::create_download_response(path).await
 725     }.boxed()
 726 }