src/backup/manifest.rs: new helper archive_type()

[proxmox-backup.git] / src / backup / manifest.rs

diff --git a/src/backup/manifest.rs b/src/backup/manifest.rs
index 8d5d4488edb0c360324eab6028d949abdc42c2f5..7eaa170480b07b9644f9dce1b69ad4cdd71bf525 100644 (file)
--- a/src/backup/manifest.rs
+++ b/src/backup/manifest.rs
@@ -1,5 +1,6 @@
 use failure::*;
 use std::convert::TryFrom;
+use std::path::Path;
 
 use serde_json::{json, Value};
 
@@ -7,10 +8,10 @@ use crate::backup::BackupDir;
 
 pub const MANIFEST_BLOB_NAME: &str = "index.json.blob";
 
-struct FileInfo {
-    filename: String,
-    size: u64,
-    csum: [u8; 32],
+pub struct FileInfo {
+    pub filename: String,
+    pub size: u64,
+    pub csum: [u8; 32],
 }
 
 pub struct BackupManifest {
@@ -18,14 +19,67 @@ pub struct BackupManifest {
     files: Vec<FileInfo>,
 }
 
+#[derive(PartialEq)]
+pub enum ArchiveType {
+    FixedIndex,
+    DynamicIndex,
+    Blob,
+}
+
+pub fn archive_type<P: AsRef<Path>>(
+    archive_name: P,
+) -> Result<ArchiveType, Error> {
+
+    let archive_name = archive_name.as_ref();
+    let archive_type = match archive_name.extension().and_then(|ext| ext.to_str()) {
+        Some("didx") => ArchiveType::DynamicIndex,
+        Some("fidx") => ArchiveType::FixedIndex,
+        Some("blob") => ArchiveType::Blob,
+        _ => bail!("unknown archive type: {:?}", archive_name),
+    };
+    Ok(archive_type)
+}
+
+
 impl BackupManifest {
 
     pub fn new(snapshot: BackupDir) -> Self {
         Self { files: Vec::new(), snapshot }
     }
 
-    pub fn add_file(&mut self, filename: String, size: u64, csum: [u8; 32]) {
+    pub fn add_file(&mut self, filename: String, size: u64, csum: [u8; 32]) -> Result<(), Error> {
+        let _archive_type = archive_type(&filename)?; // check type
         self.files.push(FileInfo { filename, size, csum });
+        Ok(())
+    }
+
+    pub fn files(&self) -> &[FileInfo] {
+        &self.files[..]
+    }
+
+    fn lookup_file_info(&self, name: &str) -> Result<&FileInfo, Error> {
+
+        let info = self.files.iter().find(|item| item.filename == name);
+
+        match info {
+            None => bail!("manifest does not contain file '{}'", name),
+            Some(info) => Ok(info),
+        }
+    }
+
+    pub fn verify_file(&self, name: &str, csum: &[u8; 32], size: u64) -> Result<(), Error> {
+
+        let info = self.lookup_file_info(name)?;
+
+        if size != info.size {
+            bail!("wrong size for file '{}' ({} != {}", name, info.size, size);
+        }
+
+        if csum != &info.csum {
+            bail!("wrong checksum for file '{}'", name);
+        }
+
+        Ok(())
     }
 
     pub fn into_json(self) -> Value {
@@ -52,14 +106,26 @@ impl TryFrom<Value> for BackupManifest {
 
     fn try_from(data: Value) -> Result<Self, Error> {
 
-        let backup_type = data["backup_type"].as_str().unwrap();
-        let backup_id = data["backup_id"].as_str().unwrap();
-        let backup_time = data["backup_time"].as_i64().unwrap();
+        use crate::tools::{required_string_property, required_integer_property, required_array_property};
+
+        proxmox::tools::try_block!({
+            let backup_type = required_string_property(&data, "backup-type")?;
+            let backup_id = required_string_property(&data, "backup-id")?;
+            let backup_time = required_integer_property(&data, "backup-time")?;
+
+            let snapshot = BackupDir::new(backup_type, backup_id, backup_time);
 
-        let snapshot = BackupDir::new(backup_type, backup_id, backup_time);
+            let mut manifest = BackupManifest::new(snapshot);
 
-        let files = Vec::new();
+            for item in required_array_property(&data, "files")?.iter() {
+                let filename = required_string_property(item, "filename")?.to_owned();
+                let csum = required_string_property(item, "csum")?;
+                let csum = proxmox::tools::hex_to_digest(csum)?;
+                let size = required_integer_property(item, "size")? as u64;
+                manifest.add_file(filename, size, csum)?;
+            }
+            Ok(manifest)
+        }).map_err(|err: Error| format_err!("unable to parse backup manifest - {}", err))
 
-        Ok(Self { files, snapshot })
     }
 }