Update wasmtime/wasm-tools dependencies

This updates the Wasmtime dependency from 29.0.1 to 32.0.0 released
today. Changes here are mostly around WASI APIs and a few minor
differences here and there. Most updates were mechanical.

Additionally this updates wasm-tools dependencies to their latest
229 versions. This is mostly to just keep things up-to-date as opposed
to having a burning need to get any one particular update.

Signed-off-by: Alex Crichton <[email protected]>

Author: alexcrichton

Cargo.lock

@@ -147,20 +147,20 @@ toml = "0.8"
 tracing = { version = "0.1", features = ["log"] }
 tracing-opentelemetry = { version = "0.29", default-features = false, features = ["metrics"] }
 url = "2"
-wasi-common-preview1 = { version = "25.0.0", package = "wasi-common", features = [
+wasi-common-preview1 = { version = "32.0.0", package = "wasi-common", features = [
   "tokio",
 ] }
 wasm-pkg-client = "0.10"
 wasm-pkg-common = "0.10"
-wasmtime = "29.0.1"
-wasmtime-wasi = "29.0.1"
-wasmtime-wasi-http = "29.0.1"
+wasmtime = "32.0.0"
+wasmtime-wasi = "32.0.0"
+wasmtime-wasi-http = "32.0.0"
 
-wasm-encoder = "0.227"
-wasm-metadata = "0.227"
-wasmparser = "0.227"
-wit-component = "0.227"
-wit-parser = "0.227"
+wasm-encoder = "0.229"
+wasm-metadata = "0.229"
+wasmparser = "0.229"
+wit-component = "0.229"
+wit-parser = "0.229"
 
 spin-componentize = { path = "crates/componentize" }
 

Cargo.toml

@@ -9,6 +9,7 @@ use spin_factor_outbound_networking::{ComponentTlsConfigs, OutboundAllowedHosts}
 use spin_factors::{wasmtime::component::ResourceTable, RuntimeFactorsInstanceState};
 use tokio::{net::TcpStream, time::timeout};
 use tracing::{field::Empty, instrument, Instrument};
+use wasmtime_wasi::{IoImpl, IoView};
 use wasmtime_wasi_http::{
     bindings::http::types::ErrorCode,
     body::HyperOutgoingBody,
@@ -34,7 +35,7 @@ pub(crate) fn add_to_linker<T: Send + 'static>(
     let get_data_with_table = ctx.get_data_with_table_fn();
     let closure = type_annotate(move |data| {
         let (state, table) = get_data_with_table(data);
-        WasiHttpImpl(WasiHttpImplInner { state, table })
+        WasiHttpImpl(IoImpl(WasiHttpImplInner { state, table }))
     });
     let linker = ctx.linker();
     wasmtime_wasi_http::bindings::http::outgoing_handler::add_to_linker_get_host(linker, closure)?;
@@ -51,7 +52,7 @@ impl OutboundHttpFactor {
         runtime_instance_state: &mut impl RuntimeFactorsInstanceState,
     ) -> Option<WasiHttpImpl<impl WasiHttpView + '_>> {
         let (state, table) = runtime_instance_state.get_with_table::<OutboundHttpFactor>()?;
-        Some(WasiHttpImpl(WasiHttpImplInner { state, table }))
+        Some(WasiHttpImpl(IoImpl(WasiHttpImplInner { state, table })))
     }
 }
 
@@ -60,15 +61,17 @@ pub(crate) struct WasiHttpImplInner<'a> {
     table: &'a mut ResourceTable,
 }
 
+impl IoView for WasiHttpImplInner<'_> {
+    fn table(&mut self) -> &mut ResourceTable {
+        self.table
+    }
+}
+
 impl WasiHttpView for WasiHttpImplInner<'_> {
     fn ctx(&mut self) -> &mut WasiHttpCtx {
         &mut self.state.wasi_http_ctx
     }
 
-    fn table(&mut self) -> &mut ResourceTable {
-        self.table
-    }
-
     #[instrument(
         name = "spin_outbound_http.send_request",
         skip_all,

crates/factor-outbound-http/src/wasi.rs

@@ -3,11 +3,9 @@ use std::sync::{Arc, Mutex};
 
 use async_trait::async_trait;
 use spin_factors::anyhow;
-use wasmtime_wasi::{
-    HostInputStream, HostOutputStream, StdinStream, StdoutStream, StreamError, Subscribe,
-};
+use wasmtime_wasi::{InputStream, OutputStream, Pollable, StdinStream, StdoutStream, StreamError};
 
-/// A [`HostOutputStream`] that writes to a `Write` type.
+/// A [`OutputStream`] that writes to a `Write` type.
 ///
 /// `StdinStream::stream` and `StdoutStream::new` can be called more than once in components
 /// which are composed of multiple subcomponents, since each subcomponent will potentially want
@@ -32,7 +30,7 @@ impl<T> Clone for PipedWriteStream<T> {
     }
 }
 
-impl<T: Write + Send + Sync + 'static> HostOutputStream for PipedWriteStream<T> {
+impl<T: Write + Send + Sync + 'static> OutputStream for PipedWriteStream<T> {
     fn write(&mut self, bytes: bytes::Bytes) -> Result<(), StreamError> {
         self.0
             .lock()
@@ -55,7 +53,7 @@ impl<T: Write + Send + Sync + 'static> HostOutputStream for PipedWriteStream<T>
 }
 
 impl<T: Write + Send + Sync + 'static> StdoutStream for PipedWriteStream<T> {
-    fn stream(&self) -> Box<dyn HostOutputStream> {
+    fn stream(&self) -> Box<dyn OutputStream> {
         Box::new(self.clone())
     }
 
@@ -65,11 +63,11 @@ impl<T: Write + Send + Sync + 'static> StdoutStream for PipedWriteStream<T> {
 }
 
 #[async_trait]
-impl<T: Write + Send + Sync + 'static> Subscribe for PipedWriteStream<T> {
+impl<T: Write + Send + Sync + 'static> Pollable for PipedWriteStream<T> {
     async fn ready(&mut self) {}
 }
 
-/// A [`HostInputStream`] that reads to a `Read` type.
+/// A [`InputStream`] that reads to a `Read` type.
 ///
 /// See [`PipedWriteStream`] for more information on why this is synchronous.
 pub struct PipeReadStream<T> {
@@ -95,7 +93,7 @@ impl<T> Clone for PipeReadStream<T> {
     }
 }
 
-impl<T: Read + Send + Sync + 'static> HostInputStream for PipeReadStream<T> {
+impl<T: Read + Send + Sync + 'static> InputStream for PipeReadStream<T> {
     fn read(&mut self, size: usize) -> wasmtime_wasi::StreamResult<bytes::Bytes> {
         let size = size.min(self.buffer.len());
 
@@ -105,18 +103,21 @@ impl<T: Read + Send + Sync + 'static> HostInputStream for PipeReadStream<T> {
             .unwrap()
             .read(&mut self.buffer[..size])
             .map_err(|e| StreamError::LastOperationFailed(anyhow::anyhow!(e)))?;
+        if count == 0 {
+            return Err(wasmtime_wasi::StreamError::Closed);
+        }
 
         Ok(bytes::Bytes::copy_from_slice(&self.buffer[..count]))
     }
 }
 
 #[async_trait]
-impl<T: Read + Send + Sync + 'static> Subscribe for PipeReadStream<T> {
+impl<T: Read + Send + Sync + 'static> Pollable for PipeReadStream<T> {
     async fn ready(&mut self) {}
 }
 
 impl<T: Read + Send + Sync + 'static> StdinStream for PipeReadStream<T> {
-    fn stream(&self) -> Box<dyn HostInputStream> {
+    fn stream(&self) -> Box<dyn InputStream> {
         Box::new(self.clone())
     }
 

crates/factor-wasi/src/io.rs

@@ -16,8 +16,8 @@ use spin_factors::{
     RuntimeFactors, RuntimeFactorsInstanceState,
 };
 use wasmtime_wasi::{
-    DirPerms, FilePerms, ResourceTable, StdinStream, StdoutStream, WasiCtx, WasiCtxBuilder,
-    WasiImpl, WasiView,
+    DirPerms, FilePerms, IoImpl, IoView, ResourceTable, StdinStream, StdoutStream, WasiCtx,
+    WasiCtxBuilder, WasiImpl, WasiView,
 };
 
 pub use wasmtime_wasi::SocketAddrUse;
@@ -37,10 +37,10 @@ impl WasiFactor {
         runtime_instance_state: &mut impl RuntimeFactorsInstanceState,
     ) -> Option<WasiImpl<impl WasiView + '_>> {
         let (state, table) = runtime_instance_state.get_with_table::<WasiFactor>()?;
-        Some(WasiImpl(WasiImplInner {
+        Some(WasiImpl(IoImpl(WasiImplInner {
             ctx: &mut state.ctx,
             table,
-        }))
+        })))
     }
 }
 
@@ -50,52 +50,63 @@ impl Factor for WasiFactor {
     type InstanceBuilder = InstanceBuilder;
 
     fn init<T: Send + 'static>(&mut self, mut ctx: InitContext<T, Self>) -> anyhow::Result<()> {
-        fn type_annotate<T, F>(f: F) -> F
+        fn type_annotate_wasi<T, F>(f: F) -> F
         where
             F: Fn(&mut T) -> WasiImpl<WasiImplInner>,
         {
             f
         }
+        fn type_annotate_io<T, F>(f: F) -> F
+        where
+            F: Fn(&mut T) -> IoImpl<WasiImplInner>,
+        {
+            f
+        }
         let get_data_with_table = ctx.get_data_with_table_fn();
-        let closure = type_annotate(move |data| {
+        let io_closure = type_annotate_io(move |data| {
             let (state, table) = get_data_with_table(data);
-            WasiImpl(WasiImplInner {
+            IoImpl(WasiImplInner {
                 ctx: &mut state.ctx,
                 table,
             })
         });
+        let wasi_closure = type_annotate_wasi(move |data| WasiImpl(io_closure(data)));
         let linker = ctx.linker();
         use wasmtime_wasi::bindings;
-        bindings::clocks::wall_clock::add_to_linker_get_host(linker, closure)?;
-        bindings::clocks::monotonic_clock::add_to_linker_get_host(linker, closure)?;
-        bindings::filesystem::types::add_to_linker_get_host(linker, closure)?;
-        bindings::filesystem::preopens::add_to_linker_get_host(linker, closure)?;
-        bindings::io::error::add_to_linker_get_host(linker, closure)?;
-        bindings::io::poll::add_to_linker_get_host(linker, closure)?;
-        bindings::io::streams::add_to_linker_get_host(linker, closure)?;
-        bindings::random::random::add_to_linker_get_host(linker, closure)?;
-        bindings::random::insecure::add_to_linker_get_host(linker, closure)?;
-        bindings::random::insecure_seed::add_to_linker_get_host(linker, closure)?;
-        bindings::cli::exit::add_to_linker_get_host(linker, &Default::default(), closure)?;
-        bindings::cli::environment::add_to_linker_get_host(linker, closure)?;
-        bindings::cli::stdin::add_to_linker_get_host(linker, closure)?;
-        bindings::cli::stdout::add_to_linker_get_host(linker, closure)?;
-        bindings::cli::stderr::add_to_linker_get_host(linker, closure)?;
-        bindings::cli::terminal_input::add_to_linker_get_host(linker, closure)?;
-        bindings::cli::terminal_output::add_to_linker_get_host(linker, closure)?;
-        bindings::cli::terminal_stdin::add_to_linker_get_host(linker, closure)?;
-        bindings::cli::terminal_stdout::add_to_linker_get_host(linker, closure)?;
-        bindings::cli::terminal_stderr::add_to_linker_get_host(linker, closure)?;
-        bindings::sockets::tcp::add_to_linker_get_host(linker, closure)?;
-        bindings::sockets::tcp_create_socket::add_to_linker_get_host(linker, closure)?;
-        bindings::sockets::udp::add_to_linker_get_host(linker, closure)?;
-        bindings::sockets::udp_create_socket::add_to_linker_get_host(linker, closure)?;
-        bindings::sockets::instance_network::add_to_linker_get_host(linker, closure)?;
-        bindings::sockets::network::add_to_linker_get_host(linker, &Default::default(), closure)?;
-        bindings::sockets::ip_name_lookup::add_to_linker_get_host(linker, closure)?;
-
-        wasi_2023_10_18::add_to_linker(linker, closure)?;
-        wasi_2023_11_10::add_to_linker(linker, closure)?;
+        bindings::clocks::wall_clock::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::clocks::monotonic_clock::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::filesystem::types::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::filesystem::preopens::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::io::error::add_to_linker_get_host(linker, io_closure)?;
+        bindings::io::poll::add_to_linker_get_host(linker, io_closure)?;
+        bindings::io::streams::add_to_linker_get_host(linker, io_closure)?;
+        bindings::random::random::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::random::insecure::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::random::insecure_seed::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::cli::exit::add_to_linker_get_host(linker, &Default::default(), wasi_closure)?;
+        bindings::cli::environment::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::cli::stdin::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::cli::stdout::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::cli::stderr::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::cli::terminal_input::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::cli::terminal_output::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::cli::terminal_stdin::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::cli::terminal_stdout::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::cli::terminal_stderr::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::sockets::tcp::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::sockets::tcp_create_socket::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::sockets::udp::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::sockets::udp_create_socket::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::sockets::instance_network::add_to_linker_get_host(linker, wasi_closure)?;
+        bindings::sockets::network::add_to_linker_get_host(
+            linker,
+            &Default::default(),
+            wasi_closure,
+        )?;
+        bindings::sockets::ip_name_lookup::add_to_linker_get_host(linker, wasi_closure)?;
+
+        wasi_2023_10_18::add_to_linker(linker, wasi_closure)?;
+        wasi_2023_11_10::add_to_linker(linker, wasi_closure)?;
 
         Ok(())
     }
@@ -288,7 +299,9 @@ impl WasiView for WasiImplInner<'_> {
     fn ctx(&mut self) -> &mut WasiCtx {
         self.ctx
     }
+}
 
+impl IoView for WasiImplInner<'_> {
     fn table(&mut self) -> &mut ResourceTable {
         self.table
     }