Merge pull request #17 from wacker-dev/bump-wasmtime

Test on wasmtime 23.0.1

Author: iawia002

waki/Cargo.toml

@@ -38,9 +38,9 @@ multipart = ["dep:mime", "dep:mime_guess", "dep:rand", "dep:memchr", "dep:bytes"
 [dev-dependencies]
 test-programs-artifacts = { path = "../test-programs/artifacts" }
 
-wasmtime = "22.0.0"
-wasmtime-wasi = "22.0.0"
-wasmtime-wasi-http = "22.0.0"
+wasmtime = "23.0.1"
+wasmtime-wasi = "23.0.1"
+wasmtime-wasi-http = "23.0.1"
 hyper = "1.3.1"
 http-body-util = "0.1.1"
 tokio = { version = "1.38.0", features = ["macros"] }

waki/tests/all/main.rs

@@ -2,16 +2,19 @@ mod client;
 mod server;
 
 use anyhow::{Context, Result};
-use http_body_util::Collected;
+use http_body_util::{combinators::BoxBody, Collected};
 use hyper::body::Bytes;
 use wasmtime::{
     component::{Component, Linker, ResourceTable},
     Config, Engine, Store,
 };
 use wasmtime_wasi::{bindings::Command, DirPerms, FilePerms, WasiCtx, WasiCtxBuilder, WasiView};
 use wasmtime_wasi_http::{
-    bindings::http::types::ErrorCode, body::HyperIncomingBody, proxy::Proxy, WasiHttpCtx,
-    WasiHttpView,
+    bindings::{
+        http::types::{ErrorCode, Scheme},
+        Proxy,
+    },
+    WasiHttpCtx, WasiHttpView,
 };
 
 struct Ctx {
@@ -60,20 +63,20 @@ fn new_component(component_filename: &str) -> Result<(Store<Ctx>, Component, Lin
     let store = Store::new(&engine, ctx);
     let mut linker = Linker::new(&engine);
     wasmtime_wasi::add_to_linker_async(&mut linker)?;
-    wasmtime_wasi_http::proxy::add_only_http_to_linker(&mut linker)?;
+    wasmtime_wasi_http::add_only_http_to_linker_async(&mut linker)?;
     Ok((store, component, linker))
 }
 
 // ref: https://github.com/bytecodealliance/wasmtime/blob/af59c4d568d487b7efbb49d7d31a861e7c3933a6/crates/wasi-http/tests/all/main.rs#L129
 pub async fn run_wasi_http(
     component_filename: &str,
-    req: hyper::Request<HyperIncomingBody>,
+    req: hyper::Request<BoxBody<Bytes, hyper::Error>>,
 ) -> Result<Result<hyper::Response<Collected<Bytes>>, ErrorCode>> {
     let (mut store, component, linker) = new_component(component_filename)?;
 
-    let (proxy, _) = Proxy::instantiate_async(&mut store, &component, &linker).await?;
+    let proxy = Proxy::instantiate_async(&mut store, &component, &linker).await?;
 
-    let req = store.data_mut().new_incoming_request(req)?;
+    let req = store.data_mut().new_incoming_request(Scheme::Http, req)?;
 
     let (sender, receiver) = tokio::sync::oneshot::channel();
     let out = store.data_mut().new_response_outparam(sender)?;
@@ -111,7 +114,7 @@ pub async fn run_wasi_http(
 pub async fn run_wasi(component_filename: &str) -> Result<()> {
     let (mut store, component, linker) = new_component(component_filename)?;
 
-    let (command, _) = Command::instantiate_async(&mut store, &component, &linker).await?;
+    let command = Command::instantiate_async(&mut store, &component, &linker).await?;
     command
         .wasi_cli_run()
         .call_run(&mut store)

waki/tests/all/server.rs

@@ -76,15 +76,14 @@ async fn status_code() -> Result<()> {
 }
 
 mod body {
-    use http_body_util::{BodyExt, Full};
-    use hyper::body::Bytes;
-    use wasmtime_wasi_http::body::HyperIncomingBody;
+    use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full};
+    use hyper::{body::Bytes, Error};
 
-    pub fn full(bytes: &'static str) -> HyperIncomingBody {
-        HyperIncomingBody::new(Full::new(Bytes::from(bytes)).map_err(|_| unreachable!()))
+    pub fn full(bytes: &'static str) -> BoxBody<Bytes, Error> {
+        BoxBody::new(Full::new(bytes.into()).map_err(|_| unreachable!()))
     }
 
-    pub fn empty() -> HyperIncomingBody {
-        HyperIncomingBody::default()
+    pub fn empty() -> BoxBody<Bytes, Error> {
+        BoxBody::new(Empty::new().map_err(|_| unreachable!()))
     }
 }