wasmtime 17.0.1 → 18.0.3

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

@@ -1,325 +0,0 @@
-use crate::preview2::bindings::filesystem::types;
-use crate::preview2::{
-    spawn_blocking, AbortOnDropJoinHandle, 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;
-    }
-}
-
-pub struct File {
-    /// Wrapped in an Arc because the same underlying file is used for
-    /// implementing the stream types. Also needed for [`spawn_blocking`].
-    ///
-    /// [`spawn_blocking`]: Self::spawn_blocking
-    pub file: Arc<cap_std::fs::File>,
-    pub perms: FilePerms,
-}
-
-impl File {
-    pub fn new(file: cap_std::fs::File, perms: FilePerms) -> Self {
-        Self {
-            file: Arc::new(file),
-            perms,
-        }
-    }
-
-    /// 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,
-    {
-        let f = self.file.clone();
-        spawn_blocking(move || body(&f)).await
-    }
-}
-
-bitflags::bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    pub struct DirPerms: usize {
-        const READ = 0b1;
-        const MUTATE = 0b10;
-    }
-}
-
-#[derive(Clone)]
-pub struct Dir {
-    pub dir: Arc<cap_std::fs::Dir>,
-    pub perms: DirPerms,
-    pub file_perms: FilePerms,
-}
-
-impl Dir {
-    pub fn new(dir: cap_std::fs::Dir, perms: DirPerms, file_perms: FilePerms) -> Self {
-        Dir {
-            dir: Arc::new(dir),
-            perms,
-            file_perms,
-        }
-    }
-
-    /// 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,
-    {
-        let d = self.dir.clone();
-        spawn_blocking(move || body(&d)).await
-    }
-}
-
-pub struct FileInputStream {
-    file: Arc<cap_std::fs::File>,
-    position: u64,
-}
-impl FileInputStream {
-    pub fn new(file: Arc<cap_std::fs::File>, position: u64) -> Self {
-        Self { file, position }
-    }
-
-    pub async fn read(&mut self, size: usize) -> Result<Bytes, StreamError> {
-        use system_interface::fs::FileIoExt;
-        let f = Arc::clone(&self.file);
-        let p = self.position;
-        let (r, mut buf) = spawn_blocking(move || {
-            let mut buf = BytesMut::zeroed(size);
-            let r = f.read_at(&mut buf, p);
-            (r, buf)
-        })
-        .await;
-        let n = read_result(r)?;
-        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>) -> Result<usize, StreamError> {
-    match r {
-        Ok(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: Arc<cap_std::fs::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: Arc<cap_std::fs::File>, position: u64) -> Self {
-        Self {
-            file,
-            mode: FileOutputMode::Position(position),
-            state: OutputState::Ready,
-        }
-    }
-    pub fn append(file: Arc<cap_std::fs::File>) -> Self {
-        Self {
-            file,
-            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"
-                )));
-            }
-        }
-
-        let f = Arc::clone(&self.file);
-        let m = self.mode;
-        let task = spawn_blocking(move || 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 = 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-17.0.1/src/preview2/host/clocks.rs

@@ -1,103 +0,0 @@
-#![allow(unused_variables)]
-
-use crate::preview2::bindings::{
-    clocks::monotonic_clock::{self, Duration as WasiDuration, Instant},
-    clocks::wall_clock::{self, Datetime},
-};
-use crate::preview2::poll::{subscribe, Subscribe};
-use crate::preview2::{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_mut(), duration)
-    }
-
-    fn subscribe_duration(&mut self, duration: WasiDuration) -> anyhow::Result<Resource<Pollable>> {
-        subscribe_to_duration(&mut self.table_mut(), 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,
-        }
-    }
-}