@wasm-oj/server 0.2.0

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

@@ -0,0 +1,113 @@
+use super::*;
+
+use crate::VirtualFile;
+
+/// Wraps a [`VirtualFile`], and also invokes a provided function for each write.
+///
+/// Useful for debugging.
+#[derive(derive_more::Debug)]
+pub struct DualWriteFile {
+    inner: Box<dyn VirtualFile + Send + Sync + 'static>,
+    #[allow(clippy::type_complexity)]
+    #[debug(ignore)]
+    extra_write: Box<dyn FnMut(&[u8]) + Send + Sync + 'static>,
+}
+
+impl DualWriteFile {
+    pub fn new(
+        inner: Box<dyn VirtualFile + Send + Sync + 'static>,
+        funct: impl FnMut(&[u8]) + Send + Sync + 'static,
+    ) -> Self {
+        Self {
+            inner,
+            extra_write: Box::new(funct),
+        }
+    }
+}
+
+impl VirtualFile for DualWriteFile {
+    fn last_accessed(&self) -> u64 {
+        self.inner.last_accessed()
+    }
+
+    fn last_modified(&self) -> u64 {
+        self.inner.last_modified()
+    }
+
+    fn created_time(&self) -> u64 {
+        self.inner.created_time()
+    }
+
+    fn set_times(&mut self, atime: Option<u64>, mtime: Option<u64>) -> crate::Result<()> {
+        self.inner.set_times(atime, mtime)
+    }
+
+    fn size(&self) -> u64 {
+        self.inner.size()
+    }
+
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        self.inner.set_len(new_size)
+    }
+
+    fn unlink(&mut self) -> Result<()> {
+        self.inner.unlink()
+    }
+
+    fn poll_read_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Pin::new(self.inner.as_mut()).poll_read_ready(cx)
+    }
+
+    fn poll_write_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Pin::new(self.inner.as_mut()).poll_write_ready(cx)
+    }
+}
+
+impl AsyncWrite for DualWriteFile {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &[u8],
+    ) -> Poll<std::io::Result<usize>> {
+        match Pin::new(&mut self.inner).poll_write(cx, buf) {
+            Poll::Ready(Ok(amt)) => {
+                if amt > 0 {
+                    (self.extra_write)(&buf[..amt]);
+                }
+                Poll::Ready(Ok(amt))
+            }
+            res => res,
+        }
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+}
+
+impl AsyncRead for DualWriteFile {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_read(cx, buf)
+    }
+}
+
+impl AsyncSeek for DualWriteFile {
+    fn start_seek(mut self: Pin<&mut Self>, position: io::SeekFrom) -> io::Result<()> {
+        Pin::new(&mut self.inner).start_seek(position)
+    }
+
+    fn poll_complete(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<io::Result<u64>> {
+        Pin::new(&mut self.inner).poll_complete(cx)
+    }
+}

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

@@ -0,0 +1,81 @@
+//! When no file system is used by a WebC then this is used as a placeholder -
+//! as the name suggests it always returns file not found.
+
+use std::path::Path;
+#[allow(unused_imports, dead_code)]
+use tracing::{debug, error, info, trace, warn};
+
+use crate::*;
+
+#[derive(Debug, Default)]
+pub struct EmptyFileSystem {}
+
+#[allow(unused_variables)]
+impl FileSystem for EmptyFileSystem {
+    fn readlink(&self, path: &Path) -> Result<PathBuf> {
+        Err(FsError::EntryNotFound)
+    }
+
+    fn read_dir(&self, path: &Path) -> Result<ReadDir> {
+        // Special-case the root path by returning an empty iterator.
+        // An empty file system should still be readable, just not contain
+        // any entries.
+        if path == Path::new("/") {
+            Ok(ReadDir::new(Vec::new()))
+        } else {
+            Err(FsError::EntryNotFound)
+        }
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<()> {
+        Err(FsError::EntryNotFound)
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<()> {
+        Err(FsError::EntryNotFound)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
+        Box::pin(async { Err(FsError::EntryNotFound) })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata> {
+        // Special-case the root path by returning an stub value.
+        // An empty file system should still be readable, just not contain
+        // any entries.
+        if path == Path::new("/") {
+            Ok(Metadata {
+                ft: FileType::new_dir(),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: 0,
+            })
+        } else {
+            Err(FsError::EntryNotFound)
+        }
+    }
+
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata> {
+        Err(FsError::EntryNotFound)
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<()> {
+        Err(FsError::EntryNotFound)
+    }
+
+    fn new_open_options(&self) -> OpenOptions<'_> {
+        OpenOptions::new(self)
+    }
+}
+
+impl FileOpener for EmptyFileSystem {
+    #[allow(unused_variables)]
+    fn open(
+        &self,
+        path: &Path,
+        conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync + 'static>> {
+        Err(FsError::EntryNotFound)
+    }
+}

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

@@ -0,0 +1,108 @@
+use crate::FileSystem;
+
+/// A chain of one or more [`FileSystem`]s.
+pub trait FileSystems<'a>: 'a {
+    // FIXME(Michael-F-Bryan): Rewrite this to use GATs when we bump the MSRV to
+    // 1.65 or higher. That'll get rid of all the lifetimes and HRTBs.
+    type Iter: IntoIterator<Item = &'a (dyn FileSystem + Send)> + Send + 'a;
+
+    /// Get something that can be used to iterate over the underlying
+    /// filesystems.
+    fn filesystems(&'a self) -> Self::Iter;
+}
+
+impl<'a, 'b, S> FileSystems<'a> for &'b S
+where
+    S: FileSystems<'a> + 'b,
+    'b: 'a,
+{
+    type Iter = S::Iter;
+
+    fn filesystems(&'a self) -> Self::Iter {
+        (**self).filesystems()
+    }
+}
+
+impl<'a, T> FileSystems<'a> for Vec<T>
+where
+    T: FileSystem + Send,
+{
+    type Iter = <[T] as FileSystems<'a>>::Iter;
+
+    fn filesystems(&'a self) -> Self::Iter {
+        self[..].filesystems()
+    }
+}
+
+impl<'a, T, const N: usize> FileSystems<'a> for [T; N]
+where
+    T: FileSystem + Send,
+{
+    type Iter = [&'a (dyn FileSystem + Send); N];
+
+    fn filesystems(&'a self) -> Self::Iter {
+        // TODO: rewrite this when array::each_ref() is stable
+        let mut i = 0;
+        [(); N].map(|_| {
+            let f = &self[i] as &(dyn FileSystem + Send);
+            i += 1;
+            f
+        })
+    }
+}
+
+impl<'a, T> FileSystems<'a> for [T]
+where
+    T: FileSystem + Send,
+{
+    type Iter = std::iter::Map<std::slice::Iter<'a, T>, fn(&T) -> &(dyn FileSystem + Send)>;
+
+    fn filesystems(&'a self) -> Self::Iter {
+        self.iter().map(|fs| fs as &(dyn FileSystem + Send))
+    }
+}
+
+impl<'a> FileSystems<'a> for () {
+    type Iter = std::iter::Empty<&'a (dyn FileSystem + Send)>;
+
+    fn filesystems(&'a self) -> Self::Iter {
+        std::iter::empty()
+    }
+}
+
+macro_rules! count {
+    ($first:tt $($rest:tt)*) => {
+        1 + count!($($rest)*)
+    };
+    () => { 0 };
+}
+
+macro_rules! tuple_filesystems {
+    ($first:ident $(, $rest:ident)* $(,)?) => {
+        impl<'a, $first, $( $rest ),*> FileSystems<'a> for ($first, $($rest),*)
+        where
+            $first: FileSystem,
+            $($rest: FileSystem),*
+        {
+            type Iter = [&'a (dyn FileSystem + Send); count!($first $($rest)*)];
+
+            fn filesystems(&'a self) -> Self::Iter {
+                #[allow(non_snake_case)]
+                let ($first, $($rest),*) = self;
+
+                [
+                    $first as &(dyn FileSystem + Send),
+                    $($rest),*
+                ]
+            }
+
+        }
+
+        tuple_filesystems!($($rest),*);
+    };
+    () => {};
+}
+
+tuple_filesystems!(
+    F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16,
+);