impl ArchiveEntry {
pub fn new(filepath: &[u8], entry_type: Option<&DirEntryAttribute>) -> Self {
+ let size = match entry_type {
+ Some(DirEntryAttribute::File { size, .. }) => Some(*size),
+ _ => None,
+ };
+ Self::new_with_size(filepath, entry_type, size)
+ }
+
+ pub fn new_with_size(
+ filepath: &[u8],
+ entry_type: Option<&DirEntryAttribute>,
+ size: Option<u64>,
+ ) -> Self {
Self {
filepath: base64::encode(filepath),
text: String::from_utf8_lossy(filepath.split(|x| *x == b'/').last().unwrap())
None => "v".to_owned(),
},
leaf: !matches!(entry_type, None | Some(DirEntryAttribute::Directory { .. })),
- size: match entry_type {
- Some(DirEntryAttribute::File { size, .. }) => Some(*size),
- _ => None
- },
+ size,
mtime: match entry_type {
Some(DirEntryAttribute::File { mtime, .. }) => Some(*mtime),
- _ => None
+ _ => None,
},
}
}
for c in comps {
let mut c_path = path.clone();
c_path.push(b'/');
- c_path.extend(c.as_bytes());
- res.push(ArchiveEntry::new(
+ c_path.extend(c.0.as_bytes());
+ res.push(ArchiveEntry::new_with_size(
&c_path[..],
// this marks the beginning of a filesystem, i.e. '/', so this is a Directory
Some(&DirEntryAttribute::Directory { start: 0 }),
+ Some(c.1),
));
}
}
pub enum ResolveResult {
Path(PathBuf),
BucketTypes(Vec<&'static str>),
- BucketComponents(Vec<String>),
+ BucketComponents(Vec<(String, u64)>),
}
struct PartitionBucketData {
dev_node: String,
number: i32,
mountpoint: Option<PathBuf>,
+ size: u64,
}
/// A "Bucket" represents a mapping found on a disk, e.g. a partition, a zfs dataset or an LV. A
Bucket::Partition(data) => data.number.to_string(),
}
}
+
+ fn size(&self) -> u64 {
+ match self {
+ Bucket::Partition(data) => data.size,
+ }
+ }
}
/// Functions related to the local filesystem. This mostly exists so we can use 'supported_fs' in
.trim()
.parse::<i32>()?;
+ // this *always* contains the number of 512-byte sectors, regardless of the true
+ // blocksize of this disk - which should always be 512 here anyway
+ let size = fs::file_read_firstline(&format!("{}/size", part_path))?
+ .trim()
+ .parse::<u64>()?
+ * 512;
+
info!(
- "drive '{}' ('{}'): found partition '{}' ({})",
- name, fidx, devnode, number
+ "drive '{}' ('{}'): found partition '{}' ({}, {}B)",
+ name, fidx, devnode, number, size
);
let bucket = Bucket::Partition(PartitionBucketData {
dev_node: devnode,
mountpoint: None,
number,
+ size,
});
parts.push(bucket);
let comps = buckets
.iter()
.filter(|b| b.type_string() == bucket_type)
- .map(Bucket::component_string)
+ .map(|b| (b.component_string(), b.size()))
.collect();
return Ok(ResolveResult::BucketComponents(comps));
}