]>
Commit | Line | Data |
---|---|---|
59e9ba01 DM |
1 | use failure::*; |
2 | use std::convert::TryFrom; | |
1e8da0a7 | 3 | use std::path::Path; |
59e9ba01 DM |
4 | |
5 | use serde_json::{json, Value}; | |
6 | ||
7 | use crate::backup::BackupDir; | |
8 | ||
9 | pub const MANIFEST_BLOB_NAME: &str = "index.json.blob"; | |
10 | ||
1e8da0a7 DM |
11 | pub struct FileInfo { |
12 | pub filename: String, | |
13 | pub size: u64, | |
14 | pub csum: [u8; 32], | |
59e9ba01 DM |
15 | } |
16 | ||
17 | pub struct BackupManifest { | |
18 | snapshot: BackupDir, | |
19 | files: Vec<FileInfo>, | |
20 | } | |
21 | ||
1e8da0a7 DM |
22 | #[derive(PartialEq)] |
23 | pub enum ArchiveType { | |
24 | FixedIndex, | |
25 | DynamicIndex, | |
26 | Blob, | |
27 | } | |
28 | ||
29 | pub fn archive_type<P: AsRef<Path>>( | |
30 | archive_name: P, | |
31 | ) -> Result<ArchiveType, Error> { | |
32 | ||
33 | let archive_name = archive_name.as_ref(); | |
34 | let archive_type = match archive_name.extension().and_then(|ext| ext.to_str()) { | |
35 | Some("didx") => ArchiveType::DynamicIndex, | |
36 | Some("fidx") => ArchiveType::FixedIndex, | |
37 | Some("blob") => ArchiveType::Blob, | |
38 | _ => bail!("unknown archive type: {:?}", archive_name), | |
39 | }; | |
40 | Ok(archive_type) | |
41 | } | |
42 | ||
43 | ||
59e9ba01 DM |
44 | impl BackupManifest { |
45 | ||
46 | pub fn new(snapshot: BackupDir) -> Self { | |
47 | Self { files: Vec::new(), snapshot } | |
48 | } | |
49 | ||
1e8da0a7 DM |
50 | pub fn add_file(&mut self, filename: String, size: u64, csum: [u8; 32]) -> Result<(), Error> { |
51 | let _archive_type = archive_type(&filename)?; // check type | |
59e9ba01 | 52 | self.files.push(FileInfo { filename, size, csum }); |
1e8da0a7 DM |
53 | Ok(()) |
54 | } | |
55 | ||
56 | pub fn files(&self) -> &[FileInfo] { | |
57 | &self.files[..] | |
59e9ba01 DM |
58 | } |
59 | ||
f06b820a DM |
60 | fn lookup_file_info(&self, name: &str) -> Result<&FileInfo, Error> { |
61 | ||
62 | let info = self.files.iter().find(|item| item.filename == name); | |
63 | ||
64 | match info { | |
65 | None => bail!("manifest does not contain file '{}'", name), | |
66 | Some(info) => Ok(info), | |
67 | } | |
68 | } | |
69 | ||
70 | pub fn verify_file(&self, name: &str, csum: &[u8; 32], size: u64) -> Result<(), Error> { | |
71 | ||
72 | let info = self.lookup_file_info(name)?; | |
73 | ||
74 | if size != info.size { | |
75 | bail!("wrong size for file '{}' ({} != {}", name, info.size, size); | |
76 | } | |
77 | ||
78 | if csum != &info.csum { | |
79 | bail!("wrong checksum for file '{}'", name); | |
80 | } | |
81 | ||
82 | Ok(()) | |
83 | } | |
84 | ||
59e9ba01 DM |
85 | pub fn into_json(self) -> Value { |
86 | json!({ | |
87 | "backup-type": self.snapshot.group().backup_type(), | |
88 | "backup-id": self.snapshot.group().backup_id(), | |
89 | "backup-time": self.snapshot.backup_time().timestamp(), | |
90 | "files": self.files.iter() | |
91 | .fold(Vec::new(), |mut acc, info| { | |
92 | acc.push(json!({ | |
93 | "filename": info.filename, | |
94 | "size": info.size, | |
95 | "csum": proxmox::tools::digest_to_hex(&info.csum), | |
96 | })); | |
97 | acc | |
98 | }) | |
99 | }) | |
100 | } | |
101 | ||
102 | } | |
247a8ca5 DM |
103 | impl TryFrom<super::DataBlob> for BackupManifest { |
104 | type Error = Error; | |
105 | ||
106 | fn try_from(blob: super::DataBlob) -> Result<Self, Error> { | |
107 | let data = blob.decode(None) | |
108 | .map_err(|err| format_err!("decode backup manifest blob failed - {}", err))?; | |
109 | let json: Value = serde_json::from_slice(&data[..]) | |
110 | .map_err(|err| format_err!("unable to parse backup manifest json - {}", err))?; | |
111 | BackupManifest::try_from(json) | |
112 | } | |
113 | } | |
59e9ba01 DM |
114 | |
115 | impl TryFrom<Value> for BackupManifest { | |
116 | type Error = Error; | |
117 | ||
118 | fn try_from(data: Value) -> Result<Self, Error> { | |
119 | ||
511a47bd DM |
120 | use crate::tools::{required_string_property, required_integer_property, required_array_property}; |
121 | ||
9ea4bce4 | 122 | proxmox::try_block!({ |
60ffa964 DM |
123 | let backup_type = required_string_property(&data, "backup-type")?; |
124 | let backup_id = required_string_property(&data, "backup-id")?; | |
125 | let backup_time = required_integer_property(&data, "backup-time")?; | |
59e9ba01 | 126 | |
f06b820a | 127 | let snapshot = BackupDir::new(backup_type, backup_id, backup_time); |
59e9ba01 | 128 | |
1e8da0a7 DM |
129 | let mut manifest = BackupManifest::new(snapshot); |
130 | ||
f06b820a DM |
131 | for item in required_array_property(&data, "files")?.iter() { |
132 | let filename = required_string_property(item, "filename")?.to_owned(); | |
133 | let csum = required_string_property(item, "csum")?; | |
134 | let csum = proxmox::tools::hex_to_digest(csum)?; | |
135 | let size = required_integer_property(item, "size")? as u64; | |
1e8da0a7 | 136 | manifest.add_file(filename, size, csum)?; |
f06b820a | 137 | } |
51534c8d DM |
138 | |
139 | if manifest.files().is_empty() { | |
140 | bail!("manifest does not list any files."); | |
141 | } | |
142 | ||
1e8da0a7 | 143 | Ok(manifest) |
f06b820a | 144 | }).map_err(|err: Error| format_err!("unable to parse backup manifest - {}", err)) |
59e9ba01 | 145 | |
59e9ba01 DM |
146 | } |
147 | } |