buf_fs/

lib.rs

#![warn(missing_docs)]
#![doc = include_str!("../README.md")]

use std::{
    ffi::OsStr,
    io::{Cursor, Read, Write},
    path::{Path, PathBuf},
};

use fatfs::FormatVolumeOptions;

mod types;

pub use types::*;

#[cfg(test)]
mod tests;

/// A buffer backed filesystem.
pub struct FileSystem<'a> {
    pub(crate) fs: fatfs::FileSystem<Cursor<&'a mut [u8]>>,
    cwd: PathBuf,
}

impl<'a> FileSystem<'a> {
    /// Mount the buffer, assuming it is formatted.
    pub fn mount(buffer: &'a mut [u8]) -> anyhow::Result<Self> {
        let buffer = Cursor::new(buffer);
        let fs = fatfs::FileSystem::new(buffer, fatfs::FsOptions::new())?;
        let cwd = PathBuf::from("/");

        Ok(FileSystem { fs, cwd })
    }

    /// Format the buffer.
    pub fn format(buffer: &mut [u8]) -> anyhow::Result<()> {
        let mut cursor = Cursor::new(buffer);

        let opts = FormatVolumeOptions::new();

        fatfs::format_volume(&mut cursor, opts)?;

        Ok(())
    }

    /// Format the buffer if there is no MBR, and then mount it.
    pub fn mount_or_format(buffer: &'a mut [u8]) -> anyhow::Result<Self> {
        if let Some(0) = buffer.get(0) {
            Self::format(buffer)?;
        }

        Self::mount(buffer)
    }

    /// Returns the current work directory.
    pub fn cwd(&self) -> &Path {
        &self.cwd
    }

    /// Navigates into the provided directory.
    pub fn cd<P: AsRef<Path>>(&mut self, dir: P) -> anyhow::Result<()> {
        let cwd = self.cwd.join(dir);
        let cwd = make_virtual_path_absolute(cwd);

        if cwd.parent().is_some() {
            let mut root = self.fs.root_dir();

            for d in cwd.into_iter().skip(1) {
                root = root.open_dir(node(d)?)?;
            }
        }

        self.cwd = cwd;

        Ok(())
    }

    /// Creates the provided path recursively from the current directory.
    pub fn mkdir<P: AsRef<Path>>(&mut self, dir: P) -> anyhow::Result<()> {
        let mut root = self.fs.root_dir();

        for d in dir.as_ref().into_iter() {
            let d = node(d)?;

            if d != "/" {
                root = match root.open_dir(d) {
                    Ok(d) => d,
                    Err(_) => root.create_dir(d)?,
                };
            }
        }

        Ok(())
    }

    /// Recursively removes the path and all its contents.
    pub fn rmdir<P: AsRef<Path>>(&mut self, dir: P) -> anyhow::Result<()> {
        self._rmdir(dir)?;

        let mut root = self.fs.root_dir();
        let mut path = PathBuf::from("/");

        for d in self.cwd.into_iter().skip(1) {
            root = match root.open_dir(node(d)?) {
                Ok(r) => r,
                Err(_) => break,
            };

            path = path.join(d);
        }

        self.cwd = make_virtual_path_absolute(path);

        Ok(())
    }

    fn _rmdir<P: AsRef<Path>>(&mut self, dir: P) -> anyhow::Result<()> {
        for c in self.ls(dir.as_ref())? {
            match c {
                DirOrFile::Dir(d) => self._rmdir(&d.path)?,
                DirOrFile::File(f) => self.rm(f.path)?,
            }
        }

        self.rm(dir)
    }

    /// Opens the file at the specified path.
    pub fn open<P: AsRef<Path>>(&mut self, path: P) -> anyhow::Result<File> {
        let path = path.as_ref();
        let name = path.file_name().ok_or_else(|| {
            anyhow::anyhow!("failed to define file name from `{}`.", path.display())
        })?;
        let name = node(name)?;
        let dir = path.parent().ok_or_else(|| {
            anyhow::anyhow!("failed to navigate to parent of `{}`.", path.display())
        })?;

        let cwd = self.cwd.clone();

        fn try_open<'a>(slf: &mut FileSystem<'a>, dir: &Path, name: &str) -> anyhow::Result<File> {
            slf.cd(dir)?;

            let mut root = slf.fs.root_dir();

            for d in slf.cwd.into_iter().skip(1) {
                root = root.open_dir(node(d)?)?;
            }

            let mut new = false;
            let contents = match root.create_file(name) {
                Ok(mut f) => {
                    let mut contents = Vec::new();

                    f.read_to_end(&mut contents)?;

                    contents
                }
                Err(_) => {
                    new = true;
                    vec![]
                }
            };

            Ok(File {
                path: dir.join(name),
                contents,
                new,
            })
        }

        let res = try_open(self, dir, name);

        self.cwd = cwd;

        res
    }

    /// Saves the file into the buffer.
    pub fn save(&mut self, file: File) -> anyhow::Result<()> {
        let name = file.path.file_name().ok_or_else(|| {
            anyhow::anyhow!("failed to define file name from `{}`.", file.path.display())
        })?;
        let name = node(name)?;
        let dir = file.path.parent().ok_or_else(|| {
            anyhow::anyhow!("failed to navigate to parent of `{}`.", file.path.display())
        })?;

        let cwd = self.cwd.clone();

        fn try_save<'a>(
            slf: &mut FileSystem<'a>,
            name: &str,
            dir: &Path,
            contents: &[u8],
        ) -> anyhow::Result<()> {
            slf.cd(dir)?;

            let mut root = slf.fs.root_dir();

            for d in slf.cwd.into_iter().skip(1) {
                root = root.open_dir(node(d)?)?;
            }

            root.create_file(name)?.write_all(contents)?;

            Ok(())
        }

        let res = try_save(self, name, dir, &file.contents);

        self.cwd = cwd;

        res
    }

    /// List the contents of a directory.
    pub fn ls<P: AsRef<Path>>(&mut self, dir: P) -> anyhow::Result<Vec<DirOrFile>> {
        let dir = self.cwd.join(dir);
        let dir = make_virtual_path_absolute(dir);
        let mut root = self.fs.root_dir();

        for d in dir.into_iter().skip(1) {
            root = root.open_dir(node(d)?)?;
        }

        let mut contents = Vec::with_capacity(20);

        for c in root.iter() {
            let entry = c?;
            let name = entry.file_name();
            let path = dir.join(&name);

            if entry.is_dir() {
                if name != "." && name != ".." {
                    contents.push(Dir::new(path).into());
                }
            } else {
                contents.push(FilePath::new(path, entry.len() as usize).into());
            }
        }

        contents.sort();

        Ok(contents)
    }

    /// Removes a file or an empty directory.
    pub fn rm<P: AsRef<Path>>(&mut self, dir: P) -> anyhow::Result<()> {
        let dir = self.cwd.join(dir);
        let mut dir = make_virtual_path_absolute(dir);

        anyhow::ensure!(
            dir.parent().is_some(),
            "directory `{}` cannot be removed.",
            dir.display()
        );

        let name = dir.file_name().ok_or_else(|| {
            anyhow::anyhow!("failed to compute the file name from `{}`", dir.display())
        })?;
        let name = node(name)?.to_string();

        dir.pop();

        let mut root = self.fs.root_dir();

        for d in dir.into_iter().skip(1) {
            root = root.open_dir(node(d)?)?;
        }

        root.remove(&name)?;

        Ok(())
    }
}

fn node(node: &OsStr) -> anyhow::Result<&str> {
    node.to_str()
        .ok_or_else(|| anyhow::anyhow!("failed to read path node"))
}

fn make_virtual_path_absolute(path: PathBuf) -> PathBuf {
    let mut absolute = PathBuf::from("/");
    let mut nodes = path.into_iter();

    if let Some(d) = nodes.next() {
        absolute = PathBuf::from("/").join(d);
    }

    for d in nodes {
        if d == "." || d == "/" {
            // nothing to do
        } else if d == ".." {
            absolute = absolute
                .parent()
                .map(Path::to_path_buf)
                .unwrap_or_else(|| PathBuf::from("/"));
        } else {
            absolute = absolute.join(d);
        }
    }

    absolute
}