@wasm-oj/server 0.2.0

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

@@ -0,0 +1,142 @@
+//! Used for sharing references to the same file across multiple file systems,
+//! effectively this is a symbolic link without all the complex path redirection
+
+use std::{
+    io::{self, *},
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll},
+};
+
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+use crate::VirtualFile;
+
+#[derive(Debug, Clone)]
+pub struct ArcBoxFile {
+    inner: Arc<Mutex<Box<dyn VirtualFile + Send + Sync + 'static>>>,
+}
+
+impl ArcBoxFile {
+    pub fn new(inner: Box<dyn VirtualFile + Send + Sync + 'static>) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(inner)),
+        }
+    }
+}
+
+impl AsyncSeek for ArcBoxFile {
+    fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> io::Result<()> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.start_seek(position)
+    }
+    fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_complete(cx)
+    }
+}
+
+impl AsyncWrite for ArcBoxFile {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_write(cx, buf)
+    }
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_flush(cx)
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_shutdown(cx)
+    }
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_write_vectored(cx, bufs)
+    }
+    fn is_write_vectored(&self) -> bool {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.is_write_vectored()
+    }
+}
+
+impl AsyncRead for ArcBoxFile {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_read(cx, buf)
+    }
+}
+
+impl VirtualFile for ArcBoxFile {
+    fn last_accessed(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.last_accessed()
+    }
+    fn last_modified(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.last_modified()
+    }
+    fn created_time(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.created_time()
+    }
+    fn set_times(&mut self, atime: Option<u64>, mtime: Option<u64>) -> crate::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.set_times(atime, mtime)
+    }
+    fn size(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.size()
+    }
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.set_len(new_size)
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.unlink()
+    }
+    fn is_open(&self) -> bool {
+        let inner = self.inner.lock().unwrap();
+        inner.is_open()
+    }
+    fn get_special_fd(&self) -> Option<u32> {
+        let inner = self.inner.lock().unwrap();
+        inner.get_special_fd()
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.lock().unwrap();
+        let inner = Pin::new(inner.as_mut());
+        inner.poll_read_ready(cx)
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.lock().unwrap();
+        let inner = Pin::new(inner.as_mut());
+        inner.poll_write_ready(cx)
+    }
+}
+
+impl From<Box<dyn VirtualFile + Send + Sync + 'static>> for ArcBoxFile {
+    fn from(val: Box<dyn VirtualFile + Send + Sync + 'static>) -> Self {
+        ArcBoxFile::new(val)
+    }
+}

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

@@ -0,0 +1,182 @@
+//! Used for sharing references to the same file across multiple file systems,
+//! effectively this is a symbolic link without all the complex path redirection
+
+use crate::{CloneableVirtualFile, VirtualFile};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::{
+    io::{self, *},
+    sync::{Arc, Mutex},
+};
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+#[derive(Debug)]
+pub struct ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    inner: Arc<Mutex<Box<T>>>,
+}
+
+impl<T> ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    pub fn new(inner: Box<T>) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(inner)),
+        }
+    }
+}
+
+impl<T> AsyncSeek for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> io::Result<()> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.start_seek(position)
+    }
+    fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_complete(cx)
+    }
+}
+
+impl<T> AsyncWrite for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_write(cx, buf)
+    }
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_flush(cx)
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_shutdown(cx)
+    }
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_write_vectored(cx, bufs)
+    }
+    fn is_write_vectored(&self) -> bool {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.is_write_vectored()
+    }
+}
+
+impl<T> AsyncRead for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_read(cx, buf)
+    }
+}
+
+impl<T> VirtualFile for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    fn last_accessed(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.last_accessed()
+    }
+    fn last_modified(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.last_modified()
+    }
+    fn created_time(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.created_time()
+    }
+    fn set_times(&mut self, atime: Option<u64>, mtime: Option<u64>) -> crate::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.set_times(atime, mtime)
+    }
+    fn size(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.size()
+    }
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.set_len(new_size)
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.unlink()
+    }
+    fn is_open(&self) -> bool {
+        let inner = self.inner.lock().unwrap();
+        inner.is_open()
+    }
+    fn get_special_fd(&self) -> Option<u32> {
+        let inner = self.inner.lock().unwrap();
+        inner.get_special_fd()
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.lock().unwrap();
+        let inner = Pin::new(inner.as_mut());
+        inner.poll_read_ready(cx)
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.lock().unwrap();
+        let inner = Pin::new(inner.as_mut());
+        inner.poll_write_ready(cx)
+    }
+}
+
+impl<T> Clone for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    fn clone(&self) -> Self {
+        ArcFile {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<T> CloneableVirtualFile for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+    T: Clone,
+{
+}
+
+impl<T> Default for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+    T: Default,
+{
+    fn default() -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(Box::default())),
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+//! Wraps a cloneable Arc of a file system - in practice this is useful so you
+//! can pass cloneable file systems with a `Box<dyn FileSystem>` to other
+//! interfaces
+
+use std::{path::Path, sync::Arc};
+
+use crate::*;
+
+#[derive(Debug)]
+pub struct ArcFileSystem {
+    fs: Arc<dyn FileSystem + Send + Sync + 'static>,
+}
+
+impl ArcFileSystem {
+    pub fn new(inner: Arc<dyn FileSystem + Send + Sync + 'static>) -> Self {
+        Self { fs: inner }
+    }
+
+    pub fn inner(&self) -> &Arc<dyn FileSystem + Send + Sync + 'static> {
+        &self.fs
+    }
+}
+
+impl FileSystem for ArcFileSystem {
+    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()
+    }
+}

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

@@ -0,0 +1,103 @@
+//! Used for /dev/zero - infinitely returns zero
+//! which is useful for commands like `dd if=/dev/zero of=bigfile.img size=1G`
+
+use std::io::{self, *};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+use crate::VirtualFile;
+
+#[derive(Debug, Default)]
+pub struct BufferFile {
+    pub(crate) data: Cursor<Vec<u8>>,
+}
+
+impl AsyncSeek for BufferFile {
+    fn start_seek(mut self: Pin<&mut Self>, position: io::SeekFrom) -> io::Result<()> {
+        let data = Pin::new(&mut self.data);
+        data.start_seek(position)
+    }
+
+    fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_complete(cx)
+    }
+}
+
+impl AsyncWrite for BufferFile {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_write(cx, buf)
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_write_vectored(cx, bufs)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_shutdown(cx)
+    }
+}
+
+impl AsyncRead for BufferFile {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_read(cx, buf)
+    }
+}
+
+impl VirtualFile for BufferFile {
+    fn last_accessed(&self) -> u64 {
+        1_000_000_000 // 1 second after epoch, since zero times are bad!
+    }
+    fn last_modified(&self) -> u64 {
+        1_000_000_000
+    }
+    fn created_time(&self) -> u64 {
+        1_000_000_000
+    }
+    fn size(&self) -> u64 {
+        self.data.get_ref().len() as u64
+    }
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        self.data.get_mut().resize(new_size as usize, 0);
+        Ok(())
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        Ok(())
+    }
+    fn poll_read_ready(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let cur = self.data.stream_position().unwrap_or_default();
+        let len = self.data.seek(SeekFrom::End(0)).unwrap_or_default();
+        if cur < len {
+            Poll::Ready(Ok((len - cur) as usize))
+        } else {
+            Poll::Ready(Ok(0))
+        }
+    }
+
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(8192))
+    }
+}