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.lockindex 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.tomlindex 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.rsindex 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.tomlindex 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.rsindex 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| {