Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Add `Request::into_http` (#11843)

Theodore Brockman5d97bc3d9ebe
diff --git a/crates/wasi-http/src/p3/request.rs b/crates/wasi-http/src/p3/request.rs
index 4f921258f1..6d3792f2e7 100644
--- a/crates/wasi-http/src/p3/request.rs
+++ b/crates/wasi-http/src/p3/request.rs
@@ -1,13 +1,18 @@
+use crate::get_content_length;
use crate::p3::bindings::http::types::ErrorCode;
-use crate::p3::body::Body;
+use crate::p3::body::{Body, GuestBody};
+use crate::p3::{WasiHttpCtxView, WasiHttpView};
use bytes::Bytes;
use core::time::Duration;
+use http::header::HOST;
use http::uri::{Authority, PathAndQuery, Scheme};
-use http::{HeaderMap, Method};
+use http::{HeaderMap, HeaderValue, Method, Uri};
use http_body_util::BodyExt as _;
use http_body_util::combinators::UnsyncBoxBody;
use std::sync::Arc;
use tokio::sync::oneshot;
+use tracing::debug;
+use wasmtime::AsContextMut;
/// The concrete type behind a `wasi:http/types.request-options` resource.
#[derive(Copy, Clone, Debug, Default)]
@@ -119,6 +124,114 @@ impl Request {
body.map_err(Into::into).boxed_unsync(),
)
}
+
+ /// Convert this [`Request`] into an [`http::Request<BoxBody<Bytes, ErrorCode>>`].
+ ///
+ /// The specified future `fut` can be used to communicate a request processing
+ /// error, if any, back to the caller (e.g., if this request was constructed
+ /// through `wasi:http/types.request#new`).
+ pub fn into_http<T: WasiHttpView + 'static>(
+ self,
+ store: impl AsContextMut<Data = T>,
+ fut: impl Future<Output = Result<(), ErrorCode>> + Send + 'static,
+ ) -> wasmtime::Result<http::Request<UnsyncBoxBody<Bytes, ErrorCode>>> {
+ self.into_http_with_getter(store, fut, T::http)
+ }
+
+ /// Like [`Self::into_http`], but uses a custom getter for obtaining the [`WasiHttpCtxView`].
+ pub fn into_http_with_getter<T: 'static>(
+ self,
+ mut store: impl AsContextMut<Data = T>,
+ fut: impl Future<Output = Result<(), ErrorCode>> + Send + 'static,
+ getter: fn(&mut T) -> WasiHttpCtxView<'_>,
+ ) -> wasmtime::Result<http::Request<UnsyncBoxBody<Bytes, ErrorCode>>> {
+ let Request {
+ method,
+ scheme,
+ authority,
+ path_with_query,
+ headers,
+ options: _,
+ body,
+ } = self;
+ let content_length = match get_content_length(&headers) {
+ Ok(content_length) => content_length,
+ Err(err) => {
+ body.drop(&mut store);
+ return Err(ErrorCode::InternalError(Some(format!("{err:#}"))).into());
+ }
+ };
+ // This match must appear before any potential errors handled with '?'
+ // (or errors have to explicitly be addressed and drop the body, as above),
+ // as otherwise the Body::Guest resources will not be cleaned up when dropped.
+ // see: https://github.com/bytecodealliance/wasmtime/pull/11440#discussion_r2326139381
+ // for additional context.
+ let body = match body {
+ Body::Guest {
+ contents_rx,
+ trailers_rx,
+ result_tx,
+ } => GuestBody::new(
+ &mut store,
+ contents_rx,
+ trailers_rx,
+ result_tx,
+ fut,
+ content_length,
+ ErrorCode::HttpRequestBodySize,
+ getter,
+ )
+ .boxed_unsync(),
+ Body::Host { body, result_tx } => {
+ _ = result_tx.send(Box::new(fut));
+ body
+ }
+ };
+ let mut headers = Arc::unwrap_or_clone(headers);
+ let mut store_ctx = store.as_context_mut();
+ let WasiHttpCtxView { ctx, table: _ } = getter(store_ctx.data_mut());
+ if ctx.set_host_header() {
+ let host = if let Some(authority) = authority.as_ref() {
+ HeaderValue::try_from(authority.as_str())
+ .map_err(|err| ErrorCode::InternalError(Some(err.to_string())))?
+ } else {
+ HeaderValue::from_static("")
+ };
+ headers.insert(HOST, host);
+ }
+ let scheme = match scheme {
+ None => ctx.default_scheme().ok_or(ErrorCode::HttpProtocolError)?,
+ Some(scheme) if ctx.is_supported_scheme(&scheme) => scheme,
+ Some(..) => return Err(ErrorCode::HttpProtocolError.into()),
+ };
+ let mut uri = Uri::builder().scheme(scheme);
+ if let Some(authority) = authority {
+ uri = uri.authority(authority)
+ };
+ if let Some(path_with_query) = path_with_query {
+ uri = uri.path_and_query(path_with_query)
+ };
+ let uri = uri.build().map_err(|err| {
+ debug!(?err, "failed to build request URI");
+ ErrorCode::HttpRequestUriInvalid
+ })?;
+ let mut req = http::Request::builder();
+ if let Some(headers_mut) = req.headers_mut() {
+ *headers_mut = headers;
+ } else {
+ return Err(ErrorCode::InternalError(Some(
+ "failed to get mutable headers from request builder".to_string(),
+ ))
+ .into());
+ }
+ let req = req
+ .method(method)
+ .uri(uri)
+ .body(body)
+ .map_err(|err| ErrorCode::InternalError(Some(err.to_string())))?;
+ let (req, body) = req.into_parts();
+ Ok(http::Request::from_parts(req, body))
+ }
}
/// The default implementation of how an outgoing request is sent.
@@ -348,3 +461,123 @@ pub async fn default_send_request(
conn.await.map_err(ErrorCode::from_hyper_response_error)
}))
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::p3::WasiHttpCtx;
+ use anyhow::Result;
+ use http_body_util::{BodyExt, Empty, Full};
+ use std::future::Future;
+ use std::str::FromStr;
+ use std::task::{Context, Waker};
+ use wasmtime::{Engine, Store};
+ use wasmtime_wasi::{ResourceTable, WasiCtx, WasiCtxBuilder, WasiCtxView, WasiView};
+
+ struct TestHttpCtx;
+ struct TestCtx {
+ table: ResourceTable,
+ wasi: WasiCtx,
+ http: TestHttpCtx,
+ }
+
+ impl TestCtx {
+ fn new() -> Self {
+ Self {
+ table: ResourceTable::default(),
+ wasi: WasiCtxBuilder::new().build(),
+ http: TestHttpCtx,
+ }
+ }
+ }
+
+ impl WasiView for TestCtx {
+ fn ctx(&mut self) -> WasiCtxView<'_> {
+ WasiCtxView {
+ ctx: &mut self.wasi,
+ table: &mut self.table,
+ }
+ }
+ }
+
+ impl WasiHttpCtx for TestHttpCtx {}
+
+ impl WasiHttpView for TestCtx {
+ fn http(&mut self) -> WasiHttpCtxView<'_> {
+ WasiHttpCtxView {
+ ctx: &mut self.http,
+ table: &mut self.table,
+ }
+ }
+ }
+
+ #[tokio::test]
+ async fn test_request_into_http_schemes() -> Result<()> {
+ let schemes = vec![Some(Scheme::HTTP), Some(Scheme::HTTPS), None];
+ let engine = Engine::default();
+
+ for scheme in schemes {
+ let (req, fut) = Request::new(
+ Method::POST,
+ scheme.clone(),
+ Some(Authority::from_static("example.com")),
+ Some(PathAndQuery::from_static("/path?query=1")),
+ HeaderMap::new(),
+ None,
+ Full::new(Bytes::from_static(b"body"))
+ .map_err(|x| match x {})
+ .boxed_unsync(),
+ );
+ let mut store = Store::new(&engine, TestCtx::new());
+ let http_req = req.into_http(&mut store, async { Ok(()) }).unwrap();
+ assert_eq!(http_req.method(), Method::POST);
+ let expected_scheme = scheme.unwrap_or(Scheme::HTTPS); // default scheme
+ assert_eq!(
+ http_req.uri(),
+ &http::Uri::from_str(&format!(
+ "{}://example.com/path?query=1",
+ expected_scheme.as_str()
+ ))
+ .unwrap()
+ );
+ let body_bytes = http_req.into_body().collect().await?;
+ assert_eq!(*body_bytes.to_bytes(), *b"body");
+ let mut cx = Context::from_waker(Waker::noop());
+ let mut fut = Box::pin(fut);
+ let result = fut.as_mut().poll(&mut cx);
+ assert!(matches!(result, futures::task::Poll::Ready(Ok(()))));
+ }
+
+ Ok(())
+ }
+
+ #[tokio::test]
+ async fn test_request_into_http_uri_error() -> Result<()> {
+ let (req, fut) = Request::new(
+ Method::GET,
+ Some(Scheme::HTTP),
+ Some(Authority::from_static("example.com")),
+ None, // <-- should fail, must be Some(_) when authority is set
+ HeaderMap::new(),
+ None,
+ Empty::new().map_err(|x| match x {}).boxed_unsync(),
+ );
+ let mut store = Store::new(&Engine::default(), TestCtx::new());
+ let result = req.into_http(&mut store, async {
+ Err(ErrorCode::InternalError(Some("uh oh".to_string())))
+ });
+ assert!(result.is_err());
+ assert!(matches!(
+ result.unwrap_err().downcast_ref::<ErrorCode>(),
+ Some(ErrorCode::HttpRequestUriInvalid)
+ ));
+ let mut cx = Context::from_waker(Waker::noop());
+ let result = Box::pin(fut).as_mut().poll(&mut cx);
+ assert!(matches!(
+ result,
+ futures::task::Poll::Ready(Err(ErrorCode::InternalError(Some(_))))
+ ));
+
+ Ok(())
+ }
+}