seanmonstar · brooksmtownsend · May 17, 2024 · May 17, 2024 · May 22, 2024 · Jul 26, 2024
diff --git a/.gitignore b/.gitignore
@@ -1,4 +1,5 @@
 target
 Cargo.lock
 *.swp
-.idea
+.idea
+.vscode
diff --git a/Cargo.toml b/Cargo.toml
@@ -195,6 +195,9 @@ wasm-bindgen = "0.2.68"
 wasm-bindgen-futures = "0.4.18"
 wasm-streams = { version = "0.4", optional = true }
 
+[target.'cfg(all(target_os = "wasi", target_env = "p2"))'.dependencies]
+wasi = "=0.13.1" # For compatibility, pin to [email protected] bindings
+
 [target.'cfg(target_arch = "wasm32")'.dependencies.web-sys]
 version = "0.3.28"
 features = [

diff --git a/examples/wasm_component/Cargo.toml b/examples/wasm_component/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "http-reqwest"
+edition = "2021"
+version = "0.1.0"
+
+[workspace]
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+futures = "0.3.30"
+reqwest = { version = "0.12.4", path = "../../", features = ["stream"] }
+wasi = "=0.13.1" # For compatibility, pin to [email protected] bindings
+
+[profile.release]
+# Optimize for small code size
+lto = true
+opt-level = "s"
+strip = true
diff --git a/examples/wasm_component/README.md b/examples/wasm_component/README.md
@@ -0,0 +1,34 @@
+# HTTP Reqwest
+
+This is a simple Rust Wasm example that sends an outgoing http request using the `reqwest` library to [https://hyper.rs](https://hyper.rs).
+
+## Prerequisites
+
+- `cargo` 1.80+
+- `rustup target add wasm32-wasip2`
+- [wasmtime 23.0.0+](https://github.com/bytecodealliance/wasmtime)
+
+## Building
+
+```bash
+# Build Wasm component
+cargo +nightly build --target wasm32-wasip2
+```
+
+## Running with wasmtime
+
+```bash
+wasmtime serve -Scommon ./target/wasm32-wasip2/debug/http_reqwest.wasm
+```
+
+Then send a request to `localhost:8080`
+
+```bash
+> curl localhost:8080
+
+<!doctype html>
+<html>
+<head>
+    <title>Example Domain</title>
+....
+```
diff --git a/examples/wasm_component/src/lib.rs b/examples/wasm_component/src/lib.rs
@@ -0,0 +1,32 @@
+use wasi::http::types::{
+    Fields, IncomingRequest, OutgoingBody, OutgoingResponse, ResponseOutparam,
+};
+
+#[allow(unused)]
+struct ReqwestComponent;
+
+impl wasi::exports::http::incoming_handler::Guest for ReqwestComponent {
+    fn handle(_request: IncomingRequest, response_out: ResponseOutparam) {
+        let response = OutgoingResponse::new(Fields::new());
+        response.set_status_code(200).unwrap();
+        let response_body = response
+            .body()
+            .expect("should be able to get response body");
+        ResponseOutparam::set(response_out, Ok(response));
+
+        let mut response =
+            futures::executor::block_on(reqwest::Client::new().get("https://hyper.rs").send())
+                .expect("should get response bytes");
+        std::io::copy(
+            &mut response.bytes_stream().expect("should get incoming body"),
+            &mut response_body
+                .write()
+                .expect("should be able to write to response body"),
+        )
+        .expect("should be able to stream input to output");
+
+        OutgoingBody::finish(response_body, None).expect("failed to finish response body");
+    }
+}
+
+wasi::http::proxy::export!(ReqwestComponent);
diff --git a/src/lib.rs b/src/lib.rs
@@ -372,6 +372,6 @@ if_wasm! {
     mod util;
 
     pub use self::wasm::{Body, Client, ClientBuilder, Request, RequestBuilder, Response};
-    #[cfg(feature = "multipart")]
+    #[cfg(all(not(all(target_os = "wasi", target_env = "p2")), feature = "multipart"))]
     pub use self::wasm::multipart;
 }
diff --git a/src/wasm/component/body.rs b/src/wasm/component/body.rs
@@ -0,0 +1,111 @@
+use bytes::Bytes;
+use std::{borrow::Cow, fmt};
+
+/// The body of a [`super::Request`].
+pub struct Body {
+    inner: Inner,
+}
+
+enum Inner {
+    Single(Single),
+}
+
+#[derive(Clone)]
+pub(crate) enum Single {
+    Bytes(Bytes),
+    Text(Cow<'static, str>),
+}
+
+impl Single {
+    fn as_bytes(&self) -> &[u8] {
+        match self {
+            Single::Bytes(bytes) => bytes.as_ref(),
+            Single::Text(text) => text.as_bytes(),
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        match self {
+            Single::Bytes(bytes) => bytes.is_empty(),
+            Single::Text(text) => text.is_empty(),
+        }
+    }
+}
+
+impl Body {
+    /// Returns a reference to the internal data of the `Body`.
+    ///
+    /// `None` is returned, if the underlying data is a multipart form.
+    #[inline]
+    pub fn as_bytes(&self) -> Option<&[u8]> {
+        match &self.inner {
+            Inner::Single(single) => Some(single.as_bytes()),
+        }
+    }
+
+    #[allow(unused)]
+    pub(crate) fn is_empty(&self) -> bool {
+        match &self.inner {
+            Inner::Single(single) => single.is_empty(),
+        }
+    }
+
+    pub(crate) fn try_clone(&self) -> Option<Body> {
+        match &self.inner {
+            Inner::Single(single) => Some(Self {
+                inner: Inner::Single(single.clone()),
+            }),
+        }
+    }
+}
+
+impl From<Bytes> for Body {
+    #[inline]
+    fn from(bytes: Bytes) -> Body {
+        Body {
+            inner: Inner::Single(Single::Bytes(bytes)),
+        }
+    }
+}
+
+impl From<Vec<u8>> for Body {
+    #[inline]
+    fn from(vec: Vec<u8>) -> Body {
+        Body {
+            inner: Inner::Single(Single::Bytes(vec.into())),
+        }
+    }
+}
+
+impl From<&'static [u8]> for Body {
+    #[inline]
+    fn from(s: &'static [u8]) -> Body {
+        Body {
+            inner: Inner::Single(Single::Bytes(Bytes::from_static(s))),
+        }
+    }
+}
+
+impl From<String> for Body {
+    #[inline]
+    fn from(s: String) -> Body {
+        Body {
+            inner: Inner::Single(Single::Text(s.into())),
+        }
+    }
+}
+
+impl From<&'static str> for Body {
+    #[inline]
+    fn from(s: &'static str) -> Body {
+        Body {
+            inner: Inner::Single(Single::Text(s.into())),
+        }
+    }
+}
+
+impl fmt::Debug for Body {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Body").finish()
+    }
+}