@wasm-oj/server 0.2.0

package/vendor/virtual-fs/src/static_fs.rs

@@ -0,0 +1,460 @@
+use anyhow::anyhow;
+use futures::future::BoxFuture;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+use std::convert::TryInto;
+use std::io::{self, Error as IoError, ErrorKind as IoErrorKind, SeekFrom};
+use std::path::Path;
+use std::path::PathBuf;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+
+use crate::mem_fs::FileSystem as MemFileSystem;
+use crate::{
+    FileOpener, FileSystem, FsError, Metadata, OpenOptions, OpenOptionsConfig, ReadDir, VirtualFile,
+};
+use indexmap::IndexMap;
+use webc::v1::{FsEntry, FsEntryType, OwnedFsEntryFile};
+
+/// Custom file system wrapper to map requested file paths
+#[derive(Debug)]
+pub struct StaticFileSystem {
+    pub package: String,
+    pub volumes: Arc<IndexMap<String, webc::v1::Volume<'static>>>,
+    pub memory: Arc<MemFileSystem>,
+}
+
+impl StaticFileSystem {
+    pub fn init(bytes: &'static [u8], package: &str) -> Option<Self> {
+        let volumes = Arc::new(webc::v1::WebC::parse_volumes_from_fileblock(bytes).ok()?);
+        let fs = Self {
+            package: package.to_string(),
+            volumes: volumes.clone(),
+            memory: Arc::new(MemFileSystem::default()),
+        };
+        let volume_names = fs.volumes.keys().cloned().collect::<Vec<_>>();
+        for volume_name in volume_names {
+            let directories = volumes.get(&volume_name).unwrap().list_directories();
+            for directory in directories {
+                let _ = fs.create_dir(Path::new(&directory));
+            }
+        }
+        Some(fs)
+    }
+}
+
+/// Custom file opener, returns a WebCFile
+impl FileOpener for StaticFileSystem {
+    fn open(
+        &self,
+        path: &Path,
+        _conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync>, FsError> {
+        match get_volume_name_opt(path) {
+            Some(volume) => {
+                let file = (*self.volumes)
+                    .get(&volume)
+                    .ok_or(FsError::EntryNotFound)?
+                    .get_file_entry(path.to_string_lossy().as_ref())
+                    .map_err(|_e| FsError::EntryNotFound)?;
+
+                Ok(Box::new(WebCFile {
+                    package: self.package.clone(),
+                    volume,
+                    volumes: self.volumes.clone(),
+                    path: path.to_path_buf(),
+                    entry: file,
+                    cursor: 0,
+                }))
+            }
+            None => {
+                for (volume, v) in self.volumes.iter() {
+                    let entry = match v.get_file_entry(path.to_string_lossy().as_ref()) {
+                        Ok(s) => s,
+                        Err(_) => continue, // error
+                    };
+
+                    return Ok(Box::new(WebCFile {
+                        package: self.package.clone(),
+                        volume: volume.clone(),
+                        volumes: self.volumes.clone(),
+                        path: path.to_path_buf(),
+                        entry,
+                        cursor: 0,
+                    }));
+                }
+                self.memory.new_open_options().open(path)
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct WebCFile {
+    pub volumes: Arc<IndexMap<String, webc::v1::Volume<'static>>>,
+    pub package: String,
+    pub volume: String,
+    pub path: PathBuf,
+    pub entry: OwnedFsEntryFile,
+    pub cursor: u64,
+}
+
+#[async_trait::async_trait]
+impl VirtualFile for WebCFile {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        self.entry.get_len()
+    }
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> Result<(), FsError> {
+        Ok(())
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let remaining = self.entry.get_len() - self.cursor;
+        Poll::Ready(Ok(remaining as usize))
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl AsyncRead for WebCFile {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let this = self.get_mut();
+        let bytes = this
+            .volumes
+            .get(&this.volume)
+            .ok_or_else(|| {
+                IoError::new(
+                    IoErrorKind::NotFound,
+                    anyhow!("Unknown volume {:?}", this.volume),
+                )
+            })?
+            .get_file_bytes(&this.entry)
+            .map_err(|e| IoError::new(IoErrorKind::NotFound, e))?;
+
+        let cursor: usize = this.cursor.try_into().unwrap_or(u32::MAX as usize);
+        let start = cursor.min(bytes.len());
+        let bytes = &bytes[start..];
+        let bytes_read = bytes.len().min(buf.remaining());
+
+        if bytes_read > 0 {
+            buf.put_slice(&bytes[..bytes_read]);
+            this.cursor = this.cursor.saturating_add(bytes_read as u64);
+        }
+        Poll::Ready(Ok(()))
+    }
+}
+
+// WebC file is not writable, the FileOpener will return a MemoryFile for writing instead
+// This code should never be executed (since writes are redirected to memory instead).
+impl AsyncWrite for WebCFile {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(buf.len()))
+    }
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncSeek for WebCFile {
+    fn start_seek(mut self: Pin<&mut Self>, pos: io::SeekFrom) -> io::Result<()> {
+        let self_size = self.size();
+        match pos {
+            SeekFrom::Start(s) => {
+                self.cursor = s.min(self_size);
+            }
+            SeekFrom::End(e) => {
+                let self_size_i64 = self_size.try_into().unwrap_or(i64::MAX);
+                self.cursor = ((self_size_i64).saturating_add(e))
+                    .min(self_size_i64)
+                    .try_into()
+                    .unwrap_or(i64::MAX as u64);
+            }
+            SeekFrom::Current(c) => {
+                self.cursor = (self
+                    .cursor
+                    .saturating_add(c.try_into().unwrap_or(i64::MAX as u64)))
+                .min(self_size);
+            }
+        }
+        Ok(())
+    }
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(self.cursor))
+    }
+}
+
+fn get_volume_name_opt<P: AsRef<Path>>(path: P) -> Option<String> {
+    use std::path::Component::Normal;
+    if let Some(Normal(n)) = path.as_ref().components().next()
+        && let Some(s) = n.to_str()
+        && s.ends_with(':')
+    {
+        return Some(s.replace(':', ""));
+    }
+    None
+}
+
+fn transform_into_read_dir(path: &Path, fs_entries: &[FsEntry<'_>]) -> crate::ReadDir {
+    let entries = fs_entries
+        .iter()
+        .map(|e| crate::DirEntry {
+            path: path.join(&*e.text),
+            metadata: Ok(crate::Metadata {
+                ft: translate_file_type(e.fs_type),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: e.get_len(),
+            }),
+        })
+        .collect();
+
+    crate::ReadDir::new(entries)
+}
+
+impl FileSystem for StaticFileSystem {
+    fn readlink(&self, path: &Path) -> crate::Result<PathBuf> {
+        let path = normalizes_path(path);
+        if self
+            .volumes
+            .values()
+            .find_map(|v| v.get_file_entry(&path).ok())
+            .is_some()
+        {
+            Err(FsError::InvalidInput)
+        } else {
+            self.memory.readlink(Path::new(&path))
+        }
+    }
+
+    fn read_dir(&self, path: &Path) -> Result<ReadDir, FsError> {
+        let path = normalizes_path(path);
+        for volume in self.volumes.values() {
+            let read_dir_result = volume
+                .read_dir(&path)
+                .map(|o| transform_into_read_dir(Path::new(&path), o.as_ref()))
+                .map_err(|_| FsError::EntryNotFound);
+
+            match read_dir_result {
+                Ok(o) => {
+                    return Ok(o);
+                }
+                Err(_) => {
+                    continue;
+                }
+            }
+        }
+
+        self.memory.read_dir(Path::new(&path))
+    }
+    fn create_dir(&self, path: &Path) -> Result<(), FsError> {
+        let path = normalizes_path(path);
+        self.memory.create_dir(Path::new(&path))
+    }
+    fn remove_dir(&self, path: &Path) -> Result<(), FsError> {
+        let path = normalizes_path(path);
+        let result = self.memory.remove_dir(Path::new(&path));
+        if self
+            .volumes
+            .values()
+            .find_map(|v| v.get_file_entry(&path).ok())
+            .is_some()
+        {
+            Ok(())
+        } else {
+            result
+        }
+    }
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<(), FsError>> {
+        Box::pin(async {
+            let from = normalizes_path(from);
+            let to = normalizes_path(to);
+            let result = self.memory.rename(Path::new(&from), Path::new(&to)).await;
+            if self
+                .volumes
+                .values()
+                .find_map(|v| v.get_file_entry(&from).ok())
+                .is_some()
+            {
+                Ok(())
+            } else {
+                result
+            }
+        })
+    }
+    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
+        let path = normalizes_path(path);
+        if let Some(fs_entry) = self
+            .volumes
+            .values()
+            .find_map(|v| v.get_file_entry(&path).ok())
+        {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::File),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: fs_entry.get_len(),
+            })
+        } else if let Some(_fs) = self.volumes.values().find_map(|v| v.read_dir(&path).ok()) {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::Dir),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: 0,
+            })
+        } else {
+            self.memory.metadata(Path::new(&path))
+        }
+    }
+    fn remove_file(&self, path: &Path) -> Result<(), FsError> {
+        let path = normalizes_path(path);
+        let result = self.memory.remove_file(Path::new(&path));
+        if self
+            .volumes
+            .values()
+            .find_map(|v| v.get_file_entry(&path).ok())
+            .is_some()
+        {
+            Ok(())
+        } else {
+            result
+        }
+    }
+    fn new_open_options(&self) -> OpenOptions<'_> {
+        OpenOptions::new(self)
+    }
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata, FsError> {
+        let path = normalizes_path(path);
+        if let Some(fs_entry) = self
+            .volumes
+            .values()
+            .find_map(|v| v.get_file_entry(&path).ok())
+        {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::File),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: fs_entry.get_len(),
+            })
+        } else if self
+            .volumes
+            .values()
+            .find_map(|v| v.read_dir(&path).ok())
+            .is_some()
+        {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::Dir),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: 0,
+            })
+        } else {
+            self.memory.symlink_metadata(Path::new(&path))
+        }
+    }
+}
+
+fn normalizes_path(path: &Path) -> String {
+    let path = format!("{}", path.display());
+    if !path.starts_with('/') {
+        format!("/{path}")
+    } else {
+        path
+    }
+}
+
+fn translate_file_type(f: FsEntryType) -> crate::FileType {
+    crate::FileType {
+        dir: f == FsEntryType::Dir,
+        file: f == FsEntryType::File,
+        symlink: false,
+        char_device: false,
+        block_device: false,
+        socket: false,
+        fifo: false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use indexmap::IndexMap;
+    use std::path::Path;
+    use tokio::io::AsyncReadExt;
+    use webc::{
+        metadata::Manifest,
+        v1::{DirOrFile, Volume, WebC},
+    };
+
+    fn fileblock_with_wasm_file() -> &'static [u8] {
+        let volume_bytes = Volume::serialize_files(
+            [(
+                DirOrFile::File(Path::new("lib/python.wasm").to_path_buf()),
+                vec![0, 97, 115, 109, 1, 0, 0, 0],
+            )]
+            .into_iter()
+            .collect(),
+        );
+
+        let mut volumes = IndexMap::new();
+        volumes.insert("atom".to_string(), Volume::parse(&volume_bytes).unwrap());
+
+        let fileblock = WebC {
+            version: 1,
+            checksum: None,
+            signature: None,
+            manifest: Manifest::default(),
+            atoms: Volume::parse(&volume_bytes).unwrap(),
+            volumes,
+        }
+        .get_volumes_as_fileblock();
+
+        Box::leak(fileblock.into_boxed_slice())
+    }
+
+    #[tokio::test]
+    async fn static_webc_reads_advance_the_cursor() {
+        let fs = StaticFileSystem::init(fileblock_with_wasm_file(), "python").unwrap();
+        let mut file = fs
+            .new_open_options()
+            .read(true)
+            .open("/lib/python.wasm")
+            .unwrap();
+
+        let mut first = [0; 4];
+        file.read_exact(&mut first).await.unwrap();
+        assert_eq!(&first, b"\0asm");
+
+        let mut second = [0; 4];
+        file.read_exact(&mut second).await.unwrap();
+        assert_eq!(second, [1, 0, 0, 0]);
+    }
+}

package/vendor/virtual-fs/src/tmp_fs.rs

@@ -0,0 +1,95 @@
+//! Wraps the memory file system implementation - this has been
+//! enhanced to support shared static files, readonly files, etc...
+
+use std::path::{Path, PathBuf};
+
+use crate::{
+    BoxFuture, FileSystem, Metadata, OpenOptions, ReadDir, Result, limiter::DynFsMemoryLimiter,
+    mem_fs,
+};
+
+#[derive(Debug, Default, Clone)]
+pub struct TmpFileSystem {
+    fs: mem_fs::FileSystem,
+}
+
+impl TmpFileSystem {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Creates a temporary filesystem with a fixed timestamp for every
+    /// implicit metadata update.
+    pub fn with_fixed_timestamp(timestamp: u64) -> Self {
+        Self {
+            fs: mem_fs::FileSystem::with_fixed_timestamp(timestamp),
+        }
+    }
+
+    pub fn set_memory_limiter(&self, limiter: DynFsMemoryLimiter) {
+        self.fs.set_memory_limiter(limiter);
+    }
+
+    pub fn new_open_options_ext(&self) -> &mem_fs::FileSystem {
+        self.fs.new_open_options_ext()
+    }
+
+    pub fn union(&self, other: &std::sync::Arc<dyn FileSystem + Send + Sync>) {
+        self.fs.union(other)
+    }
+
+    /// Canonicalize a path without validating that it actually exists.
+    pub fn canonicalize_unchecked(&self, path: &Path) -> Result<PathBuf> {
+        self.fs.canonicalize_unchecked(path)
+    }
+
+    pub fn create_symlink(&self, source: &Path, target: &Path) -> Result<()> {
+        self.fs.create_symlink(source, target)
+    }
+}
+
+impl FileSystem for TmpFileSystem {
+    fn readlink(&self, path: &Path) -> Result<PathBuf> {
+        self.fs.readlink(path)
+    }
+
+    fn read_dir(&self, path: &Path) -> Result<ReadDir> {
+        self.fs.read_dir(path)
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<()> {
+        self.fs.create_dir(path)
+    }
+
+    fn create_symlink(&self, source: &Path, target: &Path) -> Result<()> {
+        self.fs.create_symlink(source, target)
+    }
+
+    fn hard_link(&self, source: &Path, target: &Path) -> Result<()> {
+        self.fs.hard_link(source, target)
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<()> {
+        self.fs.remove_dir(path)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
+        Box::pin(async { self.fs.rename(from, to).await })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata> {
+        self.fs.metadata(path)
+    }
+
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata> {
+        self.fs.symlink_metadata(path)
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<()> {
+        self.fs.remove_file(path)
+    }
+
+    fn new_open_options(&self) -> OpenOptions<'_> {
+        self.fs.new_open_options()
+    }
+}