wasmtime 15.0.1 → 16.0.0

data/ext/cargo-vendor/wasmtime-wasi-16.0.0/tests/all/sync.rs

@@ -0,0 +1,299 @@
+use super::*;
+use std::path::Path;
+use test_programs_artifacts::*;
+use wasmtime_wasi::preview2::command::sync::{add_to_linker, Command};
+
+fn run(path: &str, inherit_stdio: bool) -> Result<()> {
+    let path = Path::new(path);
+    let name = path.file_stem().unwrap().to_str().unwrap();
+    let mut config = Config::new();
+    config.wasm_component_model(true);
+    let engine = Engine::new(&config)?;
+    let mut linker = Linker::new(&engine);
+    add_to_linker(&mut linker)?;
+
+    let (mut store, _td) = store(&engine, name, inherit_stdio)?;
+    let component = Component::from_file(&engine, path)?;
+    let (command, _instance) = Command::instantiate(&mut store, &component, &linker)?;
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)?
+        .map_err(|()| anyhow::anyhow!("run returned a failure"))
+}
+
+foreach_preview1!(assert_test_exists);
+foreach_preview2!(assert_test_exists);
+
+// Below here is mechanical: there should be one test for every binary in
+// wasi-tests.
+#[test_log::test]
+fn preview1_big_random_buf() {
+    run(PREVIEW1_BIG_RANDOM_BUF_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_clock_time_get() {
+    run(PREVIEW1_CLOCK_TIME_GET_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_close_preopen() {
+    run(PREVIEW1_CLOSE_PREOPEN_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_dangling_fd() {
+    run(PREVIEW1_DANGLING_FD_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_dangling_symlink() {
+    run(PREVIEW1_DANGLING_SYMLINK_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_directory_seek() {
+    run(PREVIEW1_DIRECTORY_SEEK_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_dir_fd_op_failures() {
+    run(PREVIEW1_DIR_FD_OP_FAILURES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_advise() {
+    run(PREVIEW1_FD_ADVISE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_filestat_get() {
+    run(PREVIEW1_FD_FILESTAT_GET_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_filestat_set() {
+    run(PREVIEW1_FD_FILESTAT_SET_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_flags_set() {
+    run(PREVIEW1_FD_FLAGS_SET_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_readdir() {
+    run(PREVIEW1_FD_READDIR_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_allocate() {
+    run(PREVIEW1_FILE_ALLOCATE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_pread_pwrite() {
+    run(PREVIEW1_FILE_PREAD_PWRITE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_seek_tell() {
+    run(PREVIEW1_FILE_SEEK_TELL_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_truncation() {
+    run(PREVIEW1_FILE_TRUNCATION_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_unbuffered_write() {
+    run(PREVIEW1_FILE_UNBUFFERED_WRITE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_interesting_paths() {
+    run(PREVIEW1_INTERESTING_PATHS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_regular_file_isatty() {
+    run(PREVIEW1_REGULAR_FILE_ISATTY_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_nofollow_errors() {
+    run(PREVIEW1_NOFOLLOW_ERRORS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_overwrite_preopen() {
+    run(PREVIEW1_OVERWRITE_PREOPEN_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_exists() {
+    run(PREVIEW1_PATH_EXISTS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_filestat() {
+    run(PREVIEW1_PATH_FILESTAT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_link() {
+    run(PREVIEW1_PATH_LINK_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_create_existing() {
+    run(PREVIEW1_PATH_OPEN_CREATE_EXISTING_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_read_write() {
+    run(PREVIEW1_PATH_OPEN_READ_WRITE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_dirfd_not_dir() {
+    run(PREVIEW1_PATH_OPEN_DIRFD_NOT_DIR_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_missing() {
+    run(PREVIEW1_PATH_OPEN_MISSING_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_nonblock() {
+    run(PREVIEW1_PATH_OPEN_NONBLOCK_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_rename_dir_trailing_slashes() {
+    run(PREVIEW1_PATH_RENAME_DIR_TRAILING_SLASHES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_rename() {
+    run(PREVIEW1_PATH_RENAME_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_symlink_trailing_slashes() {
+    run(PREVIEW1_PATH_SYMLINK_TRAILING_SLASHES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_poll_oneoff_files() {
+    run(PREVIEW1_POLL_ONEOFF_FILES_COMPONENT, false).unwrap()
+}
+
+#[test_log::test]
+fn preview1_poll_oneoff_stdio() {
+    run(PREVIEW1_POLL_ONEOFF_STDIO_COMPONENT, true).unwrap()
+}
+#[test_log::test]
+fn preview1_readlink() {
+    run(PREVIEW1_READLINK_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_remove_directory() {
+    run(PREVIEW1_REMOVE_DIRECTORY_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_remove_nonempty_directory() {
+    run(PREVIEW1_REMOVE_NONEMPTY_DIRECTORY_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_renumber() {
+    run(PREVIEW1_RENUMBER_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_sched_yield() {
+    run(PREVIEW1_SCHED_YIELD_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_stdio() {
+    run(PREVIEW1_STDIO_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_stdio_isatty() {
+    // If the test process is setup such that stdio is a terminal:
+    if test_programs_artifacts::stdio_is_terminal() {
+        // Inherit stdio, test asserts each is not tty:
+        run(PREVIEW1_STDIO_ISATTY_COMPONENT, true).unwrap()
+    }
+}
+#[test_log::test]
+fn preview1_stdio_not_isatty() {
+    // Don't inherit stdio, test asserts each is not tty:
+    run(PREVIEW1_STDIO_NOT_ISATTY_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_symlink_create() {
+    run(PREVIEW1_SYMLINK_CREATE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_symlink_filestat() {
+    run(PREVIEW1_SYMLINK_FILESTAT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_symlink_loop() {
+    run(PREVIEW1_SYMLINK_LOOP_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_unlink_file_trailing_slashes() {
+    run(PREVIEW1_UNLINK_FILE_TRAILING_SLASHES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_preopen() {
+    run(PREVIEW1_PATH_OPEN_PREOPEN_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_unicode_output() {
+    run(PREVIEW1_UNICODE_OUTPUT_COMPONENT, true).unwrap()
+}
+#[test_log::test]
+fn preview1_file_write() {
+    run(PREVIEW1_FILE_WRITE_COMPONENT, false).unwrap()
+}
+
+#[test_log::test]
+fn preview2_sleep() {
+    run(PREVIEW2_SLEEP_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_random() {
+    run(PREVIEW2_RANDOM_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_ip_name_lookup() {
+    run(PREVIEW2_IP_NAME_LOOKUP_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_sockopts() {
+    run(PREVIEW2_TCP_SOCKOPTS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_sample_application() {
+    run(PREVIEW2_TCP_SAMPLE_APPLICATION_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_states() {
+    run(PREVIEW2_TCP_STATES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_bind() {
+    run(PREVIEW2_TCP_BIND_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_connect() {
+    run(PREVIEW2_TCP_CONNECT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_udp_sockopts() {
+    run(PREVIEW2_UDP_SOCKOPTS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_udp_sample_application() {
+    run(PREVIEW2_UDP_SAMPLE_APPLICATION_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_udp_states() {
+    run(PREVIEW2_UDP_STATES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_udp_bind() {
+    run(PREVIEW2_UDP_BIND_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_udp_connect() {
+    run(PREVIEW2_UDP_CONNECT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_stream_pollable_correct() {
+    run(PREVIEW2_STREAM_POLLABLE_CORRECT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_stream_pollable_traps() {
+    let e = run(PREVIEW2_STREAM_POLLABLE_TRAPS_COMPONENT, false).unwrap_err();
+    assert_eq!(
+        format!("{}", e.source().expect("trap source")),
+        "entry still has children"
+    )
+}
+#[test_log::test]
+fn preview2_adapter_badfd() {
+    run(PREVIEW2_ADAPTER_BADFD_COMPONENT, false).unwrap()
+}

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

@@ -0,0 +1,165 @@
+use std::io::{BufRead, Write};
+use std::process::Command;
+use wasmtime_wasi::preview2::{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::preview2::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-16.0.0/wit/command-extended.wit

@@ -0,0 +1,6 @@
+// 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-rc-2023-12-05;
+  import wasi:http/outgoing-handler@0.2.0-rc-2023-12-05;
+}

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

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

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

@@ -0,0 +1,20 @@
+package wasi:cli@0.2.0-rc-2023-12-05;
+
+world imports {
+  include wasi:clocks/imports@0.2.0-rc-2023-11-10;
+  include wasi:filesystem/imports@0.2.0-rc-2023-11-10;
+  include wasi:sockets/imports@0.2.0-rc-2023-11-10;
+  include wasi:random/imports@0.2.0-rc-2023-11-10;
+  include wasi:io/imports@0.2.0-rc-2023-11-10;
+
+  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-16.0.0/wit/deps/http/proxy.wit

@@ -0,0 +1,32 @@
+package wasi:http@0.2.0-rc-2023-12-05;
+
+/// The `wasi:http/proxy` world captures a widely-implementable intersection of
+/// hosts that includes HTTP forward and reverse proxies. Components targeting
+/// this world may concurrently stream in and out any number of incoming and
+/// outgoing HTTP requests.
+world proxy {
+  /// HTTP proxies have access to time and randomness.
+  include wasi:clocks/imports@0.2.0-rc-2023-11-10;
+  import wasi:random/random@0.2.0-rc-2023-11-10;
+
+  /// Proxies have standard output and error streams which are expected to
+  /// terminate in a developer-facing console provided by the host.
+  import wasi:cli/stdout@0.2.0-rc-2023-12-05;
+  import wasi:cli/stderr@0.2.0-rc-2023-12-05;
+
+  /// TODO: this is a temporary workaround until component tooling is able to
+  /// gracefully handle the absence of stdin. Hosts must return an eof stream
+  /// for this import, which is what wasi-libc + tooling will do automatically
+  /// when this import is properly removed.
+  import wasi:cli/stdin@0.2.0-rc-2023-12-05;
+
+  /// This is the default handler to use when user code simply wants to make an
+  /// HTTP request (e.g., via `fetch()`).
+  import outgoing-handler;
+
+  /// The host delivers incoming HTTP requests to a component by calling the
+  /// `handle` function of this exported interface. A host may arbitrarily reuse
+  /// or not reuse component instance when delivering incoming HTTP requests and
+  /// thus a component must be able to handle 0..N calls to `handle`.
+  export incoming-handler;
+}