wasmtime 21.0.1 → 22.0.0

data/ext/cargo-vendor/wasmtime-wasi-21.0.1/src/filesystem.rs

@@ -1,446 +0,0 @@
-use crate::bindings::filesystem::types;
-use crate::runtime::{spawn_blocking, AbortOnDropJoinHandle};
-use crate::{HostOutputStream, StreamError, Subscribe, TrappableError};
-use anyhow::anyhow;
-use bytes::{Bytes, BytesMut};
-use std::io;
-use std::mem;
-use std::sync::Arc;
-
-pub type FsResult<T> = Result<T, FsError>;
-
-pub type FsError = TrappableError<types::ErrorCode>;
-
-impl From<wasmtime::component::ResourceTableError> for FsError {
-    fn from(error: wasmtime::component::ResourceTableError) -> Self {
-        Self::trap(error)
-    }
-}
-
-impl From<io::Error> for FsError {
-    fn from(error: io::Error) -> Self {
-        types::ErrorCode::from(error).into()
-    }
-}
-
-pub enum Descriptor {
-    File(File),
-    Dir(Dir),
-}
-
-impl Descriptor {
-    pub fn file(&self) -> Result<&File, types::ErrorCode> {
-        match self {
-            Descriptor::File(f) => Ok(f),
-            Descriptor::Dir(_) => Err(types::ErrorCode::BadDescriptor),
-        }
-    }
-
-    pub fn dir(&self) -> Result<&Dir, types::ErrorCode> {
-        match self {
-            Descriptor::Dir(d) => Ok(d),
-            Descriptor::File(_) => Err(types::ErrorCode::NotDirectory),
-        }
-    }
-
-    pub fn is_file(&self) -> bool {
-        match self {
-            Descriptor::File(_) => true,
-            Descriptor::Dir(_) => false,
-        }
-    }
-
-    pub fn is_dir(&self) -> bool {
-        match self {
-            Descriptor::File(_) => false,
-            Descriptor::Dir(_) => true,
-        }
-    }
-}
-
-bitflags::bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    pub struct FilePerms: usize {
-        const READ = 0b1;
-        const WRITE = 0b10;
-    }
-}
-
-bitflags::bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    pub struct OpenMode: usize {
-        const READ = 0b1;
-        const WRITE = 0b10;
-    }
-}
-
-#[derive(Clone)]
-pub struct File {
-    /// The operating system File this struct is mediating access to.
-    ///
-    /// Wrapped in an Arc because the same underlying file is used for
-    /// implementing the stream types. A copy is also needed for
-    /// [`spawn_blocking`].
-    ///
-    /// [`spawn_blocking`]: Self::spawn_blocking
-    pub file: Arc<cap_std::fs::File>,
-    /// Permissions to enforce on access to the file. These permissions are
-    /// specified by a user of the `crate::WasiCtxBuilder`, and are
-    /// enforced prior to any enforced by the underlying operating system.
-    pub perms: FilePerms,
-    /// The mode the file was opened under: bits for reading, and writing.
-    /// Required to correctly report the DescriptorFlags, because cap-std
-    /// doesn't presently provide a cross-platform equivelant of reading the
-    /// oflags back out using fcntl.
-    pub open_mode: OpenMode,
-
-    allow_blocking_current_thread: bool,
-}
-
-impl File {
-    pub fn new(
-        file: cap_std::fs::File,
-        perms: FilePerms,
-        open_mode: OpenMode,
-        allow_blocking_current_thread: bool,
-    ) -> Self {
-        Self {
-            file: Arc::new(file),
-            perms,
-            open_mode,
-            allow_blocking_current_thread,
-        }
-    }
-
-    /// Spawn a task on tokio's blocking thread for performing blocking
-    /// syscalls on the underlying [`cap_std::fs::File`].
-    pub(crate) async fn spawn_blocking<F, R>(&self, body: F) -> R
-    where
-        F: FnOnce(&cap_std::fs::File) -> R + Send + 'static,
-        R: Send + 'static,
-    {
-        match self._spawn_blocking(body) {
-            SpawnBlocking::Done(result) => result,
-            SpawnBlocking::Spawned(task) => task.await,
-        }
-    }
-
-    /// Returns `Some` when the current thread is allowed to block in filesystem
-    /// operations, and otherwise returns `None` to indicate that
-    /// `spawn_blocking` must be used.
-    pub(crate) fn as_blocking_file(&self) -> Option<&cap_std::fs::File> {
-        if self.allow_blocking_current_thread {
-            Some(&self.file)
-        } else {
-            None
-        }
-    }
-
-    fn _spawn_blocking<F, R>(&self, body: F) -> SpawnBlocking<R>
-    where
-        F: FnOnce(&cap_std::fs::File) -> R + Send + 'static,
-        R: Send + 'static,
-    {
-        match self.as_blocking_file() {
-            Some(file) => SpawnBlocking::Done(body(file)),
-            None => {
-                let f = self.file.clone();
-                SpawnBlocking::Spawned(spawn_blocking(move || body(&f)))
-            }
-        }
-    }
-}
-
-enum SpawnBlocking<T> {
-    Done(T),
-    Spawned(AbortOnDropJoinHandle<T>),
-}
-
-bitflags::bitflags! {
-    /// Permission bits for operating on a directory.
-    ///
-    /// Directories can be limited to being readonly. This will restrict what
-    /// can be done with them, for example preventing creation of new files.
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    pub struct DirPerms: usize {
-        /// This directory can be read, for example its entries can be iterated
-        /// over and files can be opened.
-        const READ = 0b1;
-
-        /// This directory can be mutated, for example by creating new files
-        /// within it.
-        const MUTATE = 0b10;
-    }
-}
-
-#[derive(Clone)]
-pub struct Dir {
-    /// The operating system file descriptor this struct is mediating access
-    /// to.
-    ///
-    /// Wrapped in an Arc because a copy is needed for [`spawn_blocking`].
-    ///
-    /// [`spawn_blocking`]: Self::spawn_blocking
-    pub dir: Arc<cap_std::fs::Dir>,
-    /// Permissions to enforce on access to this directory. These permissions
-    /// are specified by a user of the `crate::WasiCtxBuilder`, and
-    /// are enforced prior to any enforced by the underlying operating system.
-    ///
-    /// These permissions are also enforced on any directories opened under
-    /// this directory.
-    pub perms: DirPerms,
-    /// Permissions to enforce on any files opened under this directory.
-    pub file_perms: FilePerms,
-    /// The mode the directory was opened under: bits for reading, and writing.
-    /// Required to correctly report the DescriptorFlags, because cap-std
-    /// doesn't presently provide a cross-platform equivelant of reading the
-    /// oflags back out using fcntl.
-    pub open_mode: OpenMode,
-
-    allow_blocking_current_thread: bool,
-}
-
-impl Dir {
-    pub fn new(
-        dir: cap_std::fs::Dir,
-        perms: DirPerms,
-        file_perms: FilePerms,
-        open_mode: OpenMode,
-        allow_blocking_current_thread: bool,
-    ) -> Self {
-        Dir {
-            dir: Arc::new(dir),
-            perms,
-            file_perms,
-            open_mode,
-            allow_blocking_current_thread,
-        }
-    }
-
-    /// Spawn a task on tokio's blocking thread for performing blocking
-    /// syscalls on the underlying [`cap_std::fs::Dir`].
-    pub(crate) async fn spawn_blocking<F, R>(&self, body: F) -> R
-    where
-        F: FnOnce(&cap_std::fs::Dir) -> R + Send + 'static,
-        R: Send + 'static,
-    {
-        if self.allow_blocking_current_thread {
-            body(&self.dir)
-        } else {
-            let d = self.dir.clone();
-            spawn_blocking(move || body(&d)).await
-        }
-    }
-}
-
-pub struct FileInputStream {
-    file: File,
-    position: u64,
-}
-impl FileInputStream {
-    pub fn new(file: &File, position: u64) -> Self {
-        Self {
-            file: file.clone(),
-            position,
-        }
-    }
-
-    pub async fn read(&mut self, size: usize) -> Result<Bytes, StreamError> {
-        use system_interface::fs::FileIoExt;
-        let p = self.position;
-
-        let (r, mut buf) = self
-            .file
-            .spawn_blocking(move |f| {
-                let mut buf = BytesMut::zeroed(size);
-                let r = f.read_at(&mut buf, p);
-                (r, buf)
-            })
-            .await;
-        let n = read_result(r, size)?;
-        buf.truncate(n);
-        self.position += n as u64;
-        Ok(buf.freeze())
-    }
-
-    pub async fn skip(&mut self, nelem: usize) -> Result<usize, StreamError> {
-        let bs = self.read(nelem).await?;
-        Ok(bs.len())
-    }
-}
-
-fn read_result(r: io::Result<usize>, size: usize) -> Result<usize, StreamError> {
-    match r {
-        Ok(0) if size > 0 => Err(StreamError::Closed),
-        Ok(n) => Ok(n),
-        Err(e) if e.kind() == std::io::ErrorKind::Interrupted => Ok(0),
-        Err(e) => Err(StreamError::LastOperationFailed(e.into())),
-    }
-}
-
-#[derive(Clone, Copy)]
-pub(crate) enum FileOutputMode {
-    Position(u64),
-    Append,
-}
-
-pub(crate) struct FileOutputStream {
-    file: File,
-    mode: FileOutputMode,
-    state: OutputState,
-}
-
-enum OutputState {
-    Ready,
-    /// Allows join future to be awaited in a cancellable manner. Gone variant indicates
-    /// no task is currently outstanding.
-    Waiting(AbortOnDropJoinHandle<io::Result<usize>>),
-    /// The last I/O operation failed with this error.
-    Error(io::Error),
-    Closed,
-}
-
-impl FileOutputStream {
-    pub fn write_at(file: &File, position: u64) -> Self {
-        Self {
-            file: file.clone(),
-            mode: FileOutputMode::Position(position),
-            state: OutputState::Ready,
-        }
-    }
-
-    pub fn append(file: &File) -> Self {
-        Self {
-            file: file.clone(),
-            mode: FileOutputMode::Append,
-            state: OutputState::Ready,
-        }
-    }
-}
-
-// FIXME: configurable? determine from how much space left in file?
-const FILE_WRITE_CAPACITY: usize = 1024 * 1024;
-
-impl HostOutputStream for FileOutputStream {
-    fn write(&mut self, buf: Bytes) -> Result<(), StreamError> {
-        use system_interface::fs::FileIoExt;
-        match self.state {
-            OutputState::Ready => {}
-            OutputState::Closed => return Err(StreamError::Closed),
-            OutputState::Waiting(_) | OutputState::Error(_) => {
-                // a write is pending - this call was not permitted
-                return Err(StreamError::Trap(anyhow!(
-                    "write not permitted: check_write not called first"
-                )));
-            }
-        }
-
-        if buf.is_empty() {
-            return Ok(());
-        }
-
-        let m = self.mode;
-        let result = self.file._spawn_blocking(move |f| {
-            match m {
-                FileOutputMode::Position(mut p) => {
-                    let mut total = 0;
-                    let mut buf = buf;
-                    while !buf.is_empty() {
-                        let nwritten = f.write_at(buf.as_ref(), p)?;
-                        // afterwards buf contains [nwritten, len):
-                        let _ = buf.split_to(nwritten);
-                        p += nwritten as u64;
-                        total += nwritten;
-                    }
-                    Ok(total)
-                }
-                FileOutputMode::Append => {
-                    let mut total = 0;
-                    let mut buf = buf;
-                    while !buf.is_empty() {
-                        let nwritten = f.append(buf.as_ref())?;
-                        let _ = buf.split_to(nwritten);
-                        total += nwritten;
-                    }
-                    Ok(total)
-                }
-            }
-        });
-        self.state = match result {
-            SpawnBlocking::Done(Ok(nwritten)) => {
-                if let FileOutputMode::Position(ref mut p) = &mut self.mode {
-                    *p += nwritten as u64;
-                }
-                OutputState::Ready
-            }
-            SpawnBlocking::Done(Err(e)) => OutputState::Error(e),
-            SpawnBlocking::Spawned(task) => OutputState::Waiting(task),
-        };
-        Ok(())
-    }
-    fn flush(&mut self) -> Result<(), StreamError> {
-        match self.state {
-            // Only userland buffering of file writes is in the blocking task,
-            // so there's nothing extra that needs to be done to request a
-            // flush.
-            OutputState::Ready | OutputState::Waiting(_) => Ok(()),
-            OutputState::Closed => Err(StreamError::Closed),
-            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
-                OutputState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
-                _ => unreachable!(),
-            },
-        }
-    }
-    fn check_write(&mut self) -> Result<usize, StreamError> {
-        match self.state {
-            OutputState::Ready => Ok(FILE_WRITE_CAPACITY),
-            OutputState::Closed => Err(StreamError::Closed),
-            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
-                OutputState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
-                _ => unreachable!(),
-            },
-            OutputState::Waiting(_) => Ok(0),
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl Subscribe for FileOutputStream {
-    async fn ready(&mut self) {
-        if let OutputState::Waiting(task) = &mut self.state {
-            self.state = match task.await {
-                Ok(nwritten) => {
-                    if let FileOutputMode::Position(ref mut p) = &mut self.mode {
-                        *p += nwritten as u64;
-                    }
-                    OutputState::Ready
-                }
-                Err(e) => OutputState::Error(e),
-            };
-        }
-    }
-}
-
-pub struct ReaddirIterator(
-    std::sync::Mutex<Box<dyn Iterator<Item = FsResult<types::DirectoryEntry>> + Send + 'static>>,
-);
-
-impl ReaddirIterator {
-    pub(crate) fn new(
-        i: impl Iterator<Item = FsResult<types::DirectoryEntry>> + Send + 'static,
-    ) -> Self {
-        ReaddirIterator(std::sync::Mutex::new(Box::new(i)))
-    }
-    pub(crate) fn next(&self) -> FsResult<Option<types::DirectoryEntry>> {
-        self.0.lock().unwrap().next().transpose()
-    }
-}
-
-impl IntoIterator for ReaddirIterator {
-    type Item = FsResult<types::DirectoryEntry>;
-    type IntoIter = Box<dyn Iterator<Item = Self::Item> + Send>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.into_inner().unwrap()
-    }
-}

data/ext/cargo-vendor/wasmtime-wasi-21.0.1/src/host/clocks.rs

@@ -1,103 +0,0 @@
-#![allow(unused_variables)]
-
-use crate::bindings::{
-    clocks::monotonic_clock::{self, Duration as WasiDuration, Instant},
-    clocks::wall_clock::{self, Datetime},
-};
-use crate::poll::{subscribe, Subscribe};
-use crate::{Pollable, WasiView};
-use cap_std::time::SystemTime;
-use std::time::Duration;
-use wasmtime::component::Resource;
-
-impl TryFrom<SystemTime> for Datetime {
-    type Error = anyhow::Error;
-
-    fn try_from(time: SystemTime) -> Result<Self, Self::Error> {
-        let duration =
-            time.duration_since(SystemTime::from_std(std::time::SystemTime::UNIX_EPOCH))?;
-
-        Ok(Datetime {
-            seconds: duration.as_secs(),
-            nanoseconds: duration.subsec_nanos(),
-        })
-    }
-}
-
-impl<T: WasiView> wall_clock::Host for T {
-    fn now(&mut self) -> anyhow::Result<Datetime> {
-        let now = self.ctx().wall_clock.now();
-        Ok(Datetime {
-            seconds: now.as_secs(),
-            nanoseconds: now.subsec_nanos(),
-        })
-    }
-
-    fn resolution(&mut self) -> anyhow::Result<Datetime> {
-        let res = self.ctx().wall_clock.resolution();
-        Ok(Datetime {
-            seconds: res.as_secs(),
-            nanoseconds: res.subsec_nanos(),
-        })
-    }
-}
-
-fn subscribe_to_duration(
-    table: &mut wasmtime::component::ResourceTable,
-    duration: tokio::time::Duration,
-) -> anyhow::Result<Resource<Pollable>> {
-    let sleep = if duration.is_zero() {
-        table.push(Deadline::Past)?
-    } else if let Some(deadline) = tokio::time::Instant::now().checked_add(duration) {
-        // NB: this resource created here is not actually exposed to wasm, it's
-        // only an internal implementation detail used to match the signature
-        // expected by `subscribe`.
-        table.push(Deadline::Instant(deadline))?
-    } else {
-        // If the user specifies a time so far in the future we can't
-        // represent it, wait forever rather than trap.
-        table.push(Deadline::Never)?
-    };
-    subscribe(table, sleep)
-}
-
-impl<T: WasiView> monotonic_clock::Host for T {
-    fn now(&mut self) -> anyhow::Result<Instant> {
-        Ok(self.ctx().monotonic_clock.now())
-    }
-
-    fn resolution(&mut self) -> anyhow::Result<Instant> {
-        Ok(self.ctx().monotonic_clock.resolution())
-    }
-
-    fn subscribe_instant(&mut self, when: Instant) -> anyhow::Result<Resource<Pollable>> {
-        let clock_now = self.ctx().monotonic_clock.now();
-        let duration = if when > clock_now {
-            Duration::from_nanos(when - clock_now)
-        } else {
-            Duration::from_nanos(0)
-        };
-        subscribe_to_duration(&mut self.table(), duration)
-    }
-
-    fn subscribe_duration(&mut self, duration: WasiDuration) -> anyhow::Result<Resource<Pollable>> {
-        subscribe_to_duration(&mut self.table(), Duration::from_nanos(duration))
-    }
-}
-
-enum Deadline {
-    Past,
-    Instant(tokio::time::Instant),
-    Never,
-}
-
-#[async_trait::async_trait]
-impl Subscribe for Deadline {
-    async fn ready(&mut self) {
-        match self {
-            Deadline::Past => {}
-            Deadline::Instant(instant) => tokio::time::sleep_until(*instant).await,
-            Deadline::Never => std::future::pending().await,
-        }
-    }
-}

data/ext/cargo-vendor/wasmtime-wasi-21.0.1/src/host/env.rs

@@ -1,15 +0,0 @@
-use crate::bindings::cli::environment;
-use crate::WasiView;
-
-impl<T: WasiView> environment::Host for T {
-    fn get_environment(&mut self) -> anyhow::Result<Vec<(String, String)>> {
-        Ok(self.ctx().env.clone())
-    }
-    fn get_arguments(&mut self) -> anyhow::Result<Vec<String>> {
-        Ok(self.ctx().args.clone())
-    }
-    fn initial_cwd(&mut self) -> anyhow::Result<Option<String>> {
-        // FIXME: expose cwd in builder and save in ctx
-        Ok(None)
-    }
-}

data/ext/cargo-vendor/wasmtime-wasi-21.0.1/src/host/exit.rs

@@ -1,11 +0,0 @@
-use crate::{bindings::cli::exit, I32Exit, WasiView};
-
-impl<T: WasiView> exit::Host for T {
-    fn exit(&mut self, status: Result<(), ()>) -> anyhow::Result<()> {
-        let status = match status {
-            Ok(()) => 0,
-            Err(()) => 1,
-        };
-        Err(anyhow::anyhow!(I32Exit(status)))
-    }
-}