use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use prolink_proto::rpc::nfs2::{FType, Fattr, FileHandle, FileHandleKey};
use sha2::{Digest, Sha256};
use unicode_normalization::UnicodeNormalization;
const EPOCH: u32 = 1_600_000_000;
#[derive(Clone, Debug)]
pub enum Node {
Directory {
children: Vec<String>,
},
Memory {
data: Vec<u8>,
},
Disk {
path: PathBuf,
size: u64,
},
}
impl Node {
pub fn is_dir(&self) -> bool {
matches!(self, Self::Directory { .. })
}
pub fn size(&self) -> u64 {
match self {
Self::Directory { .. } => 0,
Self::Memory { data } => data.len().try_into().unwrap_or(u64::MAX),
Self::Disk { size, .. } => *size,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct Preserved {
pub kept: usize,
pub dropped: usize,
}
#[derive(Clone, Debug)]
struct Entry {
path: String,
node: Node,
}
#[derive(Debug, Default)]
pub struct Vfs {
entries: BTreeMap<FileHandleKey, Entry>,
aliases: BTreeMap<(String, Vec<u8>), String>,
}
impl Vfs {
pub fn new() -> Self {
let mut vfs = Self {
entries: BTreeMap::new(),
aliases: BTreeMap::new(),
};
vfs.insert(
"/",
Node::Directory {
children: Vec::new(),
},
);
vfs
}
pub fn handle_for(path: &str) -> FileHandle {
let digest = Sha256::digest(path.as_bytes());
let mut handle = [0u8; FileHandle::LEN];
for (slot, byte) in handle.iter_mut().zip(digest.iter()) {
*slot = *byte;
}
FileHandle(handle)
}
pub fn root(&self) -> FileHandle {
Self::handle_for("/")
}
pub fn mount(&mut self, prefix: &str, directory: &Path) -> std::io::Result<usize> {
let prefix = prefix.trim_matches('/');
let mount_point = format!("/{prefix}");
self.ensure_parents(&mount_point);
if !self
.entries
.contains_key(&Self::handle_for(&mount_point).key())
{
self.insert(
&mount_point,
Node::Directory {
children: Vec::new(),
},
);
}
if let Some((parent, name)) = split(&mount_point) {
self.add_child(&parent, &name);
}
let mut mounted = 0;
let mut stack = vec![(directory.to_path_buf(), mount_point)];
while let Some((disk, virtual_path)) = stack.pop() {
let Ok(listing) = std::fs::read_dir(&disk) else {
continue;
};
let mut entries: Vec<_> = listing.flatten().collect();
entries.sort_by_key(std::fs::DirEntry::file_name);
for entry in entries {
let name = entry.file_name().to_string_lossy().into_owned();
let child_path = join(&virtual_path, &name);
let Ok(metadata) = entry.metadata() else {
continue;
};
if metadata.is_dir() {
self.insert(
&child_path,
Node::Directory {
children: Vec::new(),
},
);
self.add_child(&virtual_path, &name);
stack.push((entry.path(), child_path));
} else if metadata.is_file() {
self.insert(
&child_path,
Node::Disk {
path: entry.path(),
size: metadata.len(),
},
);
self.add_child(&virtual_path, &name);
mounted += 1;
}
}
}
Ok(mounted)
}
pub fn preserve(&mut self, prefix: &str, cache: &BTreeMap<String, PathBuf>) -> Preserved {
let prefix = prefix.trim_matches('/');
let under = format!("/{prefix}/");
let mut result = Preserved::default();
let mut doomed: Vec<(FileHandleKey, String)> = Vec::new();
for (key, entry) in &mut self.entries {
if !entry.path.starts_with(&under) {
continue;
}
match &mut entry.node {
Node::Directory { .. } | Node::Memory { .. } => {}
Node::Disk { path, .. } => {
if let Some(copy) = cache.get(&entry.path) {
path.clone_from(copy);
result.kept += 1;
} else {
doomed.push((*key, entry.path.clone()));
}
}
}
}
for (key, path) in doomed {
self.entries.remove(&key);
if let Some((parent, name)) = split(&path) {
self.remove_child(&parent, &name);
}
result.dropped += 1;
}
result
}
pub fn mount_medium(&mut self, medium: &crate::serve::Medium) -> std::io::Result<usize> {
let Some(root) = medium.root() else {
return Ok(0);
};
let prefix = medium.slot().vfs_prefix();
let mounted = self.mount(prefix, root)?;
if let Some(folders) = medium.folders() {
let export = format!("/{prefix}");
for file in folders.files() {
self.alias(
&export,
crate::serve::folder::lookup_name(file.folder, file.id),
&format!("{export}/{}", file.relative),
);
}
}
Ok(mounted)
}
pub fn alias(&mut self, directory: &str, name: Vec<u8>, target: &str) {
self.aliases
.insert((directory.to_owned(), name), target.to_owned());
}
pub fn lookup_alias(&self, directory: FileHandle, name: &[u8]) -> Option<(FileHandle, &Node)> {
let parent = self.entries.get(&directory.key())?;
let target = self.aliases.get(&(parent.path.clone(), name.to_vec()))?;
let handle = Self::handle_for(target);
Some((handle, &self.entries.get(&handle.key())?.node))
}
pub fn unmount(&mut self, prefix: &str) -> usize {
let prefix = prefix.trim_matches('/');
let mount_point = format!("/{prefix}");
let under = format!("{mount_point}/");
let doomed: Vec<FileHandleKey> = self
.entries
.iter()
.filter(|(_, entry)| entry.path == mount_point || entry.path.starts_with(&under))
.map(|(key, _)| *key)
.collect();
for key in &doomed {
self.entries.remove(key);
}
self.aliases.retain(|(directory, _), _| {
*directory != mount_point && !directory.starts_with(&under)
});
if let Some((parent, name)) = split(&mount_point) {
self.remove_child(&parent, &name);
}
doomed.len()
}
fn remove_child(&mut self, directory: &str, name: &str) {
if let Some(entry) = self.entries.get_mut(&Self::handle_for(directory).key())
&& let Node::Directory { children } = &mut entry.node
{
children.retain(|child| child != name);
}
}
pub fn add_file(&mut self, path: &str, data: Vec<u8>) {
self.ensure_parents(path);
if let Some((parent, name)) = split(path) {
self.add_child(&parent, &name);
}
self.insert(path, Node::Memory { data });
}
pub fn resolve(&self, handle: FileHandle) -> Option<&Node> {
self.entries.get(&handle.key()).map(|entry| &entry.node)
}
pub fn path_of(&self, handle: FileHandle) -> Option<&str> {
self.entries
.get(&handle.key())
.map(|entry| entry.path.as_str())
}
pub fn lookup(&self, directory: FileHandle, name: &str) -> Option<(FileHandle, &Node)> {
let parent = self.entries.get(&directory.key())?;
let Node::Directory { children } = &parent.node else {
return None;
};
let stored = children
.iter()
.find(|child| child.as_str() == name)
.or_else(|| children.iter().find(|child| fold(child) == fold(name)))?;
let path = join(&parent.path, stored);
let handle = Self::handle_for(&path);
Some((handle, &self.entries.get(&handle.key())?.node))
}
pub fn read_dir(&self, directory: FileHandle) -> Option<&[String]> {
match self.resolve(directory)? {
Node::Directory { children } => Some(children),
_ => None,
}
}
pub fn read(&self, handle: FileHandle, offset: u64, count: usize) -> Option<Vec<u8>> {
match self.resolve(handle)? {
Node::Directory { .. } => None,
Node::Memory { data } => {
let start = usize::try_from(offset)
.unwrap_or(usize::MAX)
.min(data.len());
let end = start.saturating_add(count).min(data.len());
Some(data.get(start..end).unwrap_or_default().to_vec())
}
Node::Disk { path, .. } => Some(read_range(path, offset, count)),
}
}
pub fn attributes(&self, handle: FileHandle) -> Option<Fattr> {
let node = self.resolve(handle)?;
let size = u32::try_from(node.size()).unwrap_or(u32::MAX);
Some(Fattr {
ftype: if node.is_dir() {
FType::DIR
} else {
FType::REG
},
mode: if node.is_dir() { 0o040_755 } else { 0o100_644 },
nlink: if node.is_dir() { 2 } else { 1 },
uid: 0,
gid: 0,
size,
blocksize: 512,
rdev: 0,
blocks: size / 512 + u32::from(size % 512 != 0),
fsid: 1,
fileid: handle.fileid(),
atime_sec: EPOCH,
atime_usec: 0,
mtime_sec: EPOCH,
mtime_usec: 0,
ctime_sec: EPOCH,
ctime_usec: 0,
})
}
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn is_empty(&self) -> bool {
self.entries.len() <= 1
}
fn insert(&mut self, path: &str, node: Node) {
let handle = Self::handle_for(path);
self.entries.insert(
handle.key(),
Entry {
path: path.to_owned(),
node,
},
);
}
fn ensure_parents(&mut self, path: &str) {
let mut walked = String::new();
let components: Vec<&str> = path.split('/').filter(|part| !part.is_empty()).collect();
let Some((_, parents)) = components.split_last() else {
return;
};
for component in parents {
let parent = if walked.is_empty() {
"/".to_owned()
} else {
walked.clone()
};
walked = join(&parent, component);
if !self.entries.contains_key(&Self::handle_for(&walked).key()) {
self.insert(
&walked,
Node::Directory {
children: Vec::new(),
},
);
}
self.add_child(&parent, component);
}
}
fn add_child(&mut self, directory: &str, name: &str) {
let key = Self::handle_for(directory).key();
if let Some(Entry {
node: Node::Directory { children },
..
}) = self.entries.get_mut(&key)
&& !children.iter().any(|child| child == name)
{
children.push(name.to_owned());
}
}
}
fn fold(name: &str) -> String {
name.nfc().collect::<String>().to_lowercase()
}
fn join(parent: &str, name: &str) -> String {
if parent == "/" {
format!("/{name}")
} else {
format!("{parent}/{name}")
}
}
fn split(path: &str) -> Option<(String, String)> {
let (parent, name) = path.rsplit_once('/')?;
Some((
if parent.is_empty() {
"/".to_owned()
} else {
parent.to_owned()
},
name.to_owned(),
))
}
fn read_range(path: &Path, offset: u64, count: usize) -> Vec<u8> {
use std::io::{Read, Seek, SeekFrom};
let Ok(mut file) = std::fs::File::open(path) else {
return Vec::new();
};
if file.seek(SeekFrom::Start(offset)).is_err() {
return Vec::new();
}
let mut buffer = vec![0u8; count];
let mut filled = 0;
while filled < count {
match file.read(buffer.get_mut(filled..).unwrap_or_default()) {
Ok(0) | Err(_) => break,
Ok(read) => filled += read,
}
}
buffer.truncate(filled);
buffer
}
#[cfg(test)]
mod tests {
use super::*;
fn tree() -> Vfs {
let mut vfs = Vfs::new();
vfs.add_file("/C/PIONEER/rekordbox/export.pdb", b"pdb".to_vec());
vfs.add_file("/C/Contents/GESAFFELSTEIN/track.mp3", b"audio".to_vec());
vfs.add_file(
"/C/Contents/\u{30ab}\u{3099}\u{30ab}\u{3099}\u{30df}.mp3",
b"nfd".to_vec(),
);
vfs
}
#[test]
fn unmounting_takes_the_subtree_and_the_name_its_parent_lists() {
let mut vfs = tree();
let root = vfs.root();
assert!(
vfs.read_dir(root)
.is_some_and(|names| names.contains(&"C".to_owned())),
"the mount point is listed before it goes"
);
let file = Vfs::handle_for("/C/Contents/GESAFFELSTEIN/track.mp3");
assert!(vfs.resolve(file).is_some());
let removed = vfs.unmount("C");
assert!(removed > 0, "something was there");
assert!(
vfs.resolve(file).is_none(),
"a handle under a pulled medium must stop resolving"
);
assert!(
vfs.resolve(Vfs::handle_for("/C")).is_none(),
"and so must the mount point itself"
);
assert!(
!vfs.read_dir(root)
.is_some_and(|names| names.contains(&"C".to_owned())),
"a READDIR that names an entry LOOKUP cannot find reads as a corrupt \
medium rather than an absent one"
);
assert_eq!(
vfs.unmount("C"),
0,
"unmounting an empty slot is not an error: a caller does not always \
know whether anything was there"
);
}
#[test]
fn a_handle_survives_a_cdj_rewriting_its_tail() {
let vfs = tree();
let served = Vfs::handle_for("/C/PIONEER");
let mut returned = served;
returned.0[12..].copy_from_slice(&[0xab; 20]);
assert_ne!(served, returned, "the bytes really are different");
assert!(vfs.resolve(returned).is_some(), "and it must still resolve");
assert_eq!(vfs.path_of(returned), Some("/C/PIONEER"));
}
#[test]
fn two_media_do_not_share_a_handle() {
assert_ne!(Vfs::handle_for("/C/PIONEER"), Vfs::handle_for("/B/PIONEER"));
assert_ne!(Vfs::handle_for("/C"), Vfs::handle_for("/B"));
}
#[test]
fn a_lookup_walks_one_component() {
let vfs = tree();
let (contents, node) = vfs.lookup(Vfs::handle_for("/C"), "Contents").unwrap();
assert!(node.is_dir());
assert_eq!(vfs.path_of(contents), Some("/C/Contents"));
}
#[test]
fn a_name_differing_only_in_case_still_resolves() {
let vfs = tree();
let contents = Vfs::handle_for("/C/Contents");
let (handle, _) = vfs
.lookup(contents, "Gesaffelstein")
.expect("the fold must match");
assert_eq!(
vfs.path_of(handle),
Some("/C/Contents/GESAFFELSTEIN"),
"the handle must be for the name as stored, or every later use is STALE",
);
}
#[test]
fn a_name_differing_only_in_normalisation_still_resolves() {
let vfs = tree();
let composed = "\u{30ac}\u{30ac}\u{30df}.mp3";
let decomposed = "\u{30ab}\u{3099}\u{30ab}\u{3099}\u{30df}.mp3";
assert_ne!(
composed.as_bytes(),
decomposed.as_bytes(),
"genuinely different bytes"
);
let (handle, _) = vfs
.lookup(Vfs::handle_for("/C/Contents"), composed)
.expect("NFC must find NFD");
assert_eq!(
vfs.path_of(handle),
Some(format!("/C/Contents/{decomposed}").as_str())
);
}
#[test]
fn an_exact_match_wins_over_a_folded_one() {
let mut vfs = Vfs::new();
vfs.add_file("/x/TRACK.mp3", b"upper".to_vec());
vfs.add_file("/x/track.mp3", b"lower".to_vec());
let (handle, _) = vfs.lookup(Vfs::handle_for("/x"), "track.mp3").unwrap();
assert_eq!(
vfs.read(handle, 0, 16).as_deref(),
Some(b"lower".as_slice())
);
}
#[test]
fn a_name_no_directory_lists_can_stand_for_a_file() {
let mut vfs = tree();
let name = vec![0x3f, 0x00, b'D', b' ', b'2', b' ', b'5'];
let track = "/C/Contents/GESAFFELSTEIN/track.mp3";
vfs.alias("/C", name.clone(), track);
let export = Vfs::handle_for("/C");
let (handle, node) = vfs.lookup_alias(export, &name).expect("the alias resolves");
assert_eq!(handle, Vfs::handle_for(track));
assert!(!node.is_dir());
assert!(
vfs.lookup_alias(Vfs::handle_for("/C/Contents"), &name)
.is_none(),
"the root's only"
);
assert!(
vfs.read_dir(export)
.expect("a directory")
.iter()
.all(|child| child != "?")
);
vfs.unmount("C");
assert!(
vfs.lookup_alias(export, &name).is_none(),
"gone with the subtree"
);
}
#[test]
fn an_unknown_handle_is_stale_not_a_panic() {
let vfs = tree();
assert!(vfs.resolve(Vfs::handle_for("/nowhere")).is_none());
assert!(vfs.read(Vfs::handle_for("/nowhere"), 0, 16).is_none());
}
#[test]
fn a_read_past_the_end_is_short_not_an_error() {
let vfs = tree();
let handle = Vfs::handle_for("/C/PIONEER/rekordbox/export.pdb");
assert_eq!(
vfs.read(handle, 0, 8192).as_deref(),
Some(b"pdb".as_slice())
);
assert_eq!(vfs.read(handle, 2, 8192).as_deref(), Some(b"b".as_slice()));
assert_eq!(vfs.read(handle, 99, 8192).as_deref(), Some(b"".as_slice()));
}
#[test]
fn a_directory_cannot_be_read() {
let vfs = tree();
assert!(vfs.read(Vfs::handle_for("/C"), 0, 16).is_none());
}
#[test]
fn attributes_take_their_fileid_from_the_handle() {
let vfs = tree();
let handle = Vfs::handle_for("/C/PIONEER/rekordbox/export.pdb");
let attributes = vfs.attributes(handle).unwrap();
assert_eq!(attributes.fileid, handle.fileid());
assert_eq!(attributes.ftype, FType::REG);
assert_eq!(attributes.size, 3);
}
#[test]
fn a_mounted_directory_is_walkable() {
let root = std::env::temp_dir().join(format!("prolink-vfs-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("PIONEER/rekordbox")).unwrap();
std::fs::write(root.join("PIONEER/rekordbox/export.pdb"), b"real bytes").unwrap();
let mut vfs = Vfs::new();
let mounted = vfs.mount("C", &root).unwrap();
assert_eq!(mounted, 1);
let (pioneer, _) = vfs.lookup(Vfs::handle_for("/C"), "PIONEER").unwrap();
let (rekordbox, _) = vfs.lookup(pioneer, "rekordbox").unwrap();
let (pdb, node) = vfs.lookup(rekordbox, "export.pdb").unwrap();
assert!(!node.is_dir());
assert_eq!(vfs.read(pdb, 5, 5).as_deref(), Some(b"bytes".as_slice()));
std::fs::remove_dir_all(&root).unwrap();
}
fn scratch(name: &str, contents: &[u8]) -> (PathBuf, PathBuf) {
use std::sync::atomic::{AtomicU32, Ordering};
static NEXT: AtomicU32 = AtomicU32::new(0);
let directory = std::env::temp_dir().join(format!(
"prolink-vfs-{}-{}",
std::process::id(),
NEXT.fetch_add(1, Ordering::Relaxed)
));
std::fs::create_dir_all(&directory).expect("scratch");
let path = directory.join(name);
std::fs::write(&path, contents).expect("write");
(directory, path)
}
#[test]
fn a_preserved_file_is_answered_from_its_copy() {
let (_original, original) = scratch("track.mp3", b"the original bytes");
let (_copy, copy) = scratch("copy.mp3", b"the original bytes");
let mut vfs = Vfs::new();
vfs.insert(
"/C/Contents/track.mp3",
Node::Disk {
path: original.clone(),
size: 18,
},
);
vfs.add_child("/C/Contents", "track.mp3");
let handle = Vfs::handle_for("/C/Contents/track.mp3");
let mut cache = BTreeMap::new();
cache.insert("/C/Contents/track.mp3".to_owned(), copy);
let result = vfs.preserve("C", &cache);
assert_eq!(result.kept, 1);
assert_eq!(result.dropped, 0);
assert_eq!(
vfs.read(handle, 0, 18).expect("read"),
b"the original bytes".to_vec()
);
std::fs::remove_file(&original).expect("remove");
assert_eq!(
vfs.read(handle, 0, 18).expect("read"),
b"the original bytes".to_vec()
);
}
#[test]
fn an_unpreserved_file_stops_existing_rather_than_reading_as_silence() {
let (_directory, path) = scratch("other.mp3", b"bytes");
let mut vfs = Vfs::new();
vfs.insert("/C/Contents/other.mp3", Node::Disk { path, size: 5 });
vfs.add_child("/C/Contents", "other.mp3");
let handle = Vfs::handle_for("/C/Contents/other.mp3");
let result = vfs.preserve("C", &BTreeMap::new());
assert_eq!(result.kept, 0);
assert_eq!(result.dropped, 1);
assert!(vfs.resolve(handle).is_none());
assert!(vfs.read(handle, 0, 5).is_none());
}
#[test]
fn a_dropped_file_leaves_no_name_in_its_parent() {
let (_directory, path) = scratch("gone.mp3", b"bytes");
let mut vfs = Vfs::new();
vfs.ensure_parents("/C/Contents/gone.mp3");
vfs.insert("/C/Contents/gone.mp3", Node::Disk { path, size: 5 });
vfs.add_child("/C/Contents", "gone.mp3");
vfs.preserve("C", &BTreeMap::new());
let listing = vfs
.read_dir(Vfs::handle_for("/C/Contents"))
.expect("a directory");
assert!(!listing.contains(&"gone.mp3".to_owned()));
}
#[test]
fn directories_and_memory_files_are_left_alone() {
let mut vfs = tree();
let result = vfs.preserve("C", &BTreeMap::new());
assert_eq!(result.dropped, 0, "nothing here is disk-backed");
assert!(vfs.resolve(Vfs::handle_for("/C/Contents")).is_some());
assert_eq!(
vfs.read(Vfs::handle_for("/C/PIONEER/rekordbox/export.pdb"), 0, 3),
Some(b"pdb".to_vec())
);
}
#[test]
fn another_slot_is_untouched() {
let (_directory, path) = scratch("track.mp3", b"bytes");
let mut vfs = Vfs::new();
vfs.insert(
"/B/Contents/track.mp3",
Node::Disk {
path: path.clone(),
size: 5,
},
);
vfs.add_child("/B/Contents", "track.mp3");
let result = vfs.preserve("C", &BTreeMap::new());
assert_eq!(result.kept, 0);
assert_eq!(result.dropped, 0);
assert!(
vfs.resolve(Vfs::handle_for("/B/Contents/track.mp3"))
.is_some()
);
}
#[test]
fn the_reported_size_does_not_move() {
let (_original, original) = scratch("track.mp3", b"0123456789");
let (_copy, copy) = scratch("copy.mp3", b"0123456789");
let mut vfs = Vfs::new();
vfs.insert(
"/C/Contents/track.mp3",
Node::Disk {
path: original,
size: 10,
},
);
vfs.add_child("/C/Contents", "track.mp3");
let mut cache = BTreeMap::new();
cache.insert("/C/Contents/track.mp3".to_owned(), copy);
vfs.preserve("C", &cache);
assert_eq!(
vfs.resolve(Vfs::handle_for("/C/Contents/track.mp3"))
.expect("still there")
.size(),
10
);
}
}