wasmtime 24.0.0 → 25.0.0

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/src/write_stream.rs

@@ -1,203 +0,0 @@
-use crate::{HostOutputStream, StreamError, Subscribe};
-use anyhow::anyhow;
-use bytes::Bytes;
-use std::sync::{Arc, Mutex};
-
-#[derive(Debug)]
-struct WorkerState {
-    alive: bool,
-    items: std::collections::VecDeque<Bytes>,
-    write_budget: usize,
-    flush_pending: bool,
-    error: Option<anyhow::Error>,
-}
-
-impl WorkerState {
-    fn check_error(&mut self) -> Result<(), StreamError> {
-        if let Some(e) = self.error.take() {
-            return Err(StreamError::LastOperationFailed(e));
-        }
-        if !self.alive {
-            return Err(StreamError::Closed);
-        }
-        Ok(())
-    }
-}
-
-struct Worker {
-    state: Mutex<WorkerState>,
-    new_work: tokio::sync::Notify,
-    write_ready_changed: tokio::sync::Notify,
-}
-
-enum Job {
-    Flush,
-    Write(Bytes),
-}
-
-impl Worker {
-    fn new(write_budget: usize) -> Self {
-        Self {
-            state: Mutex::new(WorkerState {
-                alive: true,
-                items: std::collections::VecDeque::new(),
-                write_budget,
-                flush_pending: false,
-                error: None,
-            }),
-            new_work: tokio::sync::Notify::new(),
-            write_ready_changed: tokio::sync::Notify::new(),
-        }
-    }
-    async fn ready(&self) {
-        loop {
-            {
-                let state = self.state();
-                if state.error.is_some()
-                    || !state.alive
-                    || (!state.flush_pending && state.write_budget > 0)
-                {
-                    return;
-                }
-            }
-            self.write_ready_changed.notified().await;
-        }
-    }
-    fn check_write(&self) -> Result<usize, StreamError> {
-        let mut state = self.state();
-        if let Err(e) = state.check_error() {
-            return Err(e);
-        }
-
-        if state.flush_pending || state.write_budget == 0 {
-            return Ok(0);
-        }
-
-        Ok(state.write_budget)
-    }
-    fn state(&self) -> std::sync::MutexGuard<WorkerState> {
-        self.state.lock().unwrap()
-    }
-    fn pop(&self) -> Option<Job> {
-        let mut state = self.state();
-        if state.items.is_empty() {
-            if state.flush_pending {
-                return Some(Job::Flush);
-            }
-        } else if let Some(bytes) = state.items.pop_front() {
-            return Some(Job::Write(bytes));
-        }
-
-        None
-    }
-    fn report_error(&self, e: std::io::Error) {
-        {
-            let mut state = self.state();
-            state.alive = false;
-            state.error = Some(e.into());
-            state.flush_pending = false;
-        }
-        self.write_ready_changed.notify_one();
-    }
-    async fn work<T: tokio::io::AsyncWrite + Send + Unpin + 'static>(&self, mut writer: T) {
-        use tokio::io::AsyncWriteExt;
-        loop {
-            while let Some(job) = self.pop() {
-                match job {
-                    Job::Flush => {
-                        if let Err(e) = writer.flush().await {
-                            self.report_error(e);
-                            return;
-                        }
-
-                        tracing::debug!("worker marking flush complete");
-                        self.state().flush_pending = false;
-                    }
-
-                    Job::Write(mut bytes) => {
-                        tracing::debug!("worker writing: {bytes:?}");
-                        let len = bytes.len();
-                        match writer.write_all_buf(&mut bytes).await {
-                            Err(e) => {
-                                self.report_error(e);
-                                return;
-                            }
-                            Ok(_) => {
-                                self.state().write_budget += len;
-                            }
-                        }
-                    }
-                }
-
-                self.write_ready_changed.notify_one();
-            }
-            self.new_work.notified().await;
-        }
-    }
-}
-
-/// Provides a [`HostOutputStream`] impl from a [`tokio::io::AsyncWrite`] impl
-pub struct AsyncWriteStream {
-    worker: Arc<Worker>,
-    _join_handle: crate::runtime::AbortOnDropJoinHandle<()>,
-}
-
-impl AsyncWriteStream {
-    /// Create a [`AsyncWriteStream`]. In order to use the [`HostOutputStream`] impl
-    /// provided by this struct, the argument must impl [`tokio::io::AsyncWrite`].
-    pub fn new<T: tokio::io::AsyncWrite + Send + Unpin + 'static>(
-        write_budget: usize,
-        writer: T,
-    ) -> Self {
-        let worker = Arc::new(Worker::new(write_budget));
-
-        let w = Arc::clone(&worker);
-        let join_handle = crate::runtime::spawn(async move { w.work(writer).await });
-
-        AsyncWriteStream {
-            worker,
-            _join_handle: join_handle,
-        }
-    }
-}
-
-impl HostOutputStream for AsyncWriteStream {
-    fn write(&mut self, bytes: Bytes) -> Result<(), StreamError> {
-        let mut state = self.worker.state();
-        state.check_error()?;
-        if state.flush_pending {
-            return Err(StreamError::Trap(anyhow!(
-                "write not permitted while flush pending"
-            )));
-        }
-        match state.write_budget.checked_sub(bytes.len()) {
-            Some(remaining_budget) => {
-                state.write_budget = remaining_budget;
-                state.items.push_back(bytes);
-            }
-            None => return Err(StreamError::Trap(anyhow!("write exceeded budget"))),
-        }
-        drop(state);
-        self.worker.new_work.notify_one();
-        Ok(())
-    }
-    fn flush(&mut self) -> Result<(), StreamError> {
-        let mut state = self.worker.state();
-        state.check_error()?;
-
-        state.flush_pending = true;
-        self.worker.new_work.notify_one();
-
-        Ok(())
-    }
-
-    fn check_write(&mut self) -> Result<usize, StreamError> {
-        self.worker.check_write()
-    }
-}
-#[async_trait::async_trait]
-impl Subscribe for AsyncWriteStream {
-    async fn ready(&mut self) {
-        self.worker.ready().await;
-    }
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/tests/all/main.rs

@@ -1,91 +0,0 @@
-use anyhow::Result;
-use tempfile::TempDir;
-use wasmtime::{
-    component::{Component, Linker, ResourceTable},
-    Engine, Store,
-};
-use wasmtime_wasi::preview1::WasiP1Ctx;
-use wasmtime_wasi::{
-    pipe::MemoryOutputPipe, DirPerms, FilePerms, WasiCtx, WasiCtxBuilder, WasiView,
-};
-
-struct Ctx {
-    stdout: MemoryOutputPipe,
-    stderr: MemoryOutputPipe,
-    wasi: WasiP1Ctx,
-}
-
-impl WasiView for Ctx {
-    fn table(&mut self) -> &mut ResourceTable {
-        self.wasi.table()
-    }
-    fn ctx(&mut self) -> &mut WasiCtx {
-        self.wasi.ctx()
-    }
-}
-
-fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
-    let prefix = format!("wasi_components_{}_", exe_name);
-    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
-    Ok(tempdir)
-}
-
-fn store(
-    engine: &Engine,
-    name: &str,
-    configure: impl FnOnce(&mut WasiCtxBuilder),
-) -> Result<(Store<Ctx>, TempDir)> {
-    let stdout = MemoryOutputPipe::new(4096);
-    let stderr = MemoryOutputPipe::new(4096);
-    let workspace = prepare_workspace(name)?;
-
-    // Create our wasi context.
-    let mut builder = WasiCtxBuilder::new();
-    builder.stdout(stdout.clone()).stderr(stderr.clone());
-
-    builder
-        .args(&[name, "."])
-        .inherit_network()
-        .allow_ip_name_lookup(true);
-    println!("preopen: {:?}", workspace);
-    builder.preopened_dir(workspace.path(), ".", DirPerms::all(), FilePerms::all())?;
-    for (var, val) in test_programs_artifacts::wasi_tests_environment() {
-        builder.env(var, val);
-    }
-
-    configure(&mut builder);
-    let ctx = Ctx {
-        wasi: builder.build_p1(),
-        stderr,
-        stdout,
-    };
-
-    Ok((Store::new(&engine, ctx), workspace))
-}
-
-impl Drop for Ctx {
-    fn drop(&mut self) {
-        let stdout = self.stdout.contents();
-        if !stdout.is_empty() {
-            println!("[guest] stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
-        }
-        let stderr = self.stderr.contents();
-        if !stderr.is_empty() {
-            println!("[guest] stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
-        }
-    }
-}
-
-// Assert that each of `sync` and `async` below are testing everything through
-// assertion of the existence of the test function itself.
-macro_rules! assert_test_exists {
-    ($name:ident) => {
-        #[allow(unused_imports)]
-        use self::$name as _;
-    };
-}
-
-mod api;
-mod async_;
-mod preview1;
-mod sync;

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/tests/process_stdin.rs

@@ -1,165 +0,0 @@
-use std::io::{BufRead, Write};
-use std::process::Command;
-use wasmtime_wasi::{HostInputStream, Subscribe};
-
-const VAR_NAME: &str = "__CHILD_PROCESS";
-
-fn main() {
-    if cfg!(miri) {
-        return;
-    }
-    // Skip this tests if it looks like we're in a cross-compiled situation and
-    // we're emulating this test for a different platform. In that scenario
-    // emulators (like QEMU) tend to not report signals the same way and such.
-    if std::env::vars()
-        .filter(|(k, _v)| k.starts_with("CARGO_TARGET") && k.ends_with("RUNNER"))
-        .count()
-        > 0
-    {
-        return;
-    }
-
-    match std::env::var(VAR_NAME) {
-        Ok(_) => child_process(),
-        Err(_) => parent_process(),
-    }
-
-    fn child_process() {
-        let mut result_write = std::io::stderr();
-        let mut child_running = true;
-        while child_running {
-            tokio::runtime::Builder::new_multi_thread()
-                .enable_all()
-                .build()
-                .unwrap()
-                .block_on(async {
-                    'task: loop {
-                        println!("child: creating stdin");
-                        let mut stdin = wasmtime_wasi::stdin();
-
-                        println!("child: checking that stdin is not ready");
-                        assert!(
-                            tokio::time::timeout(
-                                std::time::Duration::from_millis(100),
-                                stdin.ready()
-                            )
-                            .await
-                            .is_err(),
-                            "stdin available too soon"
-                        );
-
-                        writeln!(&mut result_write, "start").unwrap();
-
-                        println!("child: started");
-
-                        let mut buffer = String::new();
-                        loop {
-                            println!("child: waiting for stdin to be ready");
-                            stdin.ready().await;
-
-                            println!("child: reading input");
-                            // We can't effectively test for the case where stdin was closed, so panic if it is...
-                            let bytes = stdin.read(1024).unwrap();
-
-                            println!("child got: {:?}", bytes);
-
-                            buffer.push_str(std::str::from_utf8(bytes.as_ref()).unwrap());
-                            if let Some((line, rest)) = buffer.split_once('\n') {
-                                if line == "all done" {
-                                    writeln!(&mut result_write, "done").unwrap();
-                                    println!("child: exiting...");
-                                    child_running = false;
-                                    break 'task;
-                                } else if line == "restart_runtime" {
-                                    writeln!(&mut result_write, "restarting").unwrap();
-                                    println!("child: restarting runtime...");
-                                    break 'task;
-                                } else if line == "restart_task" {
-                                    writeln!(&mut result_write, "restarting").unwrap();
-                                    println!("child: restarting task...");
-                                    continue 'task;
-                                } else {
-                                    writeln!(&mut result_write, "{}", line).unwrap();
-                                }
-
-                                buffer = rest.to_owned();
-                            }
-                        }
-                    }
-                });
-            println!("child: runtime exited");
-        }
-        println!("child: exiting");
-    }
-}
-
-fn parent_process() {
-    let me = std::env::current_exe().unwrap();
-    let mut cmd = Command::new(me);
-    cmd.env(VAR_NAME, "1");
-    cmd.stdin(std::process::Stdio::piped());
-
-    if std::env::args().any(|arg| arg == "--nocapture") {
-        cmd.stdout(std::process::Stdio::inherit());
-    } else {
-        cmd.stdout(std::process::Stdio::null());
-    }
-
-    cmd.stderr(std::process::Stdio::piped());
-    let mut child = cmd.spawn().unwrap();
-
-    let mut stdin_write = child.stdin.take().unwrap();
-    let mut result_read = std::io::BufReader::new(child.stderr.take().unwrap());
-
-    let mut line = String::new();
-    result_read.read_line(&mut line).unwrap();
-    assert_eq!(line, "start\n");
-
-    for i in 0..5 {
-        let message = format!("some bytes {}\n", i);
-        stdin_write.write_all(message.as_bytes()).unwrap();
-        line.clear();
-        result_read.read_line(&mut line).unwrap();
-        assert_eq!(line, message);
-    }
-
-    writeln!(&mut stdin_write, "restart_task").unwrap();
-    line.clear();
-    result_read.read_line(&mut line).unwrap();
-    assert_eq!(line, "restarting\n");
-    line.clear();
-
-    result_read.read_line(&mut line).unwrap();
-    assert_eq!(line, "start\n");
-
-    for i in 0..10 {
-        let message = format!("more bytes {}\n", i);
-        stdin_write.write_all(message.as_bytes()).unwrap();
-        line.clear();
-        result_read.read_line(&mut line).unwrap();
-        assert_eq!(line, message);
-    }
-
-    writeln!(&mut stdin_write, "restart_runtime").unwrap();
-    line.clear();
-    result_read.read_line(&mut line).unwrap();
-    assert_eq!(line, "restarting\n");
-    line.clear();
-
-    result_read.read_line(&mut line).unwrap();
-    assert_eq!(line, "start\n");
-
-    for i in 0..17 {
-        let message = format!("even more bytes {}\n", i);
-        stdin_write.write_all(message.as_bytes()).unwrap();
-        line.clear();
-        result_read.read_line(&mut line).unwrap();
-        assert_eq!(line, message);
-    }
-
-    writeln!(&mut stdin_write, "all done").unwrap();
-
-    line.clear();
-    result_read.read_line(&mut line).unwrap();
-    assert_eq!(line, "done\n");
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/command-extended.wit

@@ -1,6 +0,0 @@
-// All of the same imports and exports available in the wasi:cli/command world
-// with addition of HTTP proxy related imports:
-world command-extended {
-  include wasi:cli/command@0.2.0;
-  import wasi:http/outgoing-handler@0.2.0;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/cli/command.wit

@@ -1,7 +0,0 @@
-package wasi:cli@0.2.0;
-
-world command {
-  include imports;
-
-  export run;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/cli/environment.wit

@@ -1,18 +0,0 @@
-interface environment {
-  /// Get the POSIX-style environment variables.
-  ///
-  /// Each environment variable is provided as a pair of string variable names
-  /// and string value.
-  ///
-  /// Morally, these are a value import, but until value imports are available
-  /// in the component model, this import function should return the same
-  /// values each time it is called.
-  get-environment: func() -> list<tuple<string, string>>;
-
-  /// Get the POSIX-style arguments to the program.
-  get-arguments: func() -> list<string>;
-
-  /// Return a path that programs should use as their initial current working
-  /// directory, interpreting `.` as shorthand for this.
-  initial-cwd: func() -> option<string>;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/cli/exit.wit

@@ -1,4 +0,0 @@
-interface exit {
-  /// Exit the current instance and any linked instances.
-  exit: func(status: result);
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/cli/imports.wit

@@ -1,20 +0,0 @@
-package wasi:cli@0.2.0;
-
-world imports {
-  include wasi:clocks/imports@0.2.0;
-  include wasi:filesystem/imports@0.2.0;
-  include wasi:sockets/imports@0.2.0;
-  include wasi:random/imports@0.2.0;
-  include wasi:io/imports@0.2.0;
-
-  import environment;
-  import exit;
-  import stdin;
-  import stdout;
-  import stderr;
-  import terminal-input;
-  import terminal-output;
-  import terminal-stdin;
-  import terminal-stdout;
-  import terminal-stderr;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/cli/run.wit

@@ -1,4 +0,0 @@
-interface run {
-  /// Run the program.
-  run: func() -> result;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/cli/stdio.wit

@@ -1,17 +0,0 @@
-interface stdin {
-  use wasi:io/streams@0.2.0.{input-stream};
-
-  get-stdin: func() -> input-stream;
-}
-
-interface stdout {
-  use wasi:io/streams@0.2.0.{output-stream};
-
-  get-stdout: func() -> output-stream;
-}
-
-interface stderr {
-  use wasi:io/streams@0.2.0.{output-stream};
-
-  get-stderr: func() -> output-stream;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/cli/terminal.wit

@@ -1,49 +0,0 @@
-/// Terminal input.
-///
-/// In the future, this may include functions for disabling echoing,
-/// disabling input buffering so that keyboard events are sent through
-/// immediately, querying supported features, and so on.
-interface terminal-input {
-    /// The input side of a terminal.
-    resource terminal-input;
-}
-
-/// Terminal output.
-///
-/// In the future, this may include functions for querying the terminal
-/// size, being notified of terminal size changes, querying supported
-/// features, and so on.
-interface terminal-output {
-    /// The output side of a terminal.
-    resource terminal-output;
-}
-
-/// An interface providing an optional `terminal-input` for stdin as a
-/// link-time authority.
-interface terminal-stdin {
-    use terminal-input.{terminal-input};
-
-    /// If stdin is connected to a terminal, return a `terminal-input` handle
-    /// allowing further interaction with it.
-    get-terminal-stdin: func() -> option<terminal-input>;
-}
-
-/// An interface providing an optional `terminal-output` for stdout as a
-/// link-time authority.
-interface terminal-stdout {
-    use terminal-output.{terminal-output};
-
-    /// If stdout is connected to a terminal, return a `terminal-output` handle
-    /// allowing further interaction with it.
-    get-terminal-stdout: func() -> option<terminal-output>;
-}
-
-/// An interface providing an optional `terminal-output` for stderr as a
-/// link-time authority.
-interface terminal-stderr {
-    use terminal-output.{terminal-output};
-
-    /// If stderr is connected to a terminal, return a `terminal-output` handle
-    /// allowing further interaction with it.
-    get-terminal-stderr: func() -> option<terminal-output>;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/clocks/monotonic-clock.wit

@@ -1,45 +0,0 @@
-package wasi:clocks@0.2.0;
-/// WASI Monotonic Clock is a clock API intended to let users measure elapsed
-/// time.
-///
-/// It is intended to be portable at least between Unix-family platforms and
-/// Windows.
-///
-/// A monotonic clock is a clock which has an unspecified initial value, and
-/// successive reads of the clock will produce non-decreasing values.
-///
-/// It is intended for measuring elapsed time.
-interface monotonic-clock {
-    use wasi:io/poll@0.2.0.{pollable};
-
-    /// An instant in time, in nanoseconds. An instant is relative to an
-    /// unspecified initial value, and can only be compared to instances from
-    /// the same monotonic-clock.
-    type instant = u64;
-
-    /// A duration of time, in nanoseconds.
-    type duration = u64;
-
-    /// Read the current value of the clock.
-    ///
-    /// The clock is monotonic, therefore calling this function repeatedly will
-    /// produce a sequence of non-decreasing values.
-    now: func() -> instant;
-
-    /// Query the resolution of the clock. Returns the duration of time
-    /// corresponding to a clock tick.
-    resolution: func() -> duration;
-
-    /// Create a `pollable` which will resolve once the specified instant
-    /// occured.
-    subscribe-instant: func(
-        when: instant,
-    ) -> pollable;
-
-    /// Create a `pollable` which will resolve once the given duration has
-    /// elapsed, starting at the time at which this function was called.
-    /// occured.
-    subscribe-duration: func(
-        when: duration,
-    ) -> pollable;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/clocks/wall-clock.wit

@@ -1,42 +0,0 @@
-package wasi:clocks@0.2.0;
-/// WASI Wall Clock is a clock API intended to let users query the current
-/// time. The name "wall" makes an analogy to a "clock on the wall", which
-/// is not necessarily monotonic as it may be reset.
-///
-/// It is intended to be portable at least between Unix-family platforms and
-/// Windows.
-///
-/// A wall clock is a clock which measures the date and time according to
-/// some external reference.
-///
-/// External references may be reset, so this clock is not necessarily
-/// monotonic, making it unsuitable for measuring elapsed time.
-///
-/// It is intended for reporting the current date and time for humans.
-interface wall-clock {
-    /// A time and date in seconds plus nanoseconds.
-    record datetime {
-        seconds: u64,
-        nanoseconds: u32,
-    }
-
-    /// Read the current value of the clock.
-    ///
-    /// This clock is not monotonic, therefore calling this function repeatedly
-    /// will not necessarily produce a sequence of non-decreasing values.
-    ///
-    /// The returned timestamps represent the number of seconds since
-    /// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
-    /// also known as [Unix Time].
-    ///
-    /// The nanoseconds field of the output is always less than 1000000000.
-    ///
-    /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
-    /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
-    now: func() -> datetime;
-
-    /// Query the resolution of the clock.
-    ///
-    /// The nanoseconds field of the output is always less than 1000000000.
-    resolution: func() -> datetime;
-}

data/ext/cargo-vendor/wasmtime-wasi-24.0.0/wit/deps/clocks/world.wit

@@ -1,6 +0,0 @@
-package wasi:clocks@0.2.0;
-
-world imports {
-    import monotonic-clock;
-    import wall-clock;
-}