Struct hyper_staticfile::vfs::MemoryFs

pub struct MemoryFs { /* private fields */ }

An in-memory virtual filesystem.

This type implements FileOpener, and can be directly used in Static::with_opener, for example.

Implementations

impl MemoryFs

pub async fn from_dir(path: impl AsRef<Path>) -> Result<Self, Error>

Initialize a MemoryFs from a directory.

This loads all files and their contents into memory. Symlinks are followed.

pub fn add(
    &mut self,
    path: impl Into<PathBuf>,
    data: Bytes,
    modified: Option<SystemTime>
) -> &mut Self

Add a file to the MemoryFs.

This automatically creates directory entries leading up to the path. Any existing entries are overwritten.

Examples found in repository

src/vfs.rs (line 316)

    pub async fn from_dir(path: impl AsRef<Path>) -> Result<Self, Error> {
        let mut fs = Self::default();

        // Pending directories to scan, as: `(real path, virtual path)`
        let mut dirs = vec![(path.as_ref().to_path_buf(), PathBuf::new())];
        while let Some((dir, base)) = dirs.pop() {
            let mut iter = fs::read_dir(dir).await?;
            while let Some(entry) = iter.next_entry().await? {
                let metadata = entry.metadata().await?;

                // Build the virtual path.
                let mut out_path = base.to_path_buf();
                out_path.push(entry.file_name());

                if metadata.is_dir() {
                    // Add to pending stack,
                    dirs.push((entry.path(), out_path));
                } else if metadata.is_file() {
                    // Read file contents and create an entry.
                    let data = fs::read(entry.path()).await?;
                    fs.add(out_path, data.into(), metadata.modified().ok());
                }
            }
        }

        Ok(fs)
    }

Trait Implementations

impl Default for MemoryFs

fn default() -> Self

Returns the “default value” for a type.

impl FileOpener for MemoryFs

type File = Cursor<Bytes>

File handle type.

type Future = Ready<Result<FileWithMetadata<<MemoryFs as FileOpener>::File>, Error>>

Future type that open returns.

fn open(&self, path: &Path) -> Self::Future

Open a file and return a FileWithMetadata.