Skip to content

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

serve: accept HTTP/2 connections (#14908)

Xia Chao3ba4f6892370
diff --git a/Cargo.lock b/Cargo.lock
index 5dc05c9fb3..f6c1208194 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1910,6 +1910,20 @@ dependencies = [
"want",
]
+[[package]]
+name = "hyper-util"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddc03d96684f9226b8a787cdb71488417b53ab5ea8fdb1dac946cb9431cc8bff"
+dependencies = [
+ "bytes",
+ "http",
+ "http-body",
+ "hyper",
+ "pin-project-lite",
+ "tokio",
+]
+
[[package]]
name = "icu_collections"
version = "1.5.0"
@@ -4684,6 +4698,7 @@ dependencies = [
"http",
"http-body-util",
"hyper",
+ "hyper-util",
"indexmap 2.14.0",
"libc",
"libtest-mimic",
diff --git a/Cargo.toml b/Cargo.toml
index 800a615d6d..7631ffa3d5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -98,6 +98,7 @@ async-trait = { workspace = true }
bytes = { workspace = true }
tokio = { workspace = true, optional = true, features = [ "signal", "macros" ] }
hyper = { workspace = true, optional = true }
+hyper-util = { workspace = true, optional = true, features = ["server-auto"] }
http = { workspace = true, optional = true }
http-body-util = { workspace = true, optional = true }
futures = { workspace = true, optional = true }
@@ -431,6 +432,7 @@ libc = { version = "0.2.190", default-features = true }
file-per-thread-logger = "0.2.0"
tokio = { version = "1.51.6", features = [ "rt", "time" ] }
hyper = "1.9.0"
+hyper-util = { version = "0.1", features = ["tokio"] }
http = "1.5.0"
http-body = "1.0.1"
http-body-util = "0.1.3"
@@ -614,6 +616,7 @@ serve = [
"wasmtime-wasi-http/component-model-async",
"component-model",
"dep:http-body-util",
+ "dep:hyper-util",
"dep:http",
"dep:pin-project-lite",
"wasmtime-cli-flags/async",
diff --git a/src/commands/serve.rs b/src/commands/serve.rs
index c07f760ae2..e696b747dd 100644
--- a/src/commands/serve.rs
+++ b/src/commands/serve.rs
@@ -2,7 +2,8 @@ use crate::common::{HttpHooks, Profile, RunCommon, RunTarget};
use clap::Parser;
use http::{HeaderMap, HeaderName, HeaderValue, Response, StatusCode};
use http_body_util::{BodyExt as _, Full};
-use hyper::server::conn::http1;
+use hyper_util::rt::TokioExecutor;
+use hyper_util::server::conn::auto;
use pin_project_lite::pin_project;
use std::convert::Infallible;
use std::ffi::OsString;
@@ -905,12 +906,14 @@ impl ServeCommand {
// concurrent requests can't be served. Otherwise though spawn a
// task to handle this client.
match &mut debuggee_store {
- Some(store) => handle_client(stream, &handler, &shutdown, Some(store)).await,
+ Some(store) => {
+ handle_client(stream, handler.clone(), shutdown.clone(), Some(store)).await
+ }
None => {
let handler = handler.clone();
let shutdown = shutdown.clone();
tokio::task::spawn(async move {
- handle_client(stream, &handler, &shutdown, None).await;
+ handle_client(stream, handler, shutdown, None).await;
drop(shutdown_guard);
drop(connection_permit);
});
@@ -1375,36 +1378,82 @@ fn setup_guest_profiler(
type Request = hyper::Request<hyper::body::Incoming>;
+/// Drive a connection until it completes or the server shuts down.
+async fn drive_connection<F, G, E>(conn: F, shutdown: &GracefulShutdown, graceful: G)
+where
+ F: std::future::Future<Output = Result<(), E>>,
+ E: std::fmt::Debug,
+ G: FnOnce(std::pin::Pin<&mut F>),
+{
+ let mut conn = std::pin::pin!(conn);
+ let result = tokio::select! {
+ result = conn.as_mut() => result,
+ _ = shutdown.requested() => {
+ graceful(conn.as_mut());
+ conn.await
+ }
+ };
+ if let Err(e) = result {
+ eprintln!("error: {e:?}");
+ }
+}
+
async fn handle_client(
client: impl AsyncRead + AsyncWrite + Send + Sync + Unpin + 'static,
- handler: &ProxyHandler<HostHandlerState>,
- shutdown: &GracefulShutdown,
+ handler: ProxyHandler<HostHandlerState>,
+ shutdown: Arc<GracefulShutdown>,
debuggee_store: Option<&mut Store<Host>>,
) {
- // Hyper's `service_fn` takes an `Fn` closure, so to bridge the need to
- // transfer a mutable store to each request for debugging a tokio mutex is
- // used. The tokio mutex is required as the returned future must also be
- // `Send`.
- let lock = &debuggee_store.map(tokio::sync::Mutex::new);
+ // A debugger drives one connection synchronously, so keep that path on
+ // HTTP/1.1; the auto builder needs a `'static` service future.
+ if let Some(store) = debuggee_store {
+ let lock = std::sync::Arc::new(tokio::sync::Mutex::new(store));
+ let conn = hyper::server::conn::http1::Builder::new()
+ .keep_alive(true)
+ .serve_connection(
+ TokioIo::new(client),
+ hyper::service::service_fn(move |req| {
+ let lock = lock.clone();
+ let handler = handler.clone();
+ async move {
+ let mut store = lock.lock().await;
+ match handle_request(&handler, Some(&mut store), req).await {
+ Ok(r) => Ok::<_, Infallible>(r),
+ Err(e) => Ok(error_response(e)),
+ }
+ }
+ }),
+ );
+ drive_connection(conn, &shutdown, |conn| conn.graceful_shutdown()).await;
+ return;
+ }
- let conn = http1::Builder::new().keep_alive(true).serve_connection(
+ let builder = auto::Builder::new(TokioExecutor::new());
+ let conn = builder.serve_connection_with_upgrades(
TokioIo::new(client),
- hyper::service::service_fn(move |req| async move {
- let mut debuggee_store = match &lock {
- Some(store) => Some(store.lock().await),
- None => None,
- };
- let debuggee_store = debuggee_store.as_mut().map(|s| &mut ***s);
- match handle_request(handler, debuggee_store, req).await {
- Ok(r) => Ok::<_, Infallible>(r),
- Err(e) => {
- eprintln!("error: {e:?}");
- let status = e
- .downcast_ref::<ErrorResponse>()
- .map(|e| e.status())
- .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
- let error_html = format!(
- "\
+ hyper::service::service_fn(move |req| {
+ let handler = handler.clone();
+ async move {
+ match handle_request(&handler, None, req).await {
+ Ok(r) => Ok::<_, Infallible>(r),
+ Err(e) => Ok(error_response(e)),
+ }
+ }
+ }),
+ );
+ // Use hyper's built-in support for graceful shutdown whenever the server
+ // here gets a shutdown request.
+ drive_connection(conn, &shutdown, |conn| conn.graceful_shutdown()).await;
+}
+
+fn error_response(e: wasmtime::Error) -> Response<wasmtime_wasi_http::WasiBody> {
+ eprintln!("error: {e:?}");
+ let status = e
+ .downcast_ref::<ErrorResponse>()
+ .map(|e| e.status())
+ .unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
+ let error_html = format!(
+ "\
<!doctype html>
<html>
<head>
@@ -1418,34 +1467,16 @@ async fn handle_client(
</center>
</body>
</html>"
- );
- Ok(Response::builder()
- .status(status)
- .header("Content-Type", "text/html; charset=UTF-8")
- .body(
- Full::new(bytes::Bytes::from(error_html))
- .map_err(|_| unreachable!())
- .boxed_unsync(),
- )
- .unwrap())
- }
- }
- }),
);
- let mut conn = std::pin::pin!(conn);
-
- // Use hyper's built-in support for graceful shutdown whenever the server
- // here gets a shutdown request.
- let result = tokio::select! {
- result = conn.as_mut() => result,
- _ = shutdown.requested() => {
- conn.as_mut().graceful_shutdown();
- conn.await
- }
- };
- if let Err(e) = result {
- eprintln!("error: {e:?}");
- }
+ Response::builder()
+ .status(status)
+ .header("Content-Type", "text/html; charset=UTF-8")
+ .body(
+ Full::new(bytes::Bytes::from(error_html))
+ .map_err(|_| unreachable!())
+ .boxed_unsync(),
+ )
+ .unwrap()
}
async fn handle_request(
diff --git a/supply-chain/config.toml b/supply-chain/config.toml
index 7c13233cf1..7cc2e09aec 100644
--- a/supply-chain/config.toml
+++ b/supply-chain/config.toml
@@ -320,6 +320,10 @@ criteria = "safe-to-deploy"
version = "2.1.0"
criteria = "safe-to-deploy"
+[[exemptions.hyper-util]]
+version = "0.1.21"
+criteria = "safe-to-deploy"
+
[[exemptions.ipnet]]
version = "2.5.0"
criteria = "safe-to-deploy"
diff --git a/tests/all/cli_tests.rs b/tests/all/cli_tests.rs
index 4fd8af2c2a..75d79f50fc 100644
--- a/tests/all/cli_tests.rs
+++ b/tests/all/cli_tests.rs
@@ -2856,6 +2856,59 @@ start a print 1234
.await
}
+ #[derive(Clone)]
+ struct TokioExecutor;
+
+ impl<F> hyper::rt::Executor<F> for TokioExecutor
+ where
+ F: std::future::Future + Send + 'static,
+ F::Output: Send + 'static,
+ {
+ fn execute(&self, fut: F) {
+ tokio::task::spawn(fut);
+ }
+ }
+
+ /// The client speaks HTTP/2 with prior knowledge, so this only passes if
+ /// `serve` accepts h2c connections as well as HTTP/1.1 ones.
+ #[tokio::test]
+ async fn p2_cli_serve_hello_world_http2() -> Result<()> {
+ let server = WasmtimeServe::new(P2_CLI_SERVE_HELLO_WORLD_COMPONENT, |cmd| {
+ cmd.arg("-Scli");
+ })?;
+
+ let tcp = TcpStream::connect(server.first_addr()).await?;
+ let (mut send, conn) = hyper::client::conn::http2::Builder::new(TokioExecutor)
+ .handshake(wasmtime_wasi_http::io::TokioIo::new(tcp))
+ .await
+ .context("failed http2 handshake")?;
+ let conn_task = tokio::task::spawn(conn);
+
+ let response = send
+ .send_request(
+ hyper::Request::builder()
+ .uri("http://localhost/")
+ .body(String::new())
+ .context("failed to make request")?,
+ )
+ .await
+ .context("error sending request")?;
+ assert!(response.status().is_success());
+
+ let body = response
+ .into_body()
+ .collect()
+ .await
+ .context("failed to read body")?;
+ assert_eq!(std::str::from_utf8(&body.to_bytes())?, "Hello, WASI!");
+
+ drop(send);
+ conn_task.await??;
+
+ server.finish()?;
+ Ok(())
+ }
+
#[tokio::test]
async fn p2_cli_serve_hello_world() -> Result<()> {
cli_serve_hello_world(P2_CLI_SERVE_HELLO_WORLD_COMPONENT, 1, 1, |cmd| {