bail!("backup does not contain valid files (file count == 0)");
}
- // check manifest
- let (mut manifest, _) = self.datastore.load_manifest(&self.backup_dir)
- .map_err(|err| format_err!("unable to load manifest blob - {}", err))?;
-
+ // check for valid manifest and store stats
let stats = serde_json::to_value(state.backup_stat)?;
-
- manifest.unprotected["chunk_upload_stats"] = stats;
-
- self.datastore.store_manifest(&self.backup_dir, manifest)
- .map_err(|err| format_err!("unable to store manifest blob - {}", err))?;
+ self.datastore.update_manifest(&self.backup_dir, |manifest| {
+ manifest.unprotected["chunk_upload_stats"] = stats;
+ }).map_err(|err| format_err!("unable to update manifest blob - {}", err))?;
if let Some(base) = &self.last_backup {
let path = self.datastore.snapshot_path(&base.backup_dir);
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use std::convert::TryFrom;
+use std::time::Duration;
+use std::fs::File;
use anyhow::{bail, format_err, Error};
use lazy_static::lazy_static;
-use proxmox::tools::fs::{replace_file, CreateOptions};
+use proxmox::tools::fs::{replace_file, CreateOptions, open_file_locked};
use super::backup_info::{BackupGroup, BackupDir};
use super::chunk_store::ChunkStore;
use super::dynamic_index::{DynamicIndexReader, DynamicIndexWriter};
use super::fixed_index::{FixedIndexReader, FixedIndexWriter};
-use super::manifest::{MANIFEST_BLOB_NAME, CLIENT_LOG_BLOB_NAME, BackupManifest};
+use super::manifest::{MANIFEST_BLOB_NAME, MANIFEST_LOCK_NAME, CLIENT_LOG_BLOB_NAME, BackupManifest};
use super::index::*;
use super::{DataBlob, ArchiveType, archive_type};
use crate::config::datastore;
let full_path = self.snapshot_path(backup_dir);
- let _guard;
+ let (_guard, _manifest_guard);
if !force {
_guard = lock_dir_noblock(&full_path, "snapshot", "possibly running or in use")?;
+ _manifest_guard = self.lock_manifest(backup_dir);
}
log::info!("removing backup snapshot {:?}", full_path);
digest_str,
err,
))
- }
+ }
+
+ fn lock_manifest(
+ &self,
+ backup_dir: &BackupDir,
+ ) -> Result<File, Error> {
+ let mut path = self.base_path();
+ path.push(backup_dir.relative_path());
+ path.push(&MANIFEST_LOCK_NAME);
+
+ // update_manifest should never take a long time, so if someone else has
+ // the lock we can simply block a bit and should get it soon
+ open_file_locked(&path, Duration::from_secs(5), true)
+ .map_err(|err| {
+ format_err!(
+ "unable to acquire manifest lock {:?} - {}", &path, err
+ )
+ })
+ }
+ /// Load the manifest without a lock. Must not be written back.
pub fn load_manifest(
&self,
backup_dir: &BackupDir,
Ok((manifest, raw_size))
}
- pub fn store_manifest(
+ /// Update the manifest of the specified snapshot. Never write a manifest directly,
+ /// only use this method - anything else may break locking guarantees.
+ pub fn update_manifest(
&self,
backup_dir: &BackupDir,
- manifest: BackupManifest,
+ update_fn: impl FnOnce(&mut BackupManifest),
) -> Result<(), Error> {
+
+ let _guard = self.lock_manifest(backup_dir)?;
+ let (mut manifest, _) = self.load_manifest(&backup_dir)?;
+
+ update_fn(&mut manifest);
+
let manifest = serde_json::to_value(manifest)?;
let manifest = serde_json::to_string_pretty(&manifest)?;
let blob = DataBlob::encode(manifest.as_bytes(), None, true)?;
path.push(backup_dir.relative_path());
path.push(MANIFEST_BLOB_NAME);
+ // atomic replace invalidates flock - no other writes past this point!
replace_file(&path, raw_data, CreateOptions::new())?;
Ok(())
return Ok(true);
}
- let mut manifest = match datastore.load_manifest(&backup_dir) {
+ let manifest = match datastore.load_manifest(&backup_dir) {
Ok((manifest, _)) => manifest,
Err(err) => {
task_log!(
state: verify_result,
upid,
};
- manifest.unprotected["verify_state"] = serde_json::to_value(verify_state)?;
- datastore.store_manifest(&backup_dir, manifest)
- .map_err(|err| format_err!("unable to store manifest blob - {}", err))?;
+ let verify_state = serde_json::to_value(verify_state)?;
+ datastore.update_manifest(&backup_dir, |manifest| {
+ manifest.unprotected["verify_state"] = verify_state;
+ }).map_err(|err| format_err!("unable to update manifest blob - {}", err))?;
Ok(error_count == 0)
}