RubyGems - wasmtime - Versions diffs - 16.0.0 → 17.0.0 - Mend

wasmtime 16.0.0 → 17.0.0

Files changed (1111) hide show

data/ext/cargo-vendor/wasmtime-wasi-16.0.0/src/preview2/ctx.rs DELETED Viewed

@@ -1,325 +0,0 @@
-use super::clocks::host::{monotonic_clock, wall_clock};
-use crate::preview2::{
-    clocks::{self, HostMonotonicClock, HostWallClock},
-    filesystem::Dir,
-    pipe, random, stdio,
-    stdio::{StdinStream, StdoutStream},
-    DirPerms, FilePerms, Table,
-};
-use cap_rand::{Rng, RngCore, SeedableRng};
-use cap_std::ipnet::{self, IpNet};
-use cap_std::net::Pool;
-use cap_std::{ambient_authority, AmbientAuthority};
-use std::mem;
-use std::net::{Ipv4Addr, Ipv6Addr};
-pub struct WasiCtxBuilder {
-    stdin: Box<dyn StdinStream>,
-    stdout: Box<dyn StdoutStream>,
-    stderr: Box<dyn StdoutStream>,
-    env: Vec<(String, String)>,
-    args: Vec<String>,
-    preopens: Vec<(Dir, String)>,
-    pool: Pool,
-    random: Box<dyn RngCore + Send + Sync>,
-    insecure_random: Box<dyn RngCore + Send + Sync>,
-    insecure_random_seed: u128,
-    wall_clock: Box<dyn HostWallClock + Send + Sync>,
-    monotonic_clock: Box<dyn HostMonotonicClock + Send + Sync>,
-    allow_ip_name_lookup: bool,
-    built: bool,
-}
-impl WasiCtxBuilder {
-    /// Creates a builder for a new context with default parameters set.
-    ///
-    /// The current defaults are:
-    ///
-    /// * stdin is closed
-    /// * stdout and stderr eat all input but it doesn't go anywhere
-    /// * no env vars
-    /// * no arguments
-    /// * no preopens
-    /// * clocks use the host implementation of wall/monotonic clocks
-    /// * RNGs are all initialized with random state and suitable generator
-    ///   quality to satisfy the requirements of WASI APIs.
-    ///
-    /// These defaults can all be updated via the various builder configuration
-    /// methods below.
-    ///
-    /// Note that each builder can only be used once to produce a [`WasiCtx`].
-    /// Invoking the [`build`](WasiCtxBuilder::build) method will panic on the
-    /// second attempt.
-    pub fn new() -> Self {
-        // For the insecure random API, use `SmallRng`, which is fast. It's
-        // also insecure, but that's the deal here.
-        let insecure_random = Box::new(
-            cap_rand::rngs::SmallRng::from_rng(cap_rand::thread_rng(cap_rand::ambient_authority()))
-                .unwrap(),
-        );
-        // For the insecure random seed, use a `u128` generated from
-        // `thread_rng()`, so that it's not guessable from the insecure_random
-        // API.
-        let insecure_random_seed =
-            cap_rand::thread_rng(cap_rand::ambient_authority()).gen::<u128>();
-        Self {
-            stdin: Box::new(pipe::ClosedInputStream),
-            stdout: Box::new(pipe::SinkOutputStream),
-            stderr: Box::new(pipe::SinkOutputStream),
-            env: Vec::new(),
-            args: Vec::new(),
-            preopens: Vec::new(),
-            pool: Pool::new(),
-            random: random::thread_rng(),
-            insecure_random,
-            insecure_random_seed,
-            wall_clock: wall_clock(),
-            monotonic_clock: monotonic_clock(),
-            allow_ip_name_lookup: false,
-            built: false,
-        }
-    }
-    pub fn stdin(&mut self, stdin: impl StdinStream + 'static) -> &mut Self {
-        self.stdin = Box::new(stdin);
-        self
-    }
-    pub fn stdout(&mut self, stdout: impl StdoutStream + 'static) -> &mut Self {
-        self.stdout = Box::new(stdout);
-        self
-    }
-    pub fn stderr(&mut self, stderr: impl StdoutStream + 'static) -> &mut Self {
-        self.stderr = Box::new(stderr);
-        self
-    }
-    pub fn inherit_stdin(&mut self) -> &mut Self {
-        self.stdin(stdio::stdin())
-    }
-    pub fn inherit_stdout(&mut self) -> &mut Self {
-        self.stdout(stdio::stdout())
-    }
-    pub fn inherit_stderr(&mut self) -> &mut Self {
-        self.stderr(stdio::stderr())
-    }
-    pub fn inherit_stdio(&mut self) -> &mut Self {
-        self.inherit_stdin().inherit_stdout().inherit_stderr()
-    }
-    pub fn envs(&mut self, env: &[(impl AsRef<str>, impl AsRef<str>)]) -> &mut Self {
-        self.env.extend(
-            env.iter()
-                .map(|(k, v)| (k.as_ref().to_owned(), v.as_ref().to_owned())),
-        );
-        self
-    }
-    pub fn env(&mut self, k: impl AsRef<str>, v: impl AsRef<str>) -> &mut Self {
-        self.env
-            .push((k.as_ref().to_owned(), v.as_ref().to_owned()));
-        self
-    }
-    pub fn args(&mut self, args: &[impl AsRef<str>]) -> &mut Self {
-        self.args.extend(args.iter().map(|a| a.as_ref().to_owned()));
-        self
-    }
-    pub fn arg(&mut self, arg: impl AsRef<str>) -> &mut Self {
-        self.args.push(arg.as_ref().to_owned());
-        self
-    }
-    pub fn preopened_dir(
-        &mut self,
-        dir: cap_std::fs::Dir,
-        perms: DirPerms,
-        file_perms: FilePerms,
-        path: impl AsRef<str>,
-    ) -> &mut Self {
-        self.preopens
-            .push((Dir::new(dir, perms, file_perms), path.as_ref().to_owned()));
-        self
-    }
-    /// Set the generator for the secure random number generator to the custom
-    /// generator specified.
-    ///
-    /// Note that contexts have a default RNG configured which is a suitable
-    /// generator for WASI and is configured with a random seed per-context.
-    ///
-    /// Guest code may rely on this random number generator to produce fresh
-    /// unpredictable random data in order to maintain its security invariants,
-    /// and ideally should use the insecure random API otherwise, so using any
-    /// prerecorded or otherwise predictable data may compromise security.
-    pub fn secure_random(&mut self, random: impl RngCore + Send + Sync + 'static) -> &mut Self {
-        self.random = Box::new(random);
-        self
-    }
-    pub fn insecure_random(
-        &mut self,
-        insecure_random: impl RngCore + Send + Sync + 'static,
-    ) -> &mut Self {
-        self.insecure_random = Box::new(insecure_random);
-        self
-    }
-    pub fn insecure_random_seed(&mut self, insecure_random_seed: u128) -> &mut Self {
-        self.insecure_random_seed = insecure_random_seed;
-        self
-    }
-    pub fn wall_clock(&mut self, clock: impl clocks::HostWallClock + 'static) -> &mut Self {
-        self.wall_clock = Box::new(clock);
-        self
-    }
-    pub fn monotonic_clock(
-        &mut self,
-        clock: impl clocks::HostMonotonicClock + 'static,
-    ) -> &mut Self {
-        self.monotonic_clock = Box::new(clock);
-        self
-    }
-    /// Add all network addresses accessable to the host to the pool.
-    pub fn inherit_network(&mut self, ambient_authority: AmbientAuthority) -> &mut Self {
-        self.pool.insert_ip_net_port_any(
-            IpNet::new(Ipv4Addr::UNSPECIFIED.into(), 0).unwrap(),
-            ambient_authority,
-        );
-        self.pool.insert_ip_net_port_any(
-            IpNet::new(Ipv6Addr::UNSPECIFIED.into(), 0).unwrap(),
-            ambient_authority,
-        );
-        self
-    }
-    /// Add network addresses to the pool.
-    pub fn insert_addr<A: cap_std::net::ToSocketAddrs>(
-        &mut self,
-        addrs: A,
-    ) -> std::io::Result<&mut Self> {
-        self.pool.insert(addrs, ambient_authority())?;
-        Ok(self)
-    }
-    /// Add a specific [`cap_std::net::SocketAddr`] to the pool.
-    pub fn insert_socket_addr(&mut self, addr: cap_std::net::SocketAddr) -> &mut Self {
-        self.pool.insert_socket_addr(addr, ambient_authority());
-        self
-    }
-    /// Add a range of network addresses, accepting any port, to the pool.
-    ///
-    /// Unlike `insert_ip_net`, this function grants access to any requested port.
-    pub fn insert_ip_net_port_any(&mut self, ip_net: ipnet::IpNet) -> &mut Self {
-        self.pool
-            .insert_ip_net_port_any(ip_net, ambient_authority());
-        self
-    }
-    /// Add a range of network addresses, accepting a range of ports, to
-    /// per-instance networks.
-    ///
-    /// This grants access to the port range starting at `ports_start` and, if
-    /// `ports_end` is provided, ending before `ports_end`.
-    pub fn insert_ip_net_port_range(
-        &mut self,
-        ip_net: ipnet::IpNet,
-        ports_start: u16,
-        ports_end: Option<u16>,
-    ) -> &mut Self {
-        self.pool
-            .insert_ip_net_port_range(ip_net, ports_start, ports_end, ambient_authority());
-        self
-    }
-    /// Add a range of network addresses with a specific port to the pool.
-    pub fn insert_ip_net(&mut self, ip_net: ipnet::IpNet, port: u16) -> &mut Self {
-        self.pool.insert_ip_net(ip_net, port, ambient_authority());
-        self
-    }
-    /// Allow usage of `wasi:sockets/ip-name-lookup`
-    pub fn allow_ip_name_lookup(&mut self, enable: bool) -> &mut Self {
-        self.allow_ip_name_lookup = enable;
-        self
-    }
-    /// Uses the configured context so far to construct the final `WasiCtx`.
-    ///
-    /// Note that each `WasiCtxBuilder` can only be used to "build" once, and
-    /// calling this method twice will panic.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this method is called twice.
-    pub fn build(&mut self) -> WasiCtx {
-        assert!(!self.built);
-        let Self {
-            stdin,
-            stdout,
-            stderr,
-            env,
-            args,
-            preopens,
-            pool,
-            random,
-            insecure_random,
-            insecure_random_seed,
-            wall_clock,
-            monotonic_clock,
-            allow_ip_name_lookup,
-            built: _,
-        } = mem::replace(self, Self::new());
-        self.built = true;
-        WasiCtx {
-            stdin,
-            stdout,
-            stderr,
-            env,
-            args,
-            preopens,
-            pool,
-            random,
-            insecure_random,
-            insecure_random_seed,
-            wall_clock,
-            monotonic_clock,
-            allow_ip_name_lookup,
-        }
-    }
-}
-pub trait WasiView: Send {
-    fn table(&self) -> &Table;
-    fn table_mut(&mut self) -> &mut Table;
-    fn ctx(&self) -> &WasiCtx;
-    fn ctx_mut(&mut self) -> &mut WasiCtx;
-}
-pub struct WasiCtx {
-    pub(crate) random: Box<dyn RngCore + Send + Sync>,
-    pub(crate) insecure_random: Box<dyn RngCore + Send + Sync>,
-    pub(crate) insecure_random_seed: u128,
-    pub(crate) wall_clock: Box<dyn HostWallClock + Send + Sync>,
-    pub(crate) monotonic_clock: Box<dyn HostMonotonicClock + Send + Sync>,
-    pub(crate) env: Vec<(String, String)>,
-    pub(crate) args: Vec<String>,
-    pub(crate) preopens: Vec<(Dir, String)>,
-    pub(crate) stdin: Box<dyn StdinStream>,
-    pub(crate) stdout: Box<dyn StdoutStream>,
-    pub(crate) stderr: Box<dyn StdoutStream>,
-    pub(crate) pool: Pool,
-    pub(crate) allow_ip_name_lookup: bool,
-}

data/ext/cargo-vendor/wasmtime-wasi-16.0.0/src/preview2/filesystem.rs DELETED Viewed

@@ -1,326 +0,0 @@
-use crate::preview2::bindings::filesystem::types;
-use crate::preview2::{
-    spawn_blocking, AbortOnDropJoinHandle, HostOutputStream, StreamError, Subscribe, TableError,
-    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<TableError> for FsError {
-    fn from(error: TableError) -> 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()
-    }
-}