wasmtime 16.0.0 → 17.0.0

data/ext/cargo-vendor/wasmtime-wasi-17.0.0/src/preview2/mod.rs

@@ -0,0 +1,327 @@
+//! # Wasmtime's WASI Preview 2 Implementation
+//!
+//! Welcome to the (new!) WASI implementation from the Wasmtime team. The goal
+//! of this implementation is to support WASI Preview 2 via the Component
+//! Model, as well as to provide legacy Preview 1 host support with an adapter
+//! that is implemented in terms of the Preview 2 interfaces.
+//!
+//! Presently, this crate is experimental. We don't yet recommend you use it
+//! in production. Specifically:
+//! * the wit files in tree describing preview 2 are not faithful to the
+//! standards repos
+//!
+//! Once these issues are resolved, we expect to move this namespace up to the
+//! root of the wasmtime-wasi crate, and move its other exports underneath a
+//! `pub mod legacy` with an off-by-default feature flag, and after 2
+//! releases, retire and remove that code from our tree.
+
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+mod clocks;
+pub mod command;
+mod ctx;
+mod error;
+mod filesystem;
+mod host;
+mod ip_name_lookup;
+mod network;
+pub mod pipe;
+mod poll;
+#[cfg(feature = "preview1-on-preview2")]
+pub mod preview0;
+#[cfg(feature = "preview1-on-preview2")]
+pub mod preview1;
+mod random;
+mod stdio;
+mod stream;
+mod tcp;
+mod udp;
+mod write_stream;
+
+pub use self::clocks::{HostMonotonicClock, HostWallClock};
+pub use self::ctx::{WasiCtx, WasiCtxBuilder, WasiView};
+pub use self::error::{I32Exit, TrappableError};
+pub use self::filesystem::{DirPerms, FilePerms, FsError, FsResult};
+pub use self::network::{Network, SocketError, SocketResult};
+pub use self::poll::{subscribe, ClosureFuture, MakeFuture, Pollable, PollableFuture, Subscribe};
+pub use self::random::{thread_rng, Deterministic};
+pub use self::stdio::{
+    stderr, stdin, stdout, IsATTY, Stderr, Stdin, StdinStream, Stdout, StdoutStream,
+};
+pub use self::stream::{
+    HostInputStream, HostOutputStream, InputStream, OutputStream, StreamError, StreamResult,
+};
+pub use cap_fs_ext::SystemTimeSpec;
+pub use cap_rand::RngCore;
+pub use wasmtime::component::{ResourceTable, ResourceTableError};
+
+pub mod bindings {
+    // Generate traits for synchronous bindings.
+    //
+    // Note that this is only done for interfaces which can block, or those which
+    // have some functions in `only_imports` below for being async.
+    pub mod sync_io {
+        pub(crate) mod _internal {
+            use crate::preview2::{FsError, StreamError};
+
+            wasmtime::component::bindgen!({
+                path: "wit",
+                interfaces: "
+                    import wasi:io/poll@0.2.0;
+                    import wasi:io/streams@0.2.0;
+                    import wasi:filesystem/types@0.2.0;
+                ",
+                tracing: true,
+                trappable_error_type: {
+                    "wasi:io/streams/stream-error" => StreamError,
+                    "wasi:filesystem/types/error-code" => FsError,
+                },
+                with: {
+                    "wasi:clocks/wall-clock": crate::preview2::bindings::clocks::wall_clock,
+                    "wasi:filesystem/types/descriptor": super::super::filesystem::types::Descriptor,
+                    "wasi:filesystem/types/directory-entry-stream": super::super::filesystem::types::DirectoryEntryStream,
+                    "wasi:io/poll/pollable": super::super::io::poll::Pollable,
+                    "wasi:io/streams/input-stream": super::super::io::streams::InputStream,
+                    "wasi:io/streams/output-stream": super::super::io::streams::OutputStream,
+                    "wasi:io/error/error": super::super::io::error::Error,
+                }
+            });
+        }
+        pub use self::_internal::wasi::{filesystem, io};
+    }
+
+    wasmtime::component::bindgen!({
+        path: "wit",
+        world: "wasi:cli/imports",
+        tracing: true,
+        async: {
+            // Only these functions are `async` and everything else is sync
+            // meaning that it basically doesn't need to block. These functions
+            // are the only ones that need to block.
+            //
+            // Note that at this time `only_imports` works on function names
+            // which in theory can be shared across interfaces, so this may
+            // need fancier syntax in the future.
+            only_imports: [
+                "[method]descriptor.access-at",
+                "[method]descriptor.advise",
+                "[method]descriptor.change-directory-permissions-at",
+                "[method]descriptor.change-file-permissions-at",
+                "[method]descriptor.create-directory-at",
+                "[method]descriptor.get-flags",
+                "[method]descriptor.get-type",
+                "[method]descriptor.is-same-object",
+                "[method]descriptor.link-at",
+                "[method]descriptor.lock-exclusive",
+                "[method]descriptor.lock-shared",
+                "[method]descriptor.metadata-hash",
+                "[method]descriptor.metadata-hash-at",
+                "[method]descriptor.open-at",
+                "[method]descriptor.read",
+                "[method]descriptor.read-directory",
+                "[method]descriptor.readlink-at",
+                "[method]descriptor.remove-directory-at",
+                "[method]descriptor.rename-at",
+                "[method]descriptor.set-size",
+                "[method]descriptor.set-times",
+                "[method]descriptor.set-times-at",
+                "[method]descriptor.stat",
+                "[method]descriptor.stat-at",
+                "[method]descriptor.symlink-at",
+                "[method]descriptor.sync",
+                "[method]descriptor.sync-data",
+                "[method]descriptor.try-lock-exclusive",
+                "[method]descriptor.try-lock-shared",
+                "[method]descriptor.unlink-file-at",
+                "[method]descriptor.unlock",
+                "[method]descriptor.write",
+                "[method]input-stream.read",
+                "[method]input-stream.blocking-read",
+                "[method]input-stream.blocking-skip",
+                "[method]input-stream.skip",
+                "[method]output-stream.forward",
+                "[method]output-stream.splice",
+                "[method]output-stream.blocking-splice",
+                "[method]output-stream.blocking-flush",
+                "[method]output-stream.blocking-write",
+                "[method]output-stream.blocking-write-and-flush",
+                "[method]output-stream.blocking-write-zeroes-and-flush",
+                "[method]directory-entry-stream.read-directory-entry",
+                "poll",
+                "[method]pollable.block",
+                "[method]pollable.ready",
+            ],
+        },
+        trappable_error_type: {
+            "wasi:io/streams/stream-error" => crate::preview2::StreamError,
+            "wasi:filesystem/types/error-code" => crate::preview2::FsError,
+            "wasi:sockets/network/error-code" => crate::preview2::SocketError,
+        },
+        with: {
+            "wasi:sockets/network/network": super::network::Network,
+            "wasi:sockets/tcp/tcp-socket": super::tcp::TcpSocket,
+            "wasi:sockets/udp/udp-socket": super::udp::UdpSocket,
+            "wasi:sockets/udp/incoming-datagram-stream": super::udp::IncomingDatagramStream,
+            "wasi:sockets/udp/outgoing-datagram-stream": super::udp::OutgoingDatagramStream,
+            "wasi:sockets/ip-name-lookup/resolve-address-stream": super::ip_name_lookup::ResolveAddressStream,
+            "wasi:filesystem/types/directory-entry-stream": super::filesystem::ReaddirIterator,
+            "wasi:filesystem/types/descriptor": super::filesystem::Descriptor,
+            "wasi:io/streams/input-stream": super::stream::InputStream,
+            "wasi:io/streams/output-stream": super::stream::OutputStream,
+            "wasi:io/error/error": super::stream::Error,
+            "wasi:io/poll/pollable": super::poll::Pollable,
+            "wasi:cli/terminal-input/terminal-input": super::stdio::TerminalInput,
+            "wasi:cli/terminal-output/terminal-output": super::stdio::TerminalOutput,
+        },
+    });
+
+    pub use wasi::*;
+}
+
+pub(crate) static RUNTIME: once_cell::sync::Lazy<tokio::runtime::Runtime> =
+    once_cell::sync::Lazy::new(|| {
+        tokio::runtime::Builder::new_current_thread()
+            .enable_time()
+            .enable_io()
+            .build()
+            .unwrap()
+    });
+
+pub struct AbortOnDropJoinHandle<T>(tokio::task::JoinHandle<T>);
+impl<T> Drop for AbortOnDropJoinHandle<T> {
+    fn drop(&mut self) {
+        self.0.abort()
+    }
+}
+impl<T> std::ops::Deref for AbortOnDropJoinHandle<T> {
+    type Target = tokio::task::JoinHandle<T>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl<T> std::ops::DerefMut for AbortOnDropJoinHandle<T> {
+    fn deref_mut(&mut self) -> &mut tokio::task::JoinHandle<T> {
+        &mut self.0
+    }
+}
+impl<T> From<tokio::task::JoinHandle<T>> for AbortOnDropJoinHandle<T> {
+    fn from(jh: tokio::task::JoinHandle<T>) -> Self {
+        AbortOnDropJoinHandle(jh)
+    }
+}
+impl<T> Future for AbortOnDropJoinHandle<T> {
+    type Output = T;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match Pin::new(&mut self.as_mut().0).poll(cx) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(r) => Poll::Ready(r.expect("child task panicked")),
+        }
+    }
+}
+
+pub fn spawn<F>(f: F) -> AbortOnDropJoinHandle<F::Output>
+where
+    F: Future + Send + 'static,
+    F::Output: Send + 'static,
+{
+    let j = with_ambient_tokio_runtime(|| tokio::task::spawn(f));
+    AbortOnDropJoinHandle(j)
+}
+
+pub fn spawn_blocking<F, R>(f: F) -> AbortOnDropJoinHandle<R>
+where
+    F: FnOnce() -> R + Send + 'static,
+    R: Send + 'static,
+{
+    let j = with_ambient_tokio_runtime(|| tokio::task::spawn_blocking(f));
+    AbortOnDropJoinHandle(j)
+}
+
+pub fn in_tokio<F: Future>(f: F) -> F::Output {
+    match tokio::runtime::Handle::try_current() {
+        Ok(h) => {
+            let _enter = h.enter();
+            h.block_on(f)
+        }
+        // The `yield_now` here is non-obvious and if you're reading this
+        // you're likely curious about why it's here. This is currently required
+        // to get some features of "sync mode" working correctly, such as with
+        // the CLI. To illustrate why this is required, consider a program
+        // organized as:
+        //
+        // * A program has a `pollable` that it's waiting on.
+        // * This `pollable` is always ready .
+        // * Actually making the corresponding operation ready, however,
+        //   requires some background work on Tokio's part.
+        // * The program is looping on "wait for readiness" coupled with
+        //   performing the operation.
+        //
+        // In this situation this program ends up infinitely looping in waiting
+        // for pollables. The reason appears to be that when we enter the tokio
+        // runtime here it doesn't necessary yield to background work because
+        // the provided future `f` is ready immediately. The future `f` will run
+        // through the list of pollables and determine one of them is ready.
+        //
+        // Historically this happened with UDP sockets. A test send a datagram
+        // from one socket to another and the other socket infinitely didn't
+        // receive the data. This appeared to be because the server socket was
+        // waiting on `READABLE | WRITABLE` (which is itself a bug but ignore
+        // that) and the socket was currently in the "writable" state but never
+        // ended up receiving a notification for the "readable" state. Moving
+        // the socket to "readable" would require Tokio to perform some
+        // background work via epoll/kqueue/handle events but if the future
+        // provided here is always ready, then that never happened.
+        //
+        // Thus the `yield_now()` is an attempt to force Tokio to go do some
+        // background work eventually and look at new interest masks for
+        // example. This is a bit of a kludge but everything's already a bit
+        // wonky in synchronous mode anyway. Note that this is hypothesized to
+        // not be an issue in async mode because async mode typically has the
+        // Tokio runtime in a separate thread or otherwise participating in a
+        // larger application, it's only here in synchronous mode where we
+        // effectively own the runtime that we need some special care.
+        Err(_) => {
+            let _enter = RUNTIME.enter();
+            RUNTIME.block_on(async move {
+                tokio::task::yield_now().await;
+                f.await
+            })
+        }
+    }
+}
+
+/// Executes the closure `f` with an "ambient Tokio runtime" which basically
+/// means that if code in `f` tries to get a runtime `Handle` it'll succeed.
+///
+/// If a `Handle` is already available, e.g. in async contexts, then `f` is run
+/// immediately. Otherwise for synchronous contexts this crate's fallback
+/// runtime is configured and then `f` is executed.
+pub fn with_ambient_tokio_runtime<R>(f: impl FnOnce() -> R) -> R {
+    match tokio::runtime::Handle::try_current() {
+        Ok(_) => f(),
+        Err(_) => {
+            let _enter = RUNTIME.enter();
+            f()
+        }
+    }
+}
+
+/// Attempts to get the result of a `future`.
+///
+/// This function does not block and will poll the provided future once. If the
+/// result is here then `Some` is returned, otherwise `None` is returned.
+///
+/// Note that by polling `future` this means that `future` must be re-polled
+/// later if it's to wake up a task.
+pub fn poll_noop<F>(future: Pin<&mut F>) -> Option<F::Output>
+where
+    F: Future,
+{
+    let mut task = Context::from_waker(futures::task::noop_waker_ref());
+    match future.poll(&mut task) {
+        Poll::Ready(result) => Some(result),
+        Poll::Pending => None,
+    }
+}

data/ext/cargo-vendor/wasmtime-wasi-17.0.0/src/preview2/network.rs

@@ -0,0 +1,108 @@
+use crate::preview2::bindings::sockets::network::{Ipv4Address, Ipv6Address};
+use crate::preview2::bindings::wasi::sockets::network::ErrorCode;
+use crate::preview2::TrappableError;
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+pub struct Network {
+    pub socket_addr_check: SocketAddrCheck,
+    pub allow_ip_name_lookup: bool,
+}
+
+impl Network {
+    pub fn check_socket_addr(
+        &self,
+        addr: &SocketAddr,
+        reason: SocketAddrUse,
+    ) -> std::io::Result<()> {
+        self.socket_addr_check.check(addr, reason)
+    }
+}
+
+/// A check that will be called for each socket address that is used of whether the address is permitted.
+#[derive(Clone)]
+pub struct SocketAddrCheck(
+    pub(crate) Arc<dyn Fn(&SocketAddr, SocketAddrUse) -> bool + Send + Sync>,
+);
+
+impl SocketAddrCheck {
+    pub fn check(&self, addr: &SocketAddr, reason: SocketAddrUse) -> std::io::Result<()> {
+        if (self.0)(addr, reason) {
+            Ok(())
+        } else {
+            Err(std::io::Error::new(
+                std::io::ErrorKind::PermissionDenied,
+                "An address was not permitted by the socket address check.",
+            ))
+        }
+    }
+}
+
+impl Default for SocketAddrCheck {
+    fn default() -> Self {
+        Self(Arc::new(|_, _| false))
+    }
+}
+
+/// The reason what a socket address is being used for.
+#[derive(Clone, Copy, Debug)]
+pub enum SocketAddrUse {
+    /// Binding TCP socket
+    TcpBind,
+    /// Connecting TCP socket
+    TcpConnect,
+    /// Binding UDP socket
+    UdpBind,
+    /// Connecting UDP socket
+    UdpConnect,
+    /// Sending datagram on non-connected UDP socket
+    UdpOutgoingDatagram,
+}
+
+pub type SocketResult<T> = Result<T, SocketError>;
+
+pub type SocketError = TrappableError<ErrorCode>;
+
+impl From<wasmtime::component::ResourceTableError> for SocketError {
+    fn from(error: wasmtime::component::ResourceTableError) -> Self {
+        Self::trap(error)
+    }
+}
+
+impl From<std::io::Error> for SocketError {
+    fn from(error: std::io::Error) -> Self {
+        ErrorCode::from(error).into()
+    }
+}
+
+impl From<rustix::io::Errno> for SocketError {
+    fn from(error: rustix::io::Errno) -> Self {
+        ErrorCode::from(error).into()
+    }
+}
+
+#[derive(Copy, Clone)]
+pub enum SocketAddressFamily {
+    Ipv4,
+    Ipv6,
+}
+
+pub(crate) fn to_ipv4_addr(addr: Ipv4Address) -> std::net::Ipv4Addr {
+    let (x0, x1, x2, x3) = addr;
+    std::net::Ipv4Addr::new(x0, x1, x2, x3)
+}
+
+pub(crate) fn from_ipv4_addr(addr: std::net::Ipv4Addr) -> Ipv4Address {
+    let [x0, x1, x2, x3] = addr.octets();
+    (x0, x1, x2, x3)
+}
+
+pub(crate) fn to_ipv6_addr(addr: Ipv6Address) -> std::net::Ipv6Addr {
+    let (x0, x1, x2, x3, x4, x5, x6, x7) = addr;
+    std::net::Ipv6Addr::new(x0, x1, x2, x3, x4, x5, x6, x7)
+}
+
+pub(crate) fn from_ipv6_addr(addr: std::net::Ipv6Addr) -> Ipv6Address {
+    let [x0, x1, x2, x3, x4, x5, x6, x7] = addr.segments();
+    (x0, x1, x2, x3, x4, x5, x6, x7)
+}

data/ext/cargo-vendor/wasmtime-wasi-17.0.0/src/preview2/poll.rs

@@ -0,0 +1,175 @@
+use crate::preview2::{bindings::io::poll, WasiView};
+use anyhow::Result;
+use std::any::Any;
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use wasmtime::component::{Resource, ResourceTable};
+
+pub type PollableFuture<'a> = Pin<Box<dyn Future<Output = ()> + Send + 'a>>;
+pub type MakeFuture = for<'a> fn(&'a mut dyn Any) -> PollableFuture<'a>;
+pub type ClosureFuture = Box<dyn Fn() -> PollableFuture<'static> + Send + Sync + 'static>;
+
+/// A host representation of the `wasi:io/poll.pollable` resource.
+///
+/// A pollable is not the same thing as a Rust Future: the same pollable may be used to
+/// repeatedly check for readiness of a given condition, e.g. if a stream is readable
+/// or writable. So, rather than containing a Future, which can only become Ready once, a
+/// Pollable contains a way to create a Future in each call to `poll`.
+pub struct Pollable {
+    index: u32,
+    make_future: MakeFuture,
+    remove_index_on_delete: Option<fn(&mut ResourceTable, u32) -> Result<()>>,
+}
+
+#[async_trait::async_trait]
+pub trait Subscribe: Send + Sync + 'static {
+    async fn ready(&mut self);
+}
+
+/// Creates a `pollable` resource which is susbcribed to the provided
+/// `resource`.
+///
+/// If `resource` is an owned resource then it will be deleted when the returned
+/// resource is deleted. Otherwise the returned resource is considered a "child"
+/// of the given `resource` which means that the given resource cannot be
+/// deleted while the `pollable` is still alive.
+pub fn subscribe<T>(table: &mut ResourceTable, resource: Resource<T>) -> Result<Resource<Pollable>>
+where
+    T: Subscribe,
+{
+    fn make_future<'a, T>(stream: &'a mut dyn Any) -> PollableFuture<'a>
+    where
+        T: Subscribe,
+    {
+        stream.downcast_mut::<T>().unwrap().ready()
+    }
+
+    let pollable = Pollable {
+        index: resource.rep(),
+        remove_index_on_delete: if resource.owned() {
+            Some(|table, idx| {
+                let resource = Resource::<T>::new_own(idx);
+                table.delete(resource)?;
+                Ok(())
+            })
+        } else {
+            None
+        },
+        make_future: make_future::<T>,
+    };
+
+    Ok(table.push_child(pollable, &resource)?)
+}
+
+#[async_trait::async_trait]
+impl<T: WasiView> poll::Host for T {
+    async fn poll(&mut self, pollables: Vec<Resource<Pollable>>) -> Result<Vec<u32>> {
+        type ReadylistIndex = u32;
+
+        let table = self.table_mut();
+
+        let mut table_futures: HashMap<u32, (MakeFuture, Vec<ReadylistIndex>)> = HashMap::new();
+
+        for (ix, p) in pollables.iter().enumerate() {
+            let ix: u32 = ix.try_into()?;
+
+            let pollable = table.get(p)?;
+            let (_, list) = table_futures
+                .entry(pollable.index)
+                .or_insert((pollable.make_future, Vec::new()));
+            list.push(ix);
+        }
+
+        let mut futures: Vec<(PollableFuture<'_>, Vec<ReadylistIndex>)> = Vec::new();
+        for (entry, (make_future, readylist_indices)) in table.iter_entries(table_futures) {
+            let entry = entry?;
+            futures.push((make_future(entry), readylist_indices));
+        }
+
+        struct PollList<'a> {
+            futures: Vec<(PollableFuture<'a>, Vec<ReadylistIndex>)>,
+        }
+        impl<'a> Future for PollList<'a> {
+            type Output = Vec<u32>;
+
+            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                let mut any_ready = false;
+                let mut results = Vec::new();
+                for (fut, readylist_indicies) in self.futures.iter_mut() {
+                    match fut.as_mut().poll(cx) {
+                        Poll::Ready(()) => {
+                            results.extend_from_slice(readylist_indicies);
+                            any_ready = true;
+                        }
+                        Poll::Pending => {}
+                    }
+                }
+                if any_ready {
+                    Poll::Ready(results)
+                } else {
+                    Poll::Pending
+                }
+            }
+        }
+
+        Ok(PollList { futures }.await)
+    }
+}
+
+#[async_trait::async_trait]
+impl<T: WasiView> crate::preview2::bindings::io::poll::HostPollable for T {
+    async fn block(&mut self, pollable: Resource<Pollable>) -> Result<()> {
+        let table = self.table_mut();
+        let pollable = table.get(&pollable)?;
+        let ready = (pollable.make_future)(table.get_any_mut(pollable.index)?);
+        ready.await;
+        Ok(())
+    }
+    async fn ready(&mut self, pollable: Resource<Pollable>) -> Result<bool> {
+        let table = self.table_mut();
+        let pollable = table.get(&pollable)?;
+        let ready = (pollable.make_future)(table.get_any_mut(pollable.index)?);
+        futures::pin_mut!(ready);
+        Ok(matches!(
+            futures::future::poll_immediate(ready).await,
+            Some(())
+        ))
+    }
+    fn drop(&mut self, pollable: Resource<Pollable>) -> Result<()> {
+        let pollable = self.table_mut().delete(pollable)?;
+        if let Some(delete) = pollable.remove_index_on_delete {
+            delete(self.table_mut(), pollable.index)?;
+        }
+        Ok(())
+    }
+}
+
+pub mod sync {
+    use crate::preview2::{
+        bindings::io::poll as async_poll,
+        bindings::sync_io::io::poll::{self, Pollable},
+        in_tokio, WasiView,
+    };
+    use anyhow::Result;
+    use wasmtime::component::Resource;
+
+    impl<T: WasiView> poll::Host for T {
+        fn poll(&mut self, pollables: Vec<Resource<Pollable>>) -> Result<Vec<u32>> {
+            in_tokio(async { async_poll::Host::poll(self, pollables).await })
+        }
+    }
+
+    impl<T: WasiView> crate::preview2::bindings::sync_io::io::poll::HostPollable for T {
+        fn ready(&mut self, pollable: Resource<Pollable>) -> Result<bool> {
+            in_tokio(async { async_poll::HostPollable::ready(self, pollable).await })
+        }
+        fn block(&mut self, pollable: Resource<Pollable>) -> Result<()> {
+            in_tokio(async { async_poll::HostPollable::block(self, pollable).await })
+        }
+        fn drop(&mut self, pollable: Resource<Pollable>) -> Result<()> {
+            async_poll::HostPollable::drop(self, pollable)
+        }
+    }
+}