Update to Wasmtime 33.0.0

alexcrichton · alexcrichton · commit 9e23c7d5ac6d · 2025-05-20T09:48:25.000-07:00
This commit updates Spin to Wasmtime's latest release, made today, at
33.0.0. This brings some reorganization of the `wasmtime-wasi` crate in
preparation for WASIp3 as well as some minor method renames and
refatorings when dealing with generated bindings.

Signed-off-by: Alex Crichton &lt;alex@alexcrichton.com&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -168,19 +168,19 @@ toml_edit = "0.22"
 tracing = { version = "0.1", features = ["log"] }
 url = "2"
 walkdir = "2"
-wasi-common-preview1 = { version = "32.0.0", package = "wasi-common", features = [
+wasi-common-preview1 = { version = "33.0.0", package = "wasi-common", features = [
   "tokio",
 ] }
-wasm-encoder = "0.229"
-wasm-metadata = "0.229"
+wasm-encoder = "0.230"
+wasm-metadata = "0.230"
 wasm-pkg-client = "0.10"
 wasm-pkg-common = "0.10"
-wasmparser = "0.229"
-wasmtime = "32.0.0"
-wasmtime-wasi = "32.0.0"
-wasmtime-wasi-http = "32.0.0"
-wit-component = "0.229"
-wit-parser = "0.229"
+wasmparser = "0.230"
+wasmtime = "33.0.0"
+wasmtime-wasi = "33.0.0"
+wasmtime-wasi-http = "33.0.0"
+wit-component = "0.230"
+wit-parser = "0.230"
 
 spin-componentize = { path = "crates/componentize" }
 
diff --git a/crates/componentize/src/abi_conformance/mod.rs b/crates/componentize/src/abi_conformance/mod.rs
@@ -36,9 +36,8 @@ use wasmtime::{
     component::{Component, InstancePre, Linker},
     Engine, Store,
 };
-use wasmtime_wasi::{
-    pipe::MemoryOutputPipe, IoView, ResourceTable, WasiCtx, WasiCtxBuilder, WasiView,
-};
+use wasmtime_wasi::p2::{pipe::MemoryOutputPipe, IoView, WasiCtx, WasiCtxBuilder, WasiView};
+use wasmtime_wasi::ResourceTable;
 
 pub use test_key_value::KeyValueReport;
 pub use test_llm::LlmReport;
@@ -164,7 +163,7 @@ pub async fn test(
     test_config: TestConfig,
 ) -> Result<Report> {
     let mut linker = Linker::<Context>::new(engine);
-    wasmtime_wasi::add_to_linker_async(&mut linker)?;
+    wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;
     http::add_to_linker(&mut linker, |context| &mut context.http)?;
     redis::add_to_linker(&mut linker, |context| &mut context.redis)?;
     postgres::add_to_linker(&mut linker, |context| &mut context.postgres)?;
@@ -291,8 +290,10 @@ async fn run_command(
         match store.data().test_config.invocation_style {
             InvocationStyle::InboundHttp => {
                 let func = instance
-                    .get_export(&mut *store, None, "fermyon:spin/inbound-http")
-                    .and_then(|i| instance.get_export(&mut *store, Some(&i), "handle-request"))
+                    .get_export_index(&mut *store, None, "fermyon:spin/inbound-http")
+                    .and_then(|i| {
+                        instance.get_export_index(&mut *store, Some(&i), "handle-request")
+                    })
                     .ok_or_else(|| {
                         anyhow!("no fermyon:spin/inbound-http/handle-request function was found")
                     })?;
diff --git a/crates/componentize/src/abi_conformance/test_inbound_http.rs b/crates/componentize/src/abi_conformance/test_inbound_http.rs
@@ -15,8 +15,8 @@ pub(crate) async fn test(
         let instance = pre.instantiate_async(&mut store).await?;
 
         let func = instance
-            .get_export(&mut store, None, "fermyon:spin/inbound-http")
-            .and_then(|i| instance.get_export(&mut store, Some(&i), "handle-request"))
+            .get_export_index(&mut store, None, "fermyon:spin/inbound-http")
+            .and_then(|i| instance.get_export_index(&mut store, Some(&i), "handle-request"))
             .ok_or_else(|| {
                 anyhow!("no fermyon:spin/inbound-http/handle-request function was found")
             })?;
diff --git a/crates/componentize/src/abi_conformance/test_inbound_redis.rs b/crates/componentize/src/abi_conformance/test_inbound_redis.rs
@@ -15,8 +15,8 @@ pub(crate) async fn test(
         let instance = pre.instantiate_async(&mut store).await?;
 
         let func = instance
-            .get_export(&mut store, None, "fermyon:spin/inbound-redis")
-            .and_then(|i| instance.get_export(&mut store, Some(&i), "handle-message"))
+            .get_export_index(&mut store, None, "fermyon:spin/inbound-redis")
+            .and_then(|i| instance.get_export_index(&mut store, Some(&i), "handle-message"))
             .ok_or_else(|| {
                 anyhow!("no fermyon:spin/inbound-redis/handle-message function was found")
             })?;
diff --git a/crates/componentize/src/abi_conformance/test_wasi.rs b/crates/componentize/src/abi_conformance/test_wasi.rs
@@ -19,7 +19,7 @@ use std::{
 };
 use wasmtime::{component::InstancePre, Engine};
 use wasmtime_wasi::{
-    pipe::{MemoryInputPipe, MemoryOutputPipe},
+    p2::pipe::{MemoryInputPipe, MemoryOutputPipe},
     HostWallClock,
 };
 
diff --git a/crates/componentize/src/lib.rs b/crates/componentize/src/lib.rs
@@ -254,7 +254,7 @@ mod tests {
     use std::{path::PathBuf, process};
 
     use anyhow::Context;
-    use wasmtime_wasi::pipe::MemoryOutputPipe;
+    use wasmtime_wasi::p2::pipe::MemoryOutputPipe;
 
     use {
         super::abi_conformance::{
@@ -267,10 +267,10 @@ mod tests {
             component::{Component, Linker},
             Config, Engine, Store,
         },
-        wasmtime_wasi::{
-            bindings::Command, pipe::MemoryInputPipe, IoView, ResourceTable, WasiView,
+        wasmtime_wasi::p2::{
+            bindings::Command, pipe::MemoryInputPipe, IoView, WasiCtx, WasiCtxBuilder, WasiView,
         },
-        wasmtime_wasi::{WasiCtx, WasiCtxBuilder},
+        wasmtime_wasi::ResourceTable,
     };
 
     async fn run_spin(module: &[u8]) -> Result<()> {
@@ -371,7 +371,7 @@ mod tests {
         }
 
         let mut linker = Linker::<Wasi>::new(&engine);
-        wasmtime_wasi::add_to_linker_async(&mut linker)?;
+        wasmtime_wasi::p2::add_to_linker_async(&mut linker)?;
         let mut ctx = WasiCtxBuilder::new();
         let stdout = MemoryOutputPipe::new(1024);
         ctx.stdin(MemoryInputPipe::new("So rested he by the Tumtum tree"))
diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs
@@ -55,10 +55,8 @@ impl Config {
     ///
     /// [docs]: https://docs.wasmtime.dev/cli-cache.html
     pub fn enable_cache(&mut self, config_path: &Option<PathBuf>) -> Result<()> {
-        match config_path {
-            Some(p) => self.inner.cache_config_load(p)?,
-            None => self.inner.cache_config_load_default()?,
-        };
+        self.inner
+            .cache(Some(wasmtime::Cache::from_file(config_path.as_deref())?));
 
         Ok(())
     }
diff --git a/crates/core/tests/integration_test.rs b/crates/core/tests/integration_test.rs
@@ -158,8 +158,8 @@ async fn run_test(
     let instance = instance_pre.instantiate_async(&mut store).await?;
     let func = {
         let func = instance
-            .get_export(&mut store, None, "wasi:cli/run@0.2.0")
-            .and_then(|i| instance.get_export(&mut store, Some(&i), "run"))
+            .get_export_index(&mut store, None, "wasi:cli/run@0.2.0")
+            .and_then(|i| instance.get_export_index(&mut store, Some(&i), "run"))
             .context("missing the expected 'wasi:cli/run@0.2.0/run' function")?;
         instance.get_typed_func::<(), (Result<(), ()>,)>(&mut store, &func)?
     };
diff --git a/crates/factor-outbound-http/src/wasi.rs b/crates/factor-outbound-http/src/wasi.rs
@@ -9,7 +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::p2::{IoImpl, IoView};
 use wasmtime_wasi_http::{
     bindings::http::types::ErrorCode,
     body::HyperOutgoingBody,
diff --git a/crates/factor-outbound-http/tests/factor_test.rs b/crates/factor-outbound-http/tests/factor_test.rs
@@ -7,7 +7,7 @@ use spin_factor_outbound_networking::OutboundNetworkingFactor;
 use spin_factor_variables::VariablesFactor;
 use spin_factors::{anyhow, RuntimeFactors};
 use spin_factors_test::{toml, TestEnvironment};
-use wasmtime_wasi::Pollable;
+use wasmtime_wasi::p2::Pollable;
 use wasmtime_wasi_http::{
     bindings::http::types::ErrorCode, types::OutgoingRequestConfig, WasiHttpView,
 };
diff --git a/crates/factor-outbound-networking/tests/factor_test.rs b/crates/factor-outbound-networking/tests/factor_test.rs
@@ -3,7 +3,8 @@ use spin_factor_variables::VariablesFactor;
 use spin_factor_wasi::{DummyFilesMounter, WasiFactor};
 use spin_factors::{anyhow, RuntimeFactors};
 use spin_factors_test::{toml, TestEnvironment};
-use wasmtime_wasi::{bindings::sockets::instance_network::Host, IoView, SocketAddrUse};
+use wasmtime_wasi::p2::{bindings::sockets::instance_network::Host, IoView};
+use wasmtime_wasi::SocketAddrUse;
 
 #[derive(RuntimeFactors)]
 struct TestFactors {
diff --git a/crates/factor-wasi/src/io.rs b/crates/factor-wasi/src/io.rs
@@ -3,7 +3,9 @@ use std::sync::{Arc, Mutex};
 
 use async_trait::async_trait;
 use spin_factors::anyhow;
-use wasmtime_wasi::{InputStream, OutputStream, Pollable, StdinStream, StdoutStream, StreamError};
+use wasmtime_wasi::p2::{
+    InputStream, OutputStream, Pollable, StdinStream, StdoutStream, StreamError,
+};
 
 /// A [`OutputStream`] that writes to a `Write` type.
 ///
@@ -94,7 +96,7 @@ impl<T> Clone for PipeReadStream<T> {
 }
 
 impl<T: Read + Send + Sync + 'static> InputStream for PipeReadStream<T> {
-    fn read(&mut self, size: usize) -> wasmtime_wasi::StreamResult<bytes::Bytes> {
+    fn read(&mut self, size: usize) -> wasmtime_wasi::p2::StreamResult<bytes::Bytes> {
         let size = size.min(self.buffer.len());
 
         let count = self
@@ -104,7 +106,7 @@ impl<T: Read + Send + Sync + 'static> InputStream for PipeReadStream<T> {
             .read(&mut self.buffer[..size])
             .map_err(|e| StreamError::LastOperationFailed(anyhow::anyhow!(e)))?;
         if count == 0 {
-            return Err(wasmtime_wasi::StreamError::Closed);
+            return Err(wasmtime_wasi::p2::StreamError::Closed);
         }
 
         Ok(bytes::Bytes::copy_from_slice(&self.buffer[..count]))
diff --git a/crates/factor-wasi/src/lib.rs b/crates/factor-wasi/src/lib.rs
@@ -15,10 +15,10 @@ use spin_factors::{
     anyhow, AppComponent, Factor, FactorInstanceBuilder, InitContext, PrepareContext,
     RuntimeFactors, RuntimeFactorsInstanceState,
 };
-use wasmtime_wasi::{
-    DirPerms, FilePerms, IoImpl, IoView, ResourceTable, StdinStream, StdoutStream, WasiCtx,
-    WasiCtxBuilder, WasiImpl, WasiView,
+use wasmtime_wasi::p2::{
+    IoImpl, IoView, StdinStream, StdoutStream, WasiCtx, WasiCtxBuilder, WasiImpl, WasiView,
 };
+use wasmtime_wasi::{DirPerms, FilePerms, ResourceTable};
 
 pub use wasmtime_wasi::SocketAddrUse;
 
@@ -104,7 +104,7 @@ impl Factor for WasiFactor {
     type InstanceBuilder = InstanceBuilder;
 
     fn init(&mut self, ctx: &mut impl InitContext<Self>) -> anyhow::Result<()> {
-        use wasmtime_wasi::bindings;
+        use wasmtime_wasi::p2::bindings;
 
         ctx.link_wasi_bindings(bindings::clocks::wall_clock::add_to_linker_get_host)?;
         ctx.link_wasi_bindings(bindings::clocks::monotonic_clock::add_to_linker_get_host)?;
diff --git a/crates/factor-wasi/src/wasi_2023_10_18.rs b/crates/factor-wasi/src/wasi_2023_10_18.rs
@@ -1,10 +1,11 @@
 use spin_factors::anyhow::{self, Result};
 use std::mem;
 use wasmtime::component::{Linker, Resource};
-use wasmtime_wasi::{DynPollable, IoView, TrappableError, WasiImpl, WasiView};
+use wasmtime_wasi::p2::{DynPollable, IoView, WasiImpl, WasiView};
+use wasmtime_wasi::TrappableError;
 
 mod latest {
-    pub use wasmtime_wasi::bindings::*;
+    pub use wasmtime_wasi::p2::bindings::*;
 }
 
 mod bindings {
@@ -1666,19 +1667,19 @@ where
 
 fn convert_stream_result<T, T2>(
     mut view: impl WasiView,
-    result: Result<T, wasmtime_wasi::StreamError>,
+    result: Result<T, wasmtime_wasi::p2::StreamError>,
 ) -> wasmtime::Result<Result<T2, StreamError>>
 where
     T2: From<T>,
 {
     match result {
         Ok(e) => Ok(Ok(e.into())),
-        Err(wasmtime_wasi::StreamError::Closed) => Ok(Err(StreamError::Closed)),
-        Err(wasmtime_wasi::StreamError::LastOperationFailed(e)) => {
+        Err(wasmtime_wasi::p2::StreamError::Closed) => Ok(Err(StreamError::Closed)),
+        Err(wasmtime_wasi::p2::StreamError::LastOperationFailed(e)) => {
             let e = view.table().push(e)?;
             Ok(Err(StreamError::LastOperationFailed(e)))
         }
-        Err(wasmtime_wasi::StreamError::Trap(e)) => Err(e),
+        Err(wasmtime_wasi::p2::StreamError::Trap(e)) => Err(e),
     }
 }
 
diff --git a/crates/factor-wasi/src/wasi_2023_11_10.rs b/crates/factor-wasi/src/wasi_2023_11_10.rs
@@ -1,10 +1,10 @@
 use super::wasi_2023_10_18::{convert, convert_result};
 use spin_factors::anyhow::{self, Result};
 use wasmtime::component::{Linker, Resource};
-use wasmtime_wasi::{WasiImpl, WasiView};
+use wasmtime_wasi::p2::{WasiImpl, WasiView};
 
 mod latest {
-    pub use wasmtime_wasi::bindings::*;
+    pub use wasmtime_wasi::p2::bindings::*;
 }
 
 mod bindings {
@@ -593,19 +593,19 @@ where
 
 fn convert_stream_result<T, T2>(
     mut view: impl WasiView,
-    result: Result<T, wasmtime_wasi::StreamError>,
+    result: Result<T, wasmtime_wasi::p2::StreamError>,
 ) -> wasmtime::Result<Result<T2, StreamError>>
 where
     T2: From<T>,
 {
     match result {
         Ok(e) => Ok(Ok(e.into())),
-        Err(wasmtime_wasi::StreamError::Closed) => Ok(Err(StreamError::Closed)),
-        Err(wasmtime_wasi::StreamError::LastOperationFailed(e)) => {
+        Err(wasmtime_wasi::p2::StreamError::Closed) => Ok(Err(StreamError::Closed)),
+        Err(wasmtime_wasi::p2::StreamError::LastOperationFailed(e)) => {
             let e = view.table().push(e)?;
             Ok(Err(StreamError::LastOperationFailed(e)))
         }
-        Err(wasmtime_wasi::StreamError::Trap(e)) => Err(e),
+        Err(wasmtime_wasi::p2::StreamError::Trap(e)) => Err(e),
     }
 }
 
diff --git a/crates/factor-wasi/tests/factor_test.rs b/crates/factor-wasi/tests/factor_test.rs
@@ -1,7 +1,7 @@
 use spin_factor_wasi::{DummyFilesMounter, WasiFactor};
 use spin_factors::{anyhow, RuntimeFactors};
 use spin_factors_test::{toml, TestEnvironment};
-use wasmtime_wasi::bindings::cli::environment::Host;
+use wasmtime_wasi::p2::bindings::cli::environment::Host;
 
 #[derive(RuntimeFactors)]
 struct TestFactors {
diff --git a/crates/factors-executor/src/lib.rs b/crates/factors-executor/src/lib.rs
@@ -148,11 +148,13 @@ impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutorApp<T, U> {
     }
 
     pub fn get_component(&self, component_id: &str) -> anyhow::Result<&Component> {
-        let instance_pre = self
-            .component_instance_pres
+        Ok(self.get_instance_pre(component_id)?.component())
+    }
+
+    pub fn get_instance_pre(&self, component_id: &str) -> anyhow::Result<&InstancePre<T, U>> {
+        self.component_instance_pres
             .get(component_id)
-            .with_context(|| format!("no such component {component_id:?}"))?;
-        Ok(instance_pre.component())
+            .with_context(|| format!("no such component {component_id:?}"))
     }
 
     /// Returns an instance builder for the given component ID.
diff --git a/crates/http/src/trigger.rs b/crates/http/src/trigger.rs
@@ -1,8 +1,8 @@
 use serde::{Deserialize, Serialize};
 use spin_factor_outbound_http::wasi_2023_10_18::ProxyIndices as ProxyIndices2023_10_18;
 use spin_factor_outbound_http::wasi_2023_11_10::ProxyIndices as ProxyIndices2023_11_10;
-use wasmtime::component::Component;
-use wasmtime_wasi::bindings::CommandIndices;
+use wasmtime::component::InstancePre;
+use wasmtime_wasi::p2::bindings::CommandIndices;
 use wasmtime_wasi_http::bindings::ProxyIndices;
 
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
@@ -37,18 +37,22 @@ const SPIN_HTTP_EXPORT: &str = "fermyon:spin/inbound-http";
 
 impl HandlerType {
     /// Determine the handler type from the exports of a component.
-    pub fn from_component(component: &Component) -> anyhow::Result<HandlerType> {
+    pub fn from_instance_pre<T>(pre: &InstancePre<T>) -> anyhow::Result<HandlerType> {
         let mut candidates = Vec::new();
-        if let Ok(indices) = ProxyIndices::new(component) {
+        if let Ok(indices) = ProxyIndices::new(pre) {
             candidates.push(HandlerType::Wasi0_2(indices));
         }
-        if let Ok(indices) = ProxyIndices2023_10_18::new(component) {
+        if let Ok(indices) = ProxyIndices2023_10_18::new(pre) {
             candidates.push(HandlerType::Wasi2023_10_18(indices));
         }
-        if let Ok(indices) = ProxyIndices2023_11_10::new(component) {
+        if let Ok(indices) = ProxyIndices2023_11_10::new(pre) {
             candidates.push(HandlerType::Wasi2023_11_10(indices));
         }
-        if component.export_index(None, SPIN_HTTP_EXPORT).is_some() {
+        if pre
+            .component()
+            .get_export_index(None, SPIN_HTTP_EXPORT)
+            .is_some()
+        {
             candidates.push(HandlerType::Spin);
         }
 
diff --git a/crates/trigger-http/src/server.rs b/crates/trigger-http/src/server.rs
diff --git a/crates/trigger-http/src/spin.rs b/crates/trigger-http/src/spin.rs
diff --git a/crates/trigger-http/src/wagi.rs b/crates/trigger-http/src/wagi.rs
diff --git a/crates/trigger-http/src/wasi.rs b/crates/trigger-http/src/wasi.rs
diff --git a/crates/trigger-redis/src/lib.rs b/crates/trigger-redis/src/lib.rs
diff --git a/examples/spin-timer/Cargo.lock b/examples/spin-timer/Cargo.lock
diff --git a/examples/spin-timer/Cargo.toml b/examples/spin-timer/Cargo.toml
