wasmtime 15.0.1 → 16.0.0

data/ext/cargo-vendor/wasmtime-wasi-16.0.0/src/preview2/table.rs

@@ -0,0 +1,337 @@
+use std::any::Any;
+use std::collections::{BTreeSet, HashMap};
+use wasmtime::component::Resource;
+
+#[derive(thiserror::Error, Debug)]
+pub enum TableError {
+    #[error("table has no free keys")]
+    Full,
+    #[error("value not present")]
+    NotPresent,
+    #[error("value is of another type")]
+    WrongType,
+    #[error("entry still has children")]
+    HasChildren,
+}
+
+/// The `Table` type is designed to map u32 handles to resources. The table is now part of the
+/// public interface to a `WasiCtx` - it is reference counted so that it can be shared beyond a
+/// `WasiCtx` with other WASI proposals (e.g. `wasi-crypto` and `wasi-nn`) to manage their
+/// resources. Elements in the `Table` are `Any` typed.
+///
+/// The `Table` type is intended to model how the Interface Types concept of Resources is shaping
+/// up. Right now it is just an approximation.
+#[derive(Debug)]
+pub struct Table {
+    entries: Vec<Entry>,
+    free_head: Option<usize>,
+}
+
+#[derive(Debug)]
+enum Entry {
+    Free { next: Option<usize> },
+    Occupied { entry: TableEntry },
+}
+
+impl Entry {
+    pub fn occupied(&self) -> Option<&TableEntry> {
+        match self {
+            Self::Occupied { entry } => Some(entry),
+            Self::Free { .. } => None,
+        }
+    }
+
+    pub fn occupied_mut(&mut self) -> Option<&mut TableEntry> {
+        match self {
+            Self::Occupied { entry } => Some(entry),
+            Self::Free { .. } => None,
+        }
+    }
+}
+
+/// This structure tracks parent and child relationships for a given table entry.
+///
+/// Parents and children are referred to by table index. We maintain the
+/// following invariants to prevent orphans and cycles:
+/// * parent can only be assigned on creating the entry.
+/// * parent, if some, must exist when creating the entry.
+/// * whenever a child is created, its index is added to children.
+/// * whenever a child is deleted, its index is removed from children.
+/// * an entry with children may not be deleted.
+#[derive(Debug)]
+struct TableEntry {
+    /// The entry in the table, as a boxed dynamically-typed object
+    entry: Box<dyn Any + Send + Sync>,
+    /// The index of the parent of this entry, if it has one.
+    parent: Option<u32>,
+    /// The indicies of any children of this entry.
+    children: BTreeSet<u32>,
+}
+
+impl TableEntry {
+    fn new(entry: Box<dyn Any + Send + Sync>, parent: Option<u32>) -> Self {
+        Self {
+            entry,
+            parent,
+            children: BTreeSet::new(),
+        }
+    }
+    fn add_child(&mut self, child: u32) {
+        debug_assert!(!self.children.contains(&child));
+        self.children.insert(child);
+    }
+    fn remove_child(&mut self, child: u32) {
+        let was_removed = self.children.remove(&child);
+        debug_assert!(was_removed);
+    }
+}
+
+impl Table {
+    /// Create an empty table
+    pub fn new() -> Self {
+        Table {
+            entries: Vec::new(),
+            free_head: None,
+        }
+    }
+
+    /// Create an empty table with at least the specified capacity.
+    pub fn with_capacity(capacity: usize) -> Self {
+        Table {
+            entries: Vec::with_capacity(capacity),
+            free_head: None,
+        }
+    }
+
+    /// Inserts a new value `T` into this table, returning a corresponding
+    /// `Resource<T>` which can be used to refer to it after it was inserted.
+    pub fn push<T>(&mut self, entry: T) -> Result<Resource<T>, TableError>
+    where
+        T: Send + Sync + 'static,
+    {
+        let idx = self.push_(TableEntry::new(Box::new(entry), None))?;
+        Ok(Resource::new_own(idx))
+    }
+
+    /// Pop an index off of the free list, if it's not empty.
+    fn pop_free_list(&mut self) -> Option<usize> {
+        if let Some(ix) = self.free_head {
+            // Advance free_head to the next entry if one is available.
+            match &self.entries[ix] {
+                Entry::Free { next } => self.free_head = *next,
+                Entry::Occupied { .. } => unreachable!(),
+            }
+            Some(ix)
+        } else {
+            None
+        }
+    }
+
+    /// Free an entry in the table, returning its [`TableEntry`]. Add the index to the free list.
+    fn free_entry(&mut self, ix: usize) -> TableEntry {
+        let entry = match std::mem::replace(
+            &mut self.entries[ix],
+            Entry::Free {
+                next: self.free_head,
+            },
+        ) {
+            Entry::Occupied { entry } => entry,
+            Entry::Free { .. } => unreachable!(),
+        };
+
+        self.free_head = Some(ix);
+
+        entry
+    }
+
+    /// Push a new entry into the table, returning its handle. This will prefer to use free entries
+    /// if they exist, falling back on pushing new entries onto the end of the table.
+    fn push_(&mut self, e: TableEntry) -> Result<u32, TableError> {
+        if let Some(free) = self.pop_free_list() {
+            self.entries[free] = Entry::Occupied { entry: e };
+            Ok(free as u32)
+        } else {
+            let ix = self
+                .entries
+                .len()
+                .try_into()
+                .map_err(|_| TableError::Full)?;
+            self.entries.push(Entry::Occupied { entry: e });
+            Ok(ix)
+        }
+    }
+
+    fn occupied(&self, key: u32) -> Result<&TableEntry, TableError> {
+        self.entries
+            .get(key as usize)
+            .and_then(Entry::occupied)
+            .ok_or(TableError::NotPresent)
+    }
+
+    fn occupied_mut(&mut self, key: u32) -> Result<&mut TableEntry, TableError> {
+        self.entries
+            .get_mut(key as usize)
+            .and_then(Entry::occupied_mut)
+            .ok_or(TableError::NotPresent)
+    }
+
+    /// Insert a resource at the next available index, and track that it has a
+    /// parent resource.
+    ///
+    /// The parent must exist to create a child. All children resources must
+    /// be destroyed before a parent can be destroyed - otherwise [`Table::delete`]
+    /// will fail with [`TableError::HasChildren`].
+    ///
+    /// Parent-child relationships are tracked inside the table to ensure that
+    /// a parent resource is not deleted while it has live children. This
+    /// allows child resources to hold "references" to a parent by table
+    /// index, to avoid needing e.g. an `Arc<Mutex<parent>>` and the associated
+    /// locking overhead and design issues, such as child existence extending
+    /// lifetime of parent referent even after parent resource is destroyed,
+    /// possibility for deadlocks.
+    ///
+    /// Parent-child relationships may not be modified once created. There
+    /// is no way to observe these relationships through the [`Table`] methods
+    /// except for erroring on deletion, or the [`std::fmt::Debug`] impl.
+    pub fn push_child<T, U>(
+        &mut self,
+        entry: T,
+        parent: &Resource<U>,
+    ) -> Result<Resource<T>, TableError>
+    where
+        T: Send + Sync + 'static,
+        U: 'static,
+    {
+        let parent = parent.rep();
+        self.occupied(parent)?;
+        let child = self.push_(TableEntry::new(Box::new(entry), Some(parent)))?;
+        self.occupied_mut(parent)?.add_child(child);
+        Ok(Resource::new_own(child))
+    }
+
+    /// Get an immutable reference to a resource of a given type at a given
+    /// index.
+    ///
+    /// Multiple shared references can be borrowed at any given time.
+    pub fn get<T: Any + Sized>(&self, key: &Resource<T>) -> Result<&T, TableError> {
+        self.get_(key.rep())?
+            .downcast_ref()
+            .ok_or(TableError::WrongType)
+    }
+
+    fn get_(&self, key: u32) -> Result<&dyn Any, TableError> {
+        let r = self.occupied(key)?;
+        Ok(&*r.entry)
+    }
+
+    /// Get an mutable reference to a resource of a given type at a given
+    /// index.
+    pub fn get_mut<T: Any + Sized>(&mut self, key: &Resource<T>) -> Result<&mut T, TableError> {
+        self.get_any_mut(key.rep())?
+            .downcast_mut()
+            .ok_or(TableError::WrongType)
+    }
+
+    /// Returns the raw `Any` at the `key` index provided.
+    pub fn get_any_mut(&mut self, key: u32) -> Result<&mut dyn Any, TableError> {
+        let r = self.occupied_mut(key)?;
+        Ok(&mut *r.entry)
+    }
+
+    /// Same as `delete`, but typed
+    pub fn delete<T>(&mut self, resource: Resource<T>) -> Result<T, TableError>
+    where
+        T: Any,
+    {
+        debug_assert!(resource.owned());
+        let entry = self.delete_entry(resource.rep())?;
+        match entry.entry.downcast() {
+            Ok(t) => Ok(*t),
+            Err(_e) => Err(TableError::WrongType),
+        }
+    }
+
+    fn delete_entry(&mut self, key: u32) -> Result<TableEntry, TableError> {
+        if !self.occupied(key)?.children.is_empty() {
+            return Err(TableError::HasChildren);
+        }
+        let e = self.free_entry(key as usize);
+        if let Some(parent) = e.parent {
+            // Remove deleted resource from parent's child list.
+            // Parent must still be present because it cant be deleted while still having
+            // children:
+            self.occupied_mut(parent)
+                .expect("missing parent")
+                .remove_child(key);
+        }
+        Ok(e)
+    }
+
+    /// Zip the values of the map with mutable references to table entries corresponding to each
+    /// key. As the keys in the [HashMap] are unique, this iterator can give mutable references
+    /// with the same lifetime as the mutable reference to the [Table].
+    pub fn iter_entries<'a, T>(
+        &'a mut self,
+        map: HashMap<u32, T>,
+    ) -> impl Iterator<Item = (Result<&'a mut dyn Any, TableError>, T)> {
+        map.into_iter().map(move |(k, v)| {
+            let item = self
+                .occupied_mut(k)
+                .map(|e| Box::as_mut(&mut e.entry))
+                // Safety: extending the lifetime of the mutable reference.
+                .map(|item| unsafe { &mut *(item as *mut dyn Any) });
+            (item, v)
+        })
+    }
+
+    /// Iterate over all children belonging to the provided parent
+    pub fn iter_children<T>(
+        &self,
+        parent: &Resource<T>,
+    ) -> Result<impl Iterator<Item = &(dyn Any + Send + Sync)>, TableError>
+    where
+        T: 'static,
+    {
+        let parent_entry = self.occupied(parent.rep())?;
+        Ok(parent_entry.children.iter().map(|child_index| {
+            let child = self.occupied(*child_index).expect("missing child");
+            child.entry.as_ref()
+        }))
+    }
+}
+
+impl Default for Table {
+    fn default() -> Self {
+        Table::new()
+    }
+}
+
+#[test]
+pub fn test_free_list() {
+    let mut table = Table::new();
+
+    let x = table.push(()).unwrap();
+    assert_eq!(x.rep(), 0);
+
+    let y = table.push(()).unwrap();
+    assert_eq!(y.rep(), 1);
+
+    // Deleting x should put it on the free list, so the next entry should have the same rep.
+    table.delete(x).unwrap();
+    let x = table.push(()).unwrap();
+    assert_eq!(x.rep(), 0);
+
+    // Deleting x and then y should yield indices 1 and then 0 for new entries.
+    table.delete(x).unwrap();
+    table.delete(y).unwrap();
+
+    let y = table.push(()).unwrap();
+    assert_eq!(y.rep(), 1);
+
+    let x = table.push(()).unwrap();
+    assert_eq!(x.rep(), 0);
+
+    // As the free list is empty, this entry will have a new id.
+    let x = table.push(()).unwrap();
+    assert_eq!(x.rep(), 2);
+}

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

@@ -0,0 +1,218 @@
+use anyhow::Result;
+use cap_std::ambient_authority;
+use cap_std::fs::Dir;
+use std::io::Write;
+use std::sync::Mutex;
+use std::time::Duration;
+use wasmtime::component::{Component, Linker};
+use wasmtime::{Config, Engine, Store};
+use wasmtime_wasi::preview2::bindings::wasi::clocks::wall_clock;
+use wasmtime_wasi::preview2::bindings::wasi::filesystem::types as filesystem;
+use wasmtime_wasi::preview2::command::{add_to_linker, Command};
+use wasmtime_wasi::preview2::{
+    self, DirPerms, FilePerms, HostMonotonicClock, HostWallClock, Table, WasiCtx, WasiCtxBuilder,
+    WasiView,
+};
+
+struct CommandCtx {
+    table: Table,
+    wasi: WasiCtx,
+}
+
+impl WasiView for CommandCtx {
+    fn table(&self) -> &Table {
+        &self.table
+    }
+    fn table_mut(&mut self) -> &mut Table {
+        &mut self.table
+    }
+    fn ctx(&self) -> &WasiCtx {
+        &self.wasi
+    }
+    fn ctx_mut(&mut self) -> &mut WasiCtx {
+        &mut self.wasi
+    }
+}
+
+use test_programs_artifacts::*;
+
+foreach_api!(assert_test_exists);
+
+async fn instantiate(path: &str, ctx: CommandCtx) -> Result<(Store<CommandCtx>, Command)> {
+    let mut config = Config::new();
+    config.async_support(true).wasm_component_model(true);
+    let engine = Engine::new(&config)?;
+    let mut linker = Linker::new(&engine);
+    add_to_linker(&mut linker)?;
+
+    let mut store = Store::new(&engine, ctx);
+    let component = Component::from_file(&engine, path)?;
+    let (command, _instance) = Command::instantiate_async(&mut store, &component, &linker).await?;
+    Ok((store, command))
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn api_time() -> Result<()> {
+    struct FakeWallClock;
+
+    impl HostWallClock for FakeWallClock {
+        fn resolution(&self) -> Duration {
+            Duration::from_secs(1)
+        }
+
+        fn now(&self) -> Duration {
+            Duration::new(1431648000, 100)
+        }
+    }
+
+    struct FakeMonotonicClock {
+        now: Mutex<u64>,
+    }
+
+    impl HostMonotonicClock for FakeMonotonicClock {
+        fn resolution(&self) -> u64 {
+            1_000_000_000
+        }
+
+        fn now(&self) -> u64 {
+            let mut now = self.now.lock().unwrap();
+            let then = *now;
+            *now += 42 * 1_000_000_000;
+            then
+        }
+    }
+
+    let table = Table::new();
+    let wasi = WasiCtxBuilder::new()
+        .monotonic_clock(FakeMonotonicClock { now: Mutex::new(0) })
+        .wall_clock(FakeWallClock)
+        .build();
+
+    let (mut store, command) = instantiate(API_TIME_COMPONENT, CommandCtx { table, wasi }).await?;
+
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)
+        .await?
+        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn api_read_only() -> Result<()> {
+    let dir = tempfile::tempdir()?;
+
+    std::fs::File::create(dir.path().join("bar.txt"))?.write_all(b"And stood awhile in thought")?;
+    std::fs::create_dir(dir.path().join("sub"))?;
+
+    let table = Table::new();
+    let open_dir = Dir::open_ambient_dir(dir.path(), ambient_authority())?;
+    let wasi = WasiCtxBuilder::new()
+        .preopened_dir(open_dir, DirPerms::READ, FilePerms::READ, "/")
+        .build();
+
+    let (mut store, command) =
+        instantiate(API_READ_ONLY_COMPONENT, CommandCtx { table, wasi }).await?;
+
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)
+        .await?
+        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
+}
+
+// This is tested in the wasi-http crate, but need to satisfy the `foreach_api!`
+// macro above.
+#[allow(dead_code)]
+fn api_proxy() {}
+
+// This is tested in the wasi-http crate, but need to satisfy the `foreach_api!`
+// macro above.
+#[allow(dead_code)]
+fn api_proxy_streaming() {}
+
+wasmtime::component::bindgen!({
+    world: "test-reactor",
+    async: true,
+    with: {
+       "wasi:io/streams": preview2::bindings::io::streams,
+       "wasi:filesystem/types": preview2::bindings::filesystem::types,
+       "wasi:filesystem/preopens": preview2::bindings::filesystem::preopens,
+       "wasi:cli/environment": preview2::bindings::cli::environment,
+       "wasi:cli/exit": preview2::bindings::cli::exit,
+       "wasi:cli/stdin": preview2::bindings::cli::stdin,
+       "wasi:cli/stdout": preview2::bindings::cli::stdout,
+       "wasi:cli/stderr": preview2::bindings::cli::stderr,
+       "wasi:cli/terminal_input": preview2::bindings::cli::terminal_input,
+       "wasi:cli/terminal_output": preview2::bindings::cli::terminal_output,
+       "wasi:cli/terminal_stdin": preview2::bindings::cli::terminal_stdin,
+       "wasi:cli/terminal_stdout": preview2::bindings::cli::terminal_stdout,
+       "wasi:cli/terminal_stderr": preview2::bindings::cli::terminal_stderr,
+    },
+    ownership: Borrowing {
+        duplicate_if_necessary: false
+    }
+});
+
+#[test_log::test(tokio::test)]
+async fn api_reactor() -> Result<()> {
+    let table = Table::new();
+    let wasi = WasiCtxBuilder::new().env("GOOD_DOG", "gussie").build();
+
+    let mut config = Config::new();
+    config.async_support(true).wasm_component_model(true);
+    let engine = Engine::new(&config)?;
+    let mut linker = Linker::new(&engine);
+    add_to_linker(&mut linker)?;
+
+    let mut store = Store::new(&engine, CommandCtx { table, wasi });
+    let component = Component::from_file(&engine, API_REACTOR_COMPONENT)?;
+    let (reactor, _instance) =
+        TestReactor::instantiate_async(&mut store, &component, &linker).await?;
+
+    // Show that integration with the WASI context is working - the guest will
+    // interpolate $GOOD_DOG to gussie here using the environment:
+    let r = reactor
+        .call_add_strings(&mut store, &["hello", "$GOOD_DOG"])
+        .await?;
+    assert_eq!(r, 2);
+
+    let contents = reactor.call_get_strings(&mut store).await?;
+    assert_eq!(contents, &["hello", "gussie"]);
+
+    // Show that we can pass in a resource type whose impls are defined in the
+    // `host` and `wasi-common` crate.
+    // Note, this works because of the add_to_linker invocations using the
+    // `host` crate for `streams`, not because of `with` in the bindgen macro.
+    let writepipe = preview2::pipe::MemoryOutputPipe::new(4096);
+    let stream: preview2::OutputStream = Box::new(writepipe.clone());
+    let table_ix = store.data_mut().table_mut().push(stream)?;
+    let r = reactor.call_write_strings_to(&mut store, table_ix).await?;
+    assert_eq!(r, Ok(()));
+
+    assert_eq!(writepipe.contents().as_ref(), b"hellogussie");
+
+    // Show that the `with` invocation in the macro means we get to re-use the
+    // type definitions from inside the `host` crate for these structures:
+    let ds = filesystem::DescriptorStat {
+        data_access_timestamp: Some(wall_clock::Datetime {
+            nanoseconds: 123,
+            seconds: 45,
+        }),
+        data_modification_timestamp: Some(wall_clock::Datetime {
+            nanoseconds: 789,
+            seconds: 10,
+        }),
+        link_count: 0,
+        size: 0,
+        status_change_timestamp: Some(wall_clock::Datetime {
+            nanoseconds: 0,
+            seconds: 1,
+        }),
+        type_: filesystem::DescriptorType::Unknown,
+    };
+    let expected = format!("{ds:?}");
+    let got = reactor.call_pass_an_imported_record(&mut store, ds).await?;
+    assert_eq!(expected, got);
+
+    Ok(())
+}