Merge pull request #58 from bytecodealliance/feat/http

feat: implement `wasi:http`

Author: rvolosatovs

Cargo.lock

@@ -366,7 +366,7 @@ tokio = { version = "1.43.0", features = [ "rt", "time" ] }
 hyper = "1.0.1"
 http = "1.0.0"
 http-body = "1.0.0"
-http-body-util = "0.1.0"
+http-body-util = "0.1.1"
 bytes = { version = "1.4", default-features = false }
 futures = { version = "0.3.27", default-features = false }
 indexmap = { version = "2.0.0", default-features = false }
@@ -476,7 +476,7 @@ disable-logging = ["log/max_level_off", "tracing/max_level_off"]
 wasi-nn = ["dep:wasmtime-wasi-nn"]
 wasi-tls = ["dep:wasmtime-wasi-tls"]
 wasi-threads = ["dep:wasmtime-wasi-threads", "threads"]
-wasi-http = ["component-model", "dep:wasmtime-wasi-http", "dep:tokio", "dep:hyper"]
+wasi-http = ["component-model", "dep:wasmtime-wasi-http", "wasmtime-wasi-http/p3", "dep:tokio", "dep:hyper"]
 wasi-config = ["dep:wasmtime-wasi-config"]
 wasi-keyvalue = ["dep:wasmtime-wasi-keyvalue"]
 pooling-allocator = ["wasmtime/pooling-allocator", "wasmtime-cli-flags/pooling-allocator"]

Cargo.toml

@@ -75,6 +75,15 @@ make_vendor "wasi/src/p3" "
     random@[email protected]
     sockets@[email protected]
 "
+# `wasi:http` from https://github.com/WebAssembly/wasi-http/pull/158
+make_vendor "wasi-http/src/p3" "
+    cli@[email protected]
+    clocks@[email protected]
+    filesystem@[email protected]
+    random@[email protected]
+    sockets@[email protected]
+    http@[email protected]
+"
 
 rm -rf $cache_dir
 

ci/vendor-wit.sh

@@ -74,10 +74,12 @@ fn build_and_generate_tests() {
             s if s.starts_with("filesystem_0_3") => "filesystem_0_3",
             s if s.starts_with("random_0_3") => "random_0_3",
             s if s.starts_with("sockets_0_3") => "sockets_0_3",
+            s if s.starts_with("http_0_3") => "http_0_3",
             s if s.starts_with("http_") => "http",
             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",
@@ -113,7 +115,9 @@ fn build_and_generate_tests() {
             s if s.starts_with("filesystem_0_3") => &reactor_adapter,
             s if s.starts_with("random_0_3") => &reactor_adapter,
             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/artifacts/build.rs

@@ -0,0 +1,69 @@
+use futures::join;
+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"
+        );
+
+        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 {
+            join!(
+                async {
+                    let remaining = contents_tx.write_all(b"hello, world!".to_vec()).await;
+                    assert!(remaining.is_empty());
+                    drop(contents_tx);
+                    trailers_tx
+                        .write(Ok(None))
+                        .await
+                        .expect("failed to write trailers");
+                },
+                async {
+                    transmit
+                        .await
+                        .expect("failed to transmit response")
+                        .unwrap()
+                }
+            );
+        });
+        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/bin/api_0_3_proxy.rs

@@ -0,0 +1,137 @@
+use anyhow::Context as _;
+use futures::join;
+use test_programs::p3::wasi::http::handler;
+use test_programs::p3::wasi::http::types::{ErrorCode, Headers, Method, Request, Scheme, Trailers};
+use test_programs::p3::{wit_future, wit_stream};
+use wit_bindgen::FutureReader;
+use wit_bindgen_rt::async_support::{FutureWriter, StreamWriter};
+
+struct Component;
+
+test_programs::p3::export!(Component);
+
+fn make_request() -> (
+    Request,
+    StreamWriter<u8>,
+    FutureWriter<Result<Option<Trailers>, ErrorCode>>,
+    FutureReader<Result<(), ErrorCode>>,
+) {
+    let (contents_tx, contents_rx) = wit_stream::new();
+    let (trailers_tx, trailers_rx) = wit_future::new();
+    let (request, transmit) = Request::new(
+        Headers::from_list(&[("Content-Length".to_string(), b"11".to_vec())]).unwrap(),
+        Some(contents_rx),
+        trailers_rx,
+        None,
+    );
+
+    request.set_method(&Method::Post).expect("setting method");
+    request
+        .set_scheme(Some(&Scheme::Http))
+        .expect("setting scheme");
+    let addr = test_programs::p3::wasi::cli::environment::get_environment()
+        .into_iter()
+        .find_map(|(k, v)| k.eq("HTTP_SERVER").then_some(v))
+        .unwrap();
+    request
+        .set_authority(Some(&addr))
+        .expect("setting authority");
+    request
+        .set_path_with_query(Some("/"))
+        .expect("setting path with query");
+
+    (request, contents_tx, trailers_tx, transmit)
+}
+
+impl test_programs::p3::exports::wasi::cli::run::Guest for Component {
+    async fn run() -> Result<(), ()> {
+        {
+            let (request, mut contents_tx, trailers_tx, transmit) = make_request();
+            let (transmit, handle) = join!(async { transmit.await }, async {
+                let res = handler::handle(request)
+                    .await
+                    .context("failed to send request")?;
+                println!("writing enough");
+                let remaining = contents_tx.write_all(b"long enough".to_vec()).await;
+                assert!(
+                    remaining.is_empty(),
+                    "{}",
+                    String::from_utf8_lossy(&remaining)
+                );
+                drop(contents_tx);
+                trailers_tx
+                    .write(Ok(None))
+                    .await
+                    .context("failed to finish body")?;
+                anyhow::Ok(res)
+            });
+            let res = handle.unwrap();
+            drop(res);
+            transmit
+                .expect("transmit sender dropped")
+                .expect("failed to transmit request");
+        }
+
+        {
+            let (request, mut contents_tx, trailers_tx, transmit) = make_request();
+            let (transmit, handle) = join!(async { transmit.await }, async {
+                let res = handler::handle(request)
+                    .await
+                    .context("failed to send request")?;
+                println!("writing too little");
+                let remaining = contents_tx.write_all(b"msg".to_vec()).await;
+                assert!(
+                    remaining.is_empty(),
+                    "{}",
+                    String::from_utf8_lossy(&remaining)
+                );
+                drop(contents_tx);
+                trailers_tx
+                    .write(Ok(None))
+                    .await
+                    .context("failed to finish body")?;
+                anyhow::Ok(res)
+            });
+            let res = handle.unwrap();
+            drop(res);
+            let err = transmit
+                .expect("transmit sender dropped")
+                .expect_err("request transmission should have failed");
+            assert!(
+                matches!(err, ErrorCode::HttpRequestBodySize(Some(3))),
+                "unexpected error: {err:#?}"
+            );
+        }
+
+        {
+            let (request, mut contents_tx, trailers_tx, transmit) = make_request();
+            let (transmit, handle) = join!(async { transmit.await }, async {
+                let res = handler::handle(request)
+                    .await
+                    .context("failed to send request")?;
+                println!("writing too much");
+                let remaining = contents_tx.write_all(b"more than 11 bytes".to_vec()).await;
+                assert!(
+                    remaining.is_empty(),
+                    "{}",
+                    String::from_utf8_lossy(&remaining)
+                );
+                drop(contents_tx);
+                _ = trailers_tx.write(Ok(None)).await;
+                anyhow::Ok(res)
+            });
+            let res = handle.unwrap();
+            drop(res);
+            let err = transmit
+                .expect("transmit sender dropped")
+                .expect_err("request transmission should have failed");
+            assert!(
+                matches!(err, ErrorCode::HttpRequestBodySize(Some(18))),
+                "unexpected error: {err:#?}"
+            );
+        }
+        Ok(())
+    }
+}
+
+fn main() {}

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

@@ -0,0 +1,43 @@
+use anyhow::Context;
+use test_programs::p3::wasi::http::types::{Method, Scheme};
+
+struct Component;
+
+test_programs::p3::export!(Component);
+
+impl test_programs::p3::exports::wasi::cli::run::Guest for Component {
+    async fn run() -> Result<(), ()> {
+        let addr = test_programs::p3::wasi::cli::environment::get_environment()
+            .into_iter()
+            .find_map(|(k, v)| k.eq("HTTP_SERVER").then_some(v))
+            .unwrap();
+        let res = test_programs::p3::http::request(
+            Method::Get,
+            Scheme::Http,
+            &addr,
+            "/get?some=arg&goes=here",
+            None,
+            None,
+            None,
+            None,
+            None,
+        )
+        .await
+        .context("/get")
+        .unwrap();
+
+        println!("{addr} /get: {res:?}");
+        assert_eq!(res.status, 200);
+        let method = res.header("x-wasmtime-test-method").unwrap();
+        assert_eq!(std::str::from_utf8(method).unwrap(), "GET");
+        let uri = res.header("x-wasmtime-test-uri").unwrap();
+        assert_eq!(
+            std::str::from_utf8(uri).unwrap(),
+            format!("/get?some=arg&goes=here")
+        );
+        assert_eq!(res.body, b"");
+        Ok(())
+    }
+}
+
+fn main() {}