@wasm-oj/server 0.2.0

package/vendor/shared-buffer/src/owned.rs

@@ -0,0 +1,389 @@
+use std::{
+    borrow::Cow,
+    fs::File,
+    hash::Hash,
+    ops::{Deref, Index, RangeBounds},
+    path::{Path, PathBuf},
+};
+
+use bytes::{Buf, Bytes};
+
+use crate::{mmap::MmappedSlice, MmapError};
+
+/// A cheaply cloneable owned buffer that may be backed by a memory-mapped file
+/// or [`Bytes`] in memory.
+#[derive(Debug, Clone, Default)]
+pub struct OwnedBuffer {
+    repr: Repr,
+}
+
+impl OwnedBuffer {
+    pub const fn new() -> Self {
+        OwnedBuffer {
+            repr: Repr::InMemory(Bytes::new()),
+        }
+    }
+
+    pub const fn from_static(bytes: &'static [u8]) -> Self {
+        OwnedBuffer {
+            repr: Repr::InMemory(Bytes::from_static(bytes)),
+        }
+    }
+
+    pub fn from_bytes(bytes: impl Into<Bytes>) -> Self {
+        bytes.into().into()
+    }
+
+    pub fn mmap(path: impl AsRef<Path>) -> Result<Self, MmapError> {
+        let mmap = MmappedSlice::from_path(path.as_ref())?;
+        Ok(mmap.into())
+    }
+
+    pub fn from_file(file: &File) -> Result<Self, MmapError> {
+        let mmap = MmappedSlice::from_file(file)?;
+        Ok(mmap.into())
+    }
+
+    pub fn into_bytes(self) -> Bytes {
+        match self.repr {
+            Repr::InMemory(b) => b,
+            Repr::Mmap(m) => Bytes::from(m.as_slice().to_vec()),
+        }
+    }
+
+    pub fn as_bytes(&self) -> Option<&Bytes> {
+        self.repr.as_bytes()
+    }
+
+    #[inline]
+    pub fn as_slice(&self) -> &[u8] {
+        match &self.repr {
+            Repr::InMemory(b) => b,
+            Repr::Mmap(m) => m.as_slice(),
+        }
+    }
+
+    #[inline]
+    pub fn slice(&self, range: impl RangeBounds<usize>) -> Self {
+        self.repr.slice(range).into()
+    }
+
+    pub fn is_mmapped(&self) -> bool {
+        matches!(self.repr, Repr::Mmap(_))
+    }
+}
+
+impl Deref for OwnedBuffer {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.as_slice()
+    }
+}
+
+impl AsRef<[u8]> for OwnedBuffer {
+    fn as_ref(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
+impl PartialEq for OwnedBuffer {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.as_slice() == other.as_slice()
+    }
+}
+
+impl PartialEq<[u8]> for OwnedBuffer {
+    fn eq(&self, other: &[u8]) -> bool {
+        self.as_slice() == other
+    }
+}
+
+impl PartialEq<&[u8]> for OwnedBuffer {
+    fn eq(&self, other: &&[u8]) -> bool {
+        self.as_slice() == *other
+    }
+}
+
+impl<const N: usize> PartialEq<[u8; N]> for OwnedBuffer {
+    fn eq(&self, other: &[u8; N]) -> bool {
+        self.as_slice() == other
+    }
+}
+
+impl<const N: usize> PartialEq<&[u8; N]> for OwnedBuffer {
+    fn eq(&self, other: &&[u8; N]) -> bool {
+        self.as_slice() == *other
+    }
+}
+
+impl PartialEq<Vec<u8>> for OwnedBuffer {
+    fn eq(&self, other: &Vec<u8>) -> bool {
+        self.as_slice() == other
+    }
+}
+
+impl PartialEq<&Vec<u8>> for OwnedBuffer {
+    fn eq(&self, other: &&Vec<u8>) -> bool {
+        self.as_slice() == *other
+    }
+}
+
+impl PartialEq<OwnedBuffer> for [u8] {
+    fn eq(&self, other: &OwnedBuffer) -> bool {
+        other == self
+    }
+}
+
+impl PartialEq<OwnedBuffer> for &[u8] {
+    fn eq(&self, other: &OwnedBuffer) -> bool {
+        other == self
+    }
+}
+
+impl<const N: usize> PartialEq<OwnedBuffer> for [u8; N] {
+    fn eq(&self, other: &OwnedBuffer) -> bool {
+        other == self
+    }
+}
+
+impl<const N: usize> PartialEq<OwnedBuffer> for &[u8; N] {
+    fn eq(&self, other: &OwnedBuffer) -> bool {
+        other == self
+    }
+}
+
+impl PartialEq<OwnedBuffer> for Vec<u8> {
+    fn eq(&self, other: &OwnedBuffer) -> bool {
+        other == self
+    }
+}
+
+impl PartialEq<OwnedBuffer> for &Vec<u8> {
+    fn eq(&self, other: &OwnedBuffer) -> bool {
+        other == self
+    }
+}
+
+impl<'a> IntoIterator for &'a OwnedBuffer {
+    type Item = &'a u8;
+    type IntoIter = std::slice::Iter<'a, u8>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.as_slice().iter()
+    }
+}
+
+impl IntoIterator for OwnedBuffer {
+    type Item = u8;
+    type IntoIter = OwnedIntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        OwnedIntoIter {
+            buffer: self,
+            next_index: 0,
+        }
+    }
+}
+
+impl<I> Index<I> for OwnedBuffer
+where
+    [u8]: Index<I>,
+{
+    type Output = <[u8] as Index<I>>::Output;
+
+    fn index(&self, index: I) -> &Self::Output {
+        &self.as_slice()[index]
+    }
+}
+
+impl Eq for OwnedBuffer {}
+
+impl Ord for OwnedBuffer {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.as_slice().cmp(other.as_slice())
+    }
+}
+
+impl PartialOrd for OwnedBuffer {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Hash for OwnedBuffer {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.as_slice().hash(state);
+    }
+}
+
+impl Buf for OwnedBuffer {
+    fn remaining(&self) -> usize {
+        self.len()
+    }
+
+    fn chunk(&self) -> &[u8] {
+        self.as_slice()
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        match &mut self.repr {
+            Repr::InMemory(b) => b.advance(cnt),
+            Repr::Mmap(m) => m.advance(cnt),
+        }
+    }
+}
+
+impl From<Bytes> for OwnedBuffer {
+    fn from(value: Bytes) -> Self {
+        OwnedBuffer {
+            repr: Repr::InMemory(value),
+        }
+    }
+}
+
+impl From<&[u8]> for OwnedBuffer {
+    fn from(value: &[u8]) -> Self {
+        value.to_vec().into()
+    }
+}
+
+impl From<Cow<'_, [u8]>> for OwnedBuffer {
+    fn from(value: Cow<'_, [u8]>) -> Self {
+        match value {
+            Cow::Borrowed(value) => value.into(),
+            Cow::Owned(value) => value.into(),
+        }
+    }
+}
+
+impl From<Vec<u8>> for OwnedBuffer {
+    fn from(value: Vec<u8>) -> Self {
+        Bytes::from(value).into()
+    }
+}
+
+impl From<&Vec<u8>> for OwnedBuffer {
+    fn from(value: &Vec<u8>) -> Self {
+        value.as_slice().into()
+    }
+}
+
+impl From<OwnedBuffer> for Vec<u8> {
+    fn from(value: OwnedBuffer) -> Self {
+        value.to_vec()
+    }
+}
+
+impl From<Repr> for OwnedBuffer {
+    fn from(repr: Repr) -> Self {
+        OwnedBuffer { repr }
+    }
+}
+
+impl From<MmappedSlice> for OwnedBuffer {
+    fn from(mmap: MmappedSlice) -> Self {
+        Repr::Mmap(mmap).into()
+    }
+}
+
+impl TryFrom<&Path> for OwnedBuffer {
+    type Error = MmapError;
+
+    fn try_from(value: &Path) -> Result<Self, Self::Error> {
+        OwnedBuffer::mmap(value)
+    }
+}
+
+impl TryFrom<PathBuf> for OwnedBuffer {
+    type Error = MmapError;
+
+    fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
+        OwnedBuffer::mmap(value)
+    }
+}
+
+impl TryFrom<&PathBuf> for OwnedBuffer {
+    type Error = MmapError;
+
+    fn try_from(value: &PathBuf) -> Result<Self, Self::Error> {
+        OwnedBuffer::mmap(value)
+    }
+}
+
+impl TryFrom<&std::fs::File> for OwnedBuffer {
+    type Error = MmapError;
+
+    fn try_from(file: &std::fs::File) -> Result<Self, Self::Error> {
+        OwnedBuffer::from_file(file)
+    }
+}
+
+impl TryFrom<std::fs::File> for OwnedBuffer {
+    type Error = MmapError;
+
+    fn try_from(file: std::fs::File) -> Result<Self, Self::Error> {
+        OwnedBuffer::from_file(&file)
+    }
+}
+
+impl TryFrom<OwnedBuffer> for Bytes {
+    type Error = OwnedBuffer;
+
+    fn try_from(value: OwnedBuffer) -> Result<Self, Self::Error> {
+        if let Repr::InMemory(bytes) = value.repr {
+            Ok(bytes)
+        } else {
+            Err(value)
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+enum Repr {
+    InMemory(Bytes),
+    Mmap(MmappedSlice),
+}
+
+impl Repr {
+    #[inline]
+    fn slice(&self, range: impl RangeBounds<usize>) -> Self {
+        match self {
+            Repr::InMemory(b) => Repr::InMemory(b.slice(range)),
+            Repr::Mmap(m) => Repr::Mmap(m.slice(range)),
+        }
+    }
+
+    #[inline]
+    fn as_bytes(&self) -> Option<&Bytes> {
+        match self {
+            Repr::InMemory(b) => Some(b),
+            _ => None,
+        }
+    }
+}
+
+impl Default for Repr {
+    fn default() -> Self {
+        Repr::InMemory(Bytes::new())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct OwnedIntoIter {
+    buffer: OwnedBuffer,
+    next_index: usize,
+}
+
+impl Iterator for OwnedIntoIter {
+    type Item = u8;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        let &byte = self.buffer.as_slice().get(self.next_index)?;
+        self.next_index += 1;
+        Some(byte)
+    }
+}

package/vendor/virtual-fs/Cargo.toml

@@ -0,0 +1,181 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2024"
+rust-version = "1.93"
+name = "virtual-fs"
+version = "0.702.1"
+authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Wasmer Virtual FileSystem"
+homepage = "https://wasmer.io/"
+readme = false
+license = "MIT"
+repository = "https://github.com/wasmerio/wasmer"
+resolver = "2"
+
+[package.metadata.docs.rs]
+rustc-args = [
+    "--cfg",
+    "docsrs",
+]
+
+[features]
+default = [
+    "host-fs",
+    "webc-fs",
+    "static-fs",
+]
+enable-serde = []
+futures = []
+host-fs = [
+    "libc",
+    "fs_extra",
+    "filetime",
+    "tokio/fs",
+    "tokio/io-std",
+    "tokio/rt",
+]
+js = [
+    "dep:web-time",
+    "getrandom/wasm_js",
+]
+static-fs = [
+    "webc",
+    "anyhow",
+]
+tracking = []
+webc-fs = [
+    "webc",
+    "anyhow",
+]
+
+[lib]
+name = "virtual_fs"
+path = "src/lib.rs"
+
+[dependencies.anyhow]
+version = "1.0"
+optional = true
+
+[dependencies.async-trait]
+version = "0.1.68"
+
+[dependencies.bytes]
+version = "1.11.1"
+
+[dependencies.dashmap]
+version = "6.1.0"
+
+[dependencies.derive_more]
+version = "2.0.1"
+features = [
+    "debug",
+    "display",
+]
+
+[dependencies.dunce]
+version = "1.0.4"
+
+[dependencies.filetime]
+version = "0.2.18"
+optional = true
+
+[dependencies.fs_extra]
+version = "1.3.0"
+optional = true
+
+[dependencies.futures]
+version = "0.3.30"
+
+[dependencies.getrandom]
+version = "0.4.1"
+
+[dependencies.indexmap]
+version = "2"
+
+[dependencies.libc]
+version = "0.2.178"
+optional = true
+default-features = false
+
+[dependencies.pin-project-lite]
+version = "0.2.10"
+
+[dependencies.replace_with]
+version = "0.1.7"
+
+[dependencies.serde]
+version = "1"
+features = ["derive"]
+optional = true
+default-features = false
+
+[dependencies.shared-buffer]
+version = "0.1.4"
+
+[dependencies.slab]
+version = "0.4"
+
+[dependencies.thiserror]
+version = "2.0.17"
+
+[dependencies.tokio]
+version = "1.39.0"
+features = [
+    "io-util",
+    "sync",
+    "macros",
+]
+default-features = false
+
+[dependencies.tracing]
+version = "0.1"
+default-features = true
+
+[dependencies.virtual-mio]
+version = "0.702.1"
+default-features = false
+
+[dependencies.wasmer-package]
+version = "0.702.1"
+
+[dependencies.web-time]
+version = "1.1"
+optional = true
+
+[dependencies.webc]
+version = "=12.0.0"
+features = ["v1"]
+optional = true
+
+[dev-dependencies.pretty_assertions]
+version = "1.4.0"
+
+[dev-dependencies.tempfile]
+version = "3.6.0"
+
+[dev-dependencies.tokio]
+version = "1.39.0"
+features = [
+    "io-util",
+    "rt",
+]
+default-features = false
+
+[dev-dependencies.tracing-test]
+version = "0.2"

package/vendor/virtual-fs/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2022 The Wasmer Engineering Team <engineering@wasmer.io>
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.