update Wasmtime dep to release-37.0.0

v37.0.0 will be released later this month; this is a draft based on the Git
branch for that release so we're ready when the release happens.

Closes #3270

Signed-off-by: Joel Dice <[email protected]>

Author: dicej

Cargo.lock

@@ -170,16 +170,16 @@ tower-service = "0.3.3"
 tracing = { version = "0.1.41", features = ["log"] }
 url = "2"
 walkdir = "2"
-wasm-encoder = "0.236.1"
-wasm-metadata = "0.236.1"
+wasm-encoder = "0.239.0"
+wasm-metadata = "0.239.0"
 wasm-pkg-client = "0.11"
 wasm-pkg-common = "0.11"
-wasmparser = "0.236.1"
-wasmtime = "36.0.2"
-wasmtime-wasi = "36.0.2"
-wasmtime-wasi-http = "36.0.2"
-wit-component = "0.236.1"
-wit-parser = "0.236.1"
+wasmparser = "0.239.0"
+wasmtime = { git = "https://github.com/bytecodealliance/wasmtime", branch = "release-37.0.0" }
+wasmtime-wasi = { git = "https://github.com/bytecodealliance/wasmtime", branch = "release-37.0.0" }
+wasmtime-wasi-http = { git = "https://github.com/bytecodealliance/wasmtime", branch = "release-37.0.0" }
+wit-component = "0.239.0"
+wit-parser = "0.239.0"
 
 spin-componentize = { path = "crates/componentize" }
 

Cargo.toml

@@ -9,7 +9,7 @@ use spin_core::{AsState, Component, Config, Engine, State, Store, StoreBuilder,
 use spin_factor_wasi::{DummyFilesMounter, WasiFactor};
 use spin_factors::{App, AsInstanceState, RuntimeFactors};
 use spin_locked_app::locked::LockedApp;
-use tokio::{fs, io::AsyncWrite};
+use tokio::fs;
 use wasmtime_wasi::I32Exit;
 
 #[tokio::test(flavor = "multi_thread")]
@@ -169,44 +169,3 @@ async fn run_test(
         .0
         .map_err(|()| anyhow::anyhow!("command failed"))
 }
-
-// Write with `print!`, required for test output capture
-struct TestWriter(tokio::io::Stdout);
-
-impl std::io::Write for TestWriter {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        print!("{}", String::from_utf8_lossy(buf));
-        Ok(buf.len())
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        Ok(())
-    }
-}
-
-impl AsyncWrite for TestWriter {
-    fn poll_write(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-        buf: &[u8],
-    ) -> std::task::Poll<Result<usize, std::io::Error>> {
-        let this = self.get_mut();
-        std::pin::Pin::new(&mut this.0).poll_write(cx, buf)
-    }
-
-    fn poll_flush(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), std::io::Error>> {
-        let this = self.get_mut();
-        std::pin::Pin::new(&mut this.0).poll_flush(cx)
-    }
-
-    fn poll_shutdown(
-        self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), std::io::Error>> {
-        let this = self.get_mut();
-        std::pin::Pin::new(&mut this.0).poll_shutdown(cx)
-    }
-}

crates/core/tests/integration_test.rs

@@ -459,7 +459,7 @@ mod test {
         let mut resolve = wit_parser::Resolve::default();
         let package_id = resolve.push_str("test", wit).expect("should parse WIT");
         let world_id = resolve
-            .select_world(package_id, Some(world))
+            .select_world(&[package_id], Some(world))
             .expect("should select world");
 
         let mut wasm = wit_component::dummy_module(

crates/environments/src/environment.rs

@@ -1,11 +1,11 @@
-use spin_factor_outbound_networking::runtime_config::spin::SpinRuntimeConfig;
 use spin_factor_outbound_networking::OutboundNetworkingFactor;
+use spin_factor_outbound_networking::runtime_config::spin::SpinRuntimeConfig;
 use spin_factor_variables::VariablesFactor;
 use spin_factor_wasi::{DummyFilesMounter, WasiFactor};
-use spin_factors::{anyhow, RuntimeFactors};
-use spin_factors_test::{toml, TestEnvironment};
+use spin_factors::{RuntimeFactors, anyhow};
+use spin_factors_test::{TestEnvironment, toml};
 use wasmtime_wasi::p2::bindings::sockets::instance_network::Host;
-use wasmtime_wasi::SocketAddrUse;
+use wasmtime_wasi::sockets::SocketAddrUse;
 
 #[derive(RuntimeFactors)]
 struct TestFactors {
@@ -35,10 +35,10 @@ async fn configures_wasi_socket_addr_check() -> anyhow::Result<()> {
             ..Default::default()
         })?;
     let mut state = env.build_instance_state().await?;
-    let mut wasi = WasiFactor::get_wasi_impl(&mut state).unwrap();
+    let mut sockets = WasiFactor::get_sockets_impl(&mut state).unwrap();
 
-    let network_resource = wasi.instance_network()?;
-    let network = wasi.table.get(&network_resource)?;
+    let network_resource = sockets.instance_network()?;
+    let network = sockets.table.get(&network_resource)?;
 
     network
         .check_socket_addr(