fixup! feat(p3): implement wasi:http

Author: rvolosatovs

crates/test-programs/artifacts/build.rs

@@ -78,6 +78,7 @@ fn build_and_generate_tests() {
             s if s.starts_with("preview1_") => "preview1",
             s if s.starts_with("preview2_") => "preview2",
             s if s.starts_with("cli_") => "cli",
+            s if s.starts_with("api_0_3") => "api_0_3",
             s if s.starts_with("api_") => "api",
             s if s.starts_with("nn_") => "nn",
             s if s.starts_with("piped_") => "piped",
@@ -114,6 +115,7 @@ fn build_and_generate_tests() {
             s if s.starts_with("sockets_0_3") => &reactor_adapter,
             s if s.starts_with("http_0_3") => &reactor_adapter,
             s if s.starts_with("async_") => &reactor_adapter,
+            s if s.starts_with("api_0_3_proxy") => &proxy_adapter,
             s if s.starts_with("api_proxy") => &proxy_adapter,
             _ => &command_adapter,
         };

crates/test-programs/src/bin/api_0_3_proxy.rs

@@ -0,0 +1,64 @@
+use futures::SinkExt as _;
+use test_programs::p3::wasi::http::types::{ErrorCode, Headers, Request, Response};
+use test_programs::p3::{wit_future, wit_stream};
+use wit_bindgen_rt::async_support::spawn;
+
+struct T;
+
+test_programs::p3::proxy::export!(T);
+
+impl test_programs::p3::proxy::exports::wasi::http::handler::Guest for T {
+    async fn handle(request: Request) -> Result<Response, ErrorCode> {
+        assert!(request.scheme().is_some());
+        assert!(request.authority().is_some());
+        assert!(request.path_with_query().is_some());
+
+        // TODO: adapt below
+        //test_filesystem();
+
+        let header = String::from("custom-forbidden-header");
+        let req_hdrs = request.headers();
+
+        assert!(
+            !req_hdrs.has(&header),
+            "forbidden `custom-forbidden-header` found in request"
+        );
+
+        assert!(req_hdrs.delete(&header).is_err());
+        assert!(req_hdrs.append(&header, b"no".as_ref()).is_err());
+
+        assert!(
+            !req_hdrs.has(&header),
+            "append of forbidden header succeeded"
+        );
+
+        assert!(
+            !req_hdrs.has("host"),
+            "forbidden host header present in incoming request"
+        );
+
+        let hdrs = Headers::new();
+        let (mut contents_tx, contents_rx) = wit_stream::new();
+        let (trailers_tx, trailers_rx) = wit_future::new();
+        let (resp, transmit) = Response::new(hdrs, Some(contents_rx), trailers_rx);
+        spawn(async {
+            contents_tx
+                .send(b"hello, world!".to_vec())
+                .await
+                .expect("writing response");
+            drop(contents_tx);
+            trailers_tx.write(Ok(None));
+            transmit.await.expect("failed to transmit response");
+        });
+        Ok(resp)
+    }
+}
+
+// Technically this should not be here for a proxy, but given the current
+// framework for tests it's required since this file is built as a `bin`
+fn main() {}
+
+// TODO: adapt below
+//fn test_filesystem() {
+//    assert!(std::fs::File::open(".").is_err());
+//}

crates/test-programs/src/p3/mod.rs

@@ -12,9 +12,7 @@ wit_bindgen::generate!({
             export wasi:cli/run@0.3.0;
         }
     ",
-    path: [
-        "../wasi-http/src/p3/wit",
-    ],
+    path: "../wasi-http/src/p3/wit",
     world: "wasmtime:test/testp3",
     default_bindings_module: "test_programs::p3",
     pub_export_macro: true,
@@ -36,3 +34,37 @@ wit_bindgen::generate!({
     },
     generate_all
 });
+
+pub mod proxy {
+    wit_bindgen::generate!({
+        inline: "
+            package wasmtime:test;
+
+            world proxyp3 {
+                include wasi:http/proxy@0.3.0-draft;
+            }
+        ",
+        path: "../wasi-http/src/p3/wit",
+        world: "wasmtime:test/proxyp3",
+        default_bindings_module: "test_programs::p3::proxy",
+        pub_export_macro: true,
+        async: {
+             imports: [
+                 "wasi:http/handler@0.3.0-draft#handle",
+             ],
+             exports: [
+                 "wasi:http/handler@0.3.0-draft#handle",
+             ],
+        },
+        with: {
+            "wasi:http/handler@0.3.0-draft": generate,
+            "wasi:http/types@0.3.0-draft": crate::p3::wasi::http::types,
+            "wasi:random/random@0.3.0": crate::p3::wasi::random::random,
+            "wasi:cli/stdout@0.3.0": crate::p3::wasi::cli::stdout,
+            "wasi:cli/stderr@0.3.0": crate::p3::wasi::cli::stderr,
+            "wasi:cli/stdin@0.3.0": crate::p3::wasi::cli::stdin,
+            "wasi:clocks/monotonic-clock@0.3.0": crate::p3::wasi::clocks::monotonic_clock,
+            "wasi:clocks/wall-clock@0.3.0": crate::p3::wasi::clocks::wall_clock,
+        },
+    });
+}

crates/wasi-http/src/p3/proxy.rs

@@ -30,7 +30,7 @@ impl Proxy {
     /// Call `handle` on [Proxy].
     pub async fn handle<T>(
         &self,
-        mut store: impl AsContextMut<Data = T> + Sync + Send + 'static,
+        mut store: impl AsContextMut<Data = T> + Send + 'static,
         req: impl Into<Request>,
     ) -> wasmtime::Result<
         Result<

crates/wasi-http/src/p3/response.rs

@@ -61,7 +61,7 @@ impl Response {
     /// Convert [Response] into [http::Response].
     pub fn into_http<T: ResourceView + 'static>(
         self,
-        mut store: impl AsContextMut<Data = T> + Sync + Send + 'static,
+        mut store: impl AsContextMut<Data = T> + Send + 'static,
     ) -> anyhow::Result<(
         http::Response<UnsyncBoxBody<Bytes, Option<ErrorCode>>>,
         Option<FutureWriter<Result<(), ErrorCode>>>,

crates/wasi-http/tests/all/p3/mod.rs

@@ -1,6 +1,8 @@
 use core::future::Future;
 
 use bytes::Bytes;
+use http_body::Body;
+use http_body_util::{BodyExt as _, Collected, Empty};
 use wasmtime::component::{Component, Linker, ResourceTable};
 use wasmtime::Store;
 use wasmtime_wasi::p3::cli::{WasiCliCtx, WasiCliView};
@@ -11,13 +13,14 @@ use wasmtime_wasi::p3::sockets::{WasiSocketsCtx, WasiSocketsView};
 use wasmtime_wasi::p3::ResourceView;
 use wasmtime_wasi::{IoView, WasiCtx, WasiCtxBuilder, WasiView};
 use wasmtime_wasi_http::p3::bindings::http::types::ErrorCode;
+use wasmtime_wasi_http::p3::bindings::Proxy;
 use wasmtime_wasi_http::p3::{
     default_send_request, Client, RequestOptions, WasiHttpCtx, WasiHttpView,
 };
 
 use crate::http_server::Server;
 
-mod tests;
+mod outgoing;
 
 struct Ctx<C: Client = TestClient> {
     cli: WasiCliCtx,
@@ -103,7 +106,7 @@ impl<C: Client> WasiHttpView for Ctx<C> {
         &self.http
     }
 
-    fn is_forbidden_header(&mut self, name: &hyper::header::HeaderName) -> bool {
+    fn is_forbidden_header(&mut self, name: &http::header::HeaderName) -> bool {
         name.as_str() == "custom-forbidden-header"
     }
 }
@@ -148,104 +151,75 @@ impl Client for TestClient {
     }
 }
 
-// TODO: Port below
+async fn run_wasi_http<E: Into<ErrorCode> + 'static>(
+    component_filename: &str,
+    req: http::Request<impl Body<Data = Bytes, Error = E> + Send + Sync + 'static>,
+    client: TestClient,
+) -> anyhow::Result<Result<hyper::Response<Collected<Bytes>>, ErrorCode>> {
+    let engine = test_programs_artifacts::engine(|config| {
+        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
+        config.async_support(true);
+        config.wasm_component_model_async(true);
+    });
+    let component = Component::from_file(&engine, component_filename)?;
 
-//async fn run_wasi_http(
-//    component_filename: &str,
-//    req: hyper::Request<BoxBody<Bytes, hyper::Error>>,
-//    send_request: Option<RequestSender>,
-//    rejected_authority: Option<String>,
-//) -> anyhow::Result<Result<hyper::Response<Collected<Bytes>>, ErrorCode>> {
-//    let stdout = MemoryOutputPipe::new(4096);
-//    let stderr = MemoryOutputPipe::new(4096);
-//    let table = ResourceTable::new();
-//
-//    let mut config = Config::new();
-//    config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-//    config.wasm_component_model(true);
-//    config.async_support(true);
-//    let engine = Engine::new(&config)?;
-//    let component = Component::from_file(&engine, component_filename)?;
-//
-//    // Create our wasi context.
-//    let mut builder = WasiCtxBuilder::new();
-//    builder.stdout(stdout.clone());
-//    builder.stderr(stderr.clone());
-//    let wasi = builder.build();
-//    let http = WasiHttpCtx::new();
-//    let ctx = Ctx {
-//        table,
-//        wasi,
-//        http,
-//        stderr,
-//        stdout,
-//        send_request,
-//        rejected_authority,
-//    };
-//    let mut store = Store::new(&engine, ctx);
-//
-//    let mut linker = Linker::new(&engine);
-//    wasmtime_wasi_http::add_to_linker_async(&mut linker)?;
-//    let proxy =
-//        wasmtime_wasi_http::bindings::Proxy::instantiate_async(&mut store, &component, &linker)
-//            .await?;
-//
-//    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)?;
-//
-//    let handle = wasmtime_wasi::runtime::spawn(async move {
-//        proxy
-//            .wasi_http_incoming_handler()
-//            .call_handle(&mut store, req, out)
-//            .await?;
-//
-//        Ok::<_, anyhow::Error>(())
-//    });
-//
-//    let resp = match receiver.await {
-//        Ok(Ok(resp)) => {
-//            let (parts, body) = resp.into_parts();
-//            let collected = BodyExt::collect(body).await?;
-//            Some(Ok(hyper::Response::from_parts(parts, collected)))
-//        }
-//        Ok(Err(e)) => Some(Err(e)),
-//
-//        // Fall through below to the `resp.expect(...)` which will hopefully
-//        // return a more specific error from `handle.await`.
-//        Err(_) => None,
-//    };
-//
-//    // Now that the response has been processed, we can wait on the wasm to
-//    // finish without deadlocking.
-//    handle.await.context("Component execution")?;
-//
-//    Ok(resp.expect("wasm never called set-response-outparam"))
-//}
-//
-//#[test_log::test(tokio::test)]
-//async fn wasi_http_proxy_tests() -> anyhow::Result<()> {
-//    let req = hyper::Request::builder()
-//        .header("custom-forbidden-header", "yes")
-//        .uri("http://example.com:8080/test-path")
-//        .method(http::Method::GET);
-//
-//    let resp = run_wasi_http(
-//        test_programs_artifacts::API_PROXY_COMPONENT,
-//        req.body(body::empty())?,
-//        None,
-//        None,
-//    )
-//    .await?;
-//
-//    match resp {
-//        Ok(resp) => println!("response: {resp:?}"),
-//        Err(e) => panic!("Error given in response: {e:?}"),
-//    };
-//
-//    Ok(())
-//}
+    let mut store = Store::new(
+        &engine,
+        Ctx {
+            cli: WasiCliCtx {
+                ..WasiCliCtx::default()
+            },
+            http: WasiHttpCtx { client },
+            ..Ctx::default()
+        },
+    );
+
+    let mut linker = Linker::new(&engine);
+    wasmtime_wasi::add_to_linker_async(&mut linker)?;
+    wasmtime_wasi_http::p3::add_to_linker(&mut linker)?;
+    let proxy = Proxy::instantiate_async(&mut store, &component, &linker).await?;
+    match proxy.handle(store, req).await? {
+        Ok((resp, fut)) => {
+            let (parts, body) = resp.into_parts();
+            let body = body
+                .collect()
+                .await
+                .map_err(|err| err.expect("trailer future dropped"))?;
+            if let Some(fut) = fut {
+                let _fut = fut.write(Ok(()));
+                // TODO: Should we await the future, if so, how do we do that after having moved
+                // the store?
+            }
+            Ok(Ok(http::Response::from_parts(parts, body)))
+        }
+        Err(err) => Ok(Err(err)),
+    }
+}
+
+#[test_log::test(tokio::test)]
+async fn wasi_http_proxy_tests() -> anyhow::Result<()> {
+    let req = hyper::Request::builder()
+        // TODO: remove forbidden headers?
+        //.header("custom-forbidden-header", "yes")
+        .uri("http://example.com:8080/test-path")
+        .method(http::Method::GET);
+
+    let resp = run_wasi_http(
+        test_programs_artifacts::API_0_3_PROXY_COMPONENT,
+        req.body(Empty::new())?,
+        TestClient::default(),
+    )
+    .await?;
+
+    match resp {
+        Ok(resp) => println!("response: {resp:?}"),
+        Err(e) => panic!("Error given in response: {e:?}"),
+    };
+
+    Ok(())
+}
+
+// TODO: Port below
 //
 //#[test_log::test(tokio::test)]
 //async fn wasi_http_hash_all() -> Result<()> {