wasmtime 22.0.0 → 23.0.2

data/ext/cargo-vendor/wasi-common-22.0.0/Cargo.toml

@@ -1,224 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2021"
-name = "wasi-common"
-version = "22.0.0"
-authors = ["The Wasmtime Project Developers"]
-include = [
-    "src/**/*",
-    "tests/**/*",
-    "witx",
-    "README.md",
-    "LICENSE",
-    "build.rs",
-]
-description = "WASI implementation in Rust"
-readme = "README.md"
-keywords = [
-    "webassembly",
-    "wasm",
-]
-categories = ["wasm"]
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-
-[package.metadata.docs.rs]
-all-features = true
-
-[[test]]
-name = "all"
-
-[dependencies.anyhow]
-version = "1.0.22"
-features = ["std"]
-default-features = false
-
-[dependencies.bitflags]
-version = "2.0"
-
-[dependencies.cap-fs-ext]
-version = "3.0.0"
-optional = true
-
-[dependencies.cap-rand]
-version = "3.0.0"
-features = ["small_rng"]
-
-[dependencies.cap-std]
-version = "3.0.0"
-
-[dependencies.cap-time-ext]
-version = "3.0.0"
-optional = true
-
-[dependencies.fs-set-times]
-version = "0.20.1"
-optional = true
-
-[dependencies.io-lifetimes]
-version = "2.0.3"
-optional = true
-default-features = false
-
-[dependencies.libc]
-version = "0.2.112"
-optional = true
-default-features = true
-
-[dependencies.log]
-version = "0.4.8"
-default-features = false
-
-[dependencies.system-interface]
-version = "0.27.1"
-features = [
-    "cap_std_impls",
-    "cap_std_impls",
-]
-optional = true
-
-[dependencies.thiserror]
-version = "1.0.43"
-
-[dependencies.tokio]
-version = "1.26.0"
-features = [
-    "rt",
-    "time",
-    "rt",
-    "fs",
-    "time",
-    "io-util",
-    "net",
-    "io-std",
-    "rt-multi-thread",
-]
-optional = true
-
-[dependencies.tracing]
-version = "0.1.26"
-
-[dependencies.wasmtime]
-version = "22.0.0"
-features = ["runtime"]
-optional = true
-default-features = false
-
-[dependencies.wiggle]
-version = "=22.0.0"
-default-features = false
-
-[dev-dependencies.tempfile]
-version = "3.1.0"
-
-[dev-dependencies.test-log]
-version = "0.2"
-features = ["trace"]
-default-features = false
-
-[dev-dependencies.tokio]
-version = "1.26.0"
-features = [
-    "rt",
-    "time",
-    "macros",
-    "rt-multi-thread",
-]
-
-[dev-dependencies.tracing-subscriber]
-version = "0.3.1"
-features = [
-    "fmt",
-    "env-filter",
-    "ansi",
-    "tracing-log",
-]
-default-features = false
-
-[dev-dependencies.wasmtime]
-version = "22.0.0"
-features = [
-    "cranelift",
-    "async",
-    "runtime",
-]
-default-features = false
-
-[features]
-default = [
-    "trace_log",
-    "wasmtime",
-    "sync",
-]
-exit = [
-    "wasmtime",
-    "dep:libc",
-]
-sync = [
-    "wasmtime",
-    "dep:cap-fs-ext",
-    "dep:cap-time-ext",
-    "dep:fs-set-times",
-    "dep:system-interface",
-    "dep:io-lifetimes",
-]
-tokio = [
-    "sync",
-    "wasmtime/async",
-    "wiggle/wasmtime_async",
-    "dep:tokio",
-]
-trace_log = [
-    "wiggle/tracing_log",
-    "tracing/log",
-]
-wasmtime = [
-    "dep:wasmtime",
-    "wiggle/wasmtime",
-]
-wiggle_metadata = ["wiggle/wiggle_metadata"]
-
-[target."cfg(unix)".dependencies.rustix]
-version = "0.38.31"
-features = [
-    "fs",
-    "event",
-]
-
-[target."cfg(windows)".dependencies.io-extras]
-version = "0.18.1"
-
-[target."cfg(windows)".dependencies.once_cell]
-version = "1.12.0"
-default-features = false
-
-[target."cfg(windows)".dependencies.rustix]
-version = "0.38.31"
-features = ["net"]
-
-[target."cfg(windows)".dependencies.windows-sys]
-version = "0.52.0"
-features = [
-    "Win32_Foundation",
-    "Win32_Networking_WinSock",
-]
-
-[lints.clippy]
-all = "allow"
-
-[lints.rust]
-trivial_numeric_casts = "warn"
-unstable_features = "warn"
-unused-lifetimes = "warn"
-unused_extern_crates = "warn"
-unused_import_braces = "warn"

data/ext/cargo-vendor/wasi-common-22.0.0/src/tokio/mod.rs

@@ -1,137 +0,0 @@
-#![cfg_attr(io_lifetimes_use_std, feature(io_safety))]
-
-mod dir;
-mod file;
-pub mod net;
-pub mod sched;
-pub mod stdio;
-
-use self::sched::sched_ctx;
-use crate::sync::net::Socket;
-pub use crate::sync::{clocks_ctx, random_ctx};
-use crate::{file::FileAccessMode, Error, Table, WasiCtx, WasiFile};
-pub use dir::Dir;
-pub use file::File;
-pub use net::*;
-use std::future::Future;
-use std::mem;
-use std::path::Path;
-
-pub struct WasiCtxBuilder {
-    ctx: WasiCtx,
-    built: bool,
-}
-
-impl WasiCtxBuilder {
-    pub fn new() -> Self {
-        WasiCtxBuilder {
-            ctx: WasiCtx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
-            built: false,
-        }
-    }
-    pub fn env(&mut self, var: &str, value: &str) -> Result<&mut Self, crate::StringArrayError> {
-        self.ctx.push_env(var, value)?;
-        Ok(self)
-    }
-    pub fn envs(&mut self, env: &[(String, String)]) -> Result<&mut Self, crate::StringArrayError> {
-        for (k, v) in env {
-            self.ctx.push_env(k, v)?;
-        }
-        Ok(self)
-    }
-    pub fn inherit_env(&mut self) -> Result<&mut Self, crate::StringArrayError> {
-        for (key, value) in std::env::vars() {
-            self.ctx.push_env(&key, &value)?;
-        }
-        Ok(self)
-    }
-    pub fn arg(&mut self, arg: &str) -> Result<&mut Self, crate::StringArrayError> {
-        self.ctx.push_arg(arg)?;
-        Ok(self)
-    }
-    pub fn args(&mut self, arg: &[String]) -> Result<&mut Self, crate::StringArrayError> {
-        for a in arg {
-            self.ctx.push_arg(&a)?;
-        }
-        Ok(self)
-    }
-    pub fn inherit_args(&mut self) -> Result<&mut Self, crate::StringArrayError> {
-        for arg in std::env::args() {
-            self.ctx.push_arg(&arg)?;
-        }
-        Ok(self)
-    }
-    pub fn stdin(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stdin(f);
-        self
-    }
-    pub fn stdout(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stdout(f);
-        self
-    }
-    pub fn stderr(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stderr(f);
-        self
-    }
-    pub fn inherit_stdin(&mut self) -> &mut Self {
-        self.stdin(Box::new(crate::tokio::stdio::stdin()))
-    }
-    pub fn inherit_stdout(&mut self) -> &mut Self {
-        self.stdout(Box::new(crate::tokio::stdio::stdout()))
-    }
-    pub fn inherit_stderr(&mut self) -> &mut Self {
-        self.stderr(Box::new(crate::tokio::stdio::stderr()))
-    }
-    pub fn inherit_stdio(&mut self) -> &mut Self {
-        self.inherit_stdin().inherit_stdout().inherit_stderr()
-    }
-    pub fn preopened_dir(
-        &mut self,
-        dir: cap_std::fs::Dir,
-        guest_path: impl AsRef<Path>,
-    ) -> Result<&mut Self, Error> {
-        let dir = Box::new(crate::tokio::dir::Dir::from_cap_std(dir));
-        self.ctx.push_preopened_dir(dir, guest_path)?;
-        Ok(self)
-    }
-    pub fn preopened_socket(
-        &mut self,
-        fd: u32,
-        socket: impl Into<Socket>,
-    ) -> Result<&mut Self, Error> {
-        let socket: Socket = socket.into();
-        let file: Box<dyn WasiFile> = socket.into();
-        self.ctx
-            .insert_file(fd, file, FileAccessMode::READ | FileAccessMode::WRITE);
-        Ok(self)
-    }
-
-    pub fn build(&mut self) -> WasiCtx {
-        assert!(!self.built);
-        let WasiCtxBuilder { ctx, .. } = mem::replace(self, Self::new());
-        self.built = true;
-        ctx
-    }
-}
-
-// Much of this mod is implemented in terms of `async` methods from the
-// wasmtime_wasi::sync module. These methods may be async in signature, however,
-// they are synchronous in implementation (always Poll::Ready on first poll)
-// and perform blocking syscalls.
-//
-// This function takes this blocking code and executes it using a dummy executor
-// to assert its immediate readiness. We tell tokio this is a blocking operation
-// with the block_in_place function.
-pub(crate) fn block_on_dummy_executor<'a, F, Fut, T>(f: F) -> Result<T, Error>
-where
-    F: FnOnce() -> Fut + Send + 'a,
-    Fut: Future<Output = Result<T, Error>>,
-    T: Send + 'static,
-{
-    tokio::task::block_in_place(move || {
-        wiggle::run_in_dummy_executor(f()).expect("wrapped operation should be synchronous")
-    })
-}
-
-#[cfg(feature = "wasmtime")]
-super::define_wasi!(async T: Send);

data/ext/cargo-vendor/wasi-common-22.0.0/tests/all/async_.rs

@@ -1,293 +0,0 @@
-use super::*;
-use test_programs_artifacts::*;
-use wasi_common::tokio::{add_to_linker, WasiCtxBuilder};
-
-foreach_preview1!(assert_test_exists);
-
-pub fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
-    let prefix = format!("wasi_tokio_{}_", exe_name);
-    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
-    Ok(tempdir)
-}
-
-async fn run(path: &str, inherit_stdio: bool) -> Result<()> {
-    let path = Path::new(path);
-    let name = path.file_stem().unwrap().to_str().unwrap();
-    let workspace = prepare_workspace(name)?;
-    let stdout = WritePipe::new_in_memory();
-    let stderr = WritePipe::new_in_memory();
-    let r = {
-        let engine = test_programs_artifacts::engine(|config| {
-            config.async_support(true);
-        });
-        let mut linker = Linker::new(&engine);
-        add_to_linker(&mut linker, |cx| cx)?;
-
-        // Create our wasi context.
-        // Additionally register any preopened directories if we have them.
-        let mut builder = WasiCtxBuilder::new();
-
-        if inherit_stdio {
-            builder.inherit_stdio();
-        } else {
-            builder
-                .stdout(Box::new(stdout.clone()))
-                .stderr(Box::new(stderr.clone()));
-        }
-        builder.arg(name)?.arg(".")?;
-        println!("preopen: {:?}", workspace);
-        let preopen_dir =
-            cap_std::fs::Dir::open_ambient_dir(workspace.path(), cap_std::ambient_authority())?;
-        builder.preopened_dir(preopen_dir, ".")?;
-        for (var, val) in test_programs_artifacts::wasi_tests_environment() {
-            builder.env(var, val)?;
-        }
-
-        let mut store = Store::new(&engine, builder.build());
-        let module = Module::from_file(&engine, path)?;
-        let instance = linker.instantiate_async(&mut store, &module).await?;
-        let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
-        start.call_async(&mut store, ()).await?;
-        Ok(())
-    };
-
-    r.map_err(move |trap: anyhow::Error| {
-        let stdout = stdout
-            .try_into_inner()
-            .expect("sole ref to stdout")
-            .into_inner();
-        if !stdout.is_empty() {
-            println!("guest stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
-        }
-        let stderr = stderr
-            .try_into_inner()
-            .expect("sole ref to stderr")
-            .into_inner();
-        if !stderr.is_empty() {
-            println!("guest stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
-        }
-        trap.context(format!(
-            "error while testing wasi-tests {} with cap-std-sync",
-            name
-        ))
-    })?;
-    Ok(())
-}
-
-// Below here is mechanical: there should be one test for every binary in
-// wasi-tests.
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_big_random_buf() {
-    run(PREVIEW1_BIG_RANDOM_BUF, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_clock_time_get() {
-    run(PREVIEW1_CLOCK_TIME_GET, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_close_preopen() {
-    run(PREVIEW1_CLOSE_PREOPEN, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_dangling_fd() {
-    run(PREVIEW1_DANGLING_FD, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_dangling_symlink() {
-    run(PREVIEW1_DANGLING_SYMLINK, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_directory_seek() {
-    run(PREVIEW1_DIRECTORY_SEEK, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_dir_fd_op_failures() {
-    run(PREVIEW1_DIR_FD_OP_FAILURES, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_fd_advise() {
-    run(PREVIEW1_FD_ADVISE, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_fd_filestat_get() {
-    run(PREVIEW1_FD_FILESTAT_GET, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_fd_filestat_set() {
-    run(PREVIEW1_FD_FILESTAT_SET, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_fd_flags_set() {
-    run(PREVIEW1_FD_FLAGS_SET, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_fd_readdir() {
-    run(PREVIEW1_FD_READDIR, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_file_allocate() {
-    run(PREVIEW1_FILE_ALLOCATE, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_file_pread_pwrite() {
-    run(PREVIEW1_FILE_PREAD_PWRITE, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_file_read_write() {
-    run(PREVIEW1_FILE_READ_WRITE, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_file_seek_tell() {
-    run(PREVIEW1_FILE_SEEK_TELL, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_file_truncation() {
-    run(PREVIEW1_FILE_TRUNCATION, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_file_unbuffered_write() {
-    run(PREVIEW1_FILE_UNBUFFERED_WRITE, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_interesting_paths() {
-    run(PREVIEW1_INTERESTING_PATHS, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_regular_file_isatty() {
-    run(PREVIEW1_REGULAR_FILE_ISATTY, false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_nofollow_errors() {
-    run(PREVIEW1_NOFOLLOW_ERRORS, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_overwrite_preopen() {
-    run(PREVIEW1_OVERWRITE_PREOPEN, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_exists() {
-    run(PREVIEW1_PATH_EXISTS, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_filestat() {
-    run(PREVIEW1_PATH_FILESTAT, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_link() {
-    run(PREVIEW1_PATH_LINK, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_open_create_existing() {
-    run(PREVIEW1_PATH_OPEN_CREATE_EXISTING, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_open_read_write() {
-    run(PREVIEW1_PATH_OPEN_READ_WRITE, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_open_dirfd_not_dir() {
-    run(PREVIEW1_PATH_OPEN_DIRFD_NOT_DIR, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_open_missing() {
-    run(PREVIEW1_PATH_OPEN_MISSING, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_open_nonblock() {
-    run(PREVIEW1_PATH_OPEN_NONBLOCK, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_rename_dir_trailing_slashes() {
-    run(PREVIEW1_PATH_RENAME_DIR_TRAILING_SLASHES, true)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_rename() {
-    run(PREVIEW1_PATH_RENAME, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_symlink_trailing_slashes() {
-    run(PREVIEW1_PATH_SYMLINK_TRAILING_SLASHES, true)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_poll_oneoff_files() {
-    run(PREVIEW1_POLL_ONEOFF_FILES, false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_poll_oneoff_stdio() {
-    run(PREVIEW1_POLL_ONEOFF_STDIO, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_readlink() {
-    run(PREVIEW1_READLINK, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_remove_directory() {
-    run(PREVIEW1_REMOVE_DIRECTORY, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_remove_nonempty_directory() {
-    run(PREVIEW1_REMOVE_NONEMPTY_DIRECTORY, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_renumber() {
-    run(PREVIEW1_RENUMBER, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_sched_yield() {
-    run(PREVIEW1_SCHED_YIELD, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_stdio() {
-    run(PREVIEW1_STDIO, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_stdio_isatty() {
-    // Only a valid test if the host executable's stdio is a terminal:
-    if test_programs_artifacts::stdio_is_terminal() {
-        // Inherit stdio, test asserts it is a tty:
-        run(PREVIEW1_STDIO_ISATTY, true).await.unwrap()
-    }
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_stdio_not_isatty() {
-    // Don't inherit stdio, test asserts each is not tty:
-    run(PREVIEW1_STDIO_NOT_ISATTY, false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_symlink_create() {
-    run(PREVIEW1_SYMLINK_CREATE, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_symlink_filestat() {
-    run(PREVIEW1_SYMLINK_FILESTAT, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_symlink_loop() {
-    run(PREVIEW1_SYMLINK_LOOP, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_unlink_file_trailing_slashes() {
-    run(PREVIEW1_UNLINK_FILE_TRAILING_SLASHES, true)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_open_preopen() {
-    run(PREVIEW1_PATH_OPEN_PREOPEN, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_unicode_output() {
-    run(PREVIEW1_UNICODE_OUTPUT, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_file_write() {
-    run(PREVIEW1_FILE_WRITE, true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn preview1_path_open_lots() {
-    run(PREVIEW1_PATH_OPEN_LOTS, true).await.unwrap()
-}