diff --git a/Cargo.lock b/Cargo.lock index 3772c739df..5e89c5feed 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -965,7 +965,6 @@ dependencies = [ "fwdansi", "glibc_version", "glob", - "h2 0.4.0", "hex", "http 0.2.11", "http 1.0.0", diff --git a/Cargo.toml b/Cargo.toml index 6b53c44eab..12bdd30c65 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -107,6 +107,7 @@ http = "0.2.9" h2 = { version = "0.3.17", features = ["unstable"] } httparse = "1.8.0" hyper-util = { version = "=0.1.2", features = ["tokio", "server", "server-auto"] } +http-body-util = "0.1" hyper = { version = "0.14.26", features = ["runtime", "http1"] } hyper1 = { package = "hyper", version = "=1.1.0", features = ["full"] } indexmap = { version = "2", features = ["serde"] } diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 77aded6da2..9ac1220ef9 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -152,8 +152,7 @@ nix.workspace = true deno_bench_util.workspace = true fastwebsockets_06 = { package = "fastwebsockets", version = "0.6", features = ["upgrade", "unstable-split"] } flaky_test = "=0.1.0" -h2_04 = { package = "h2", version = "0.4" } -http-body-util = "0.1" +http-body-util.workspace = true http_1 = { package = "http", version = "1.0" } hyper-util.workspace = true hyper1.workspace = true diff --git a/ext/http/Cargo.toml b/ext/http/Cargo.toml index 2672516063..8192cf31e4 100644 --- a/ext/http/Cargo.toml +++ b/ext/http/Cargo.toml @@ -54,5 +54,5 @@ tokio-util = { workspace = true, features = ["io"] } [dev-dependencies] bencher.workspace = true -http-body-util = "0.1" +http-body-util.workspace = true rand.workspace = true diff --git a/ext/websocket/Cargo.toml b/ext/websocket/Cargo.toml index a4321b498a..ac210f9bab 100644 --- a/ext/websocket/Cargo.toml +++ b/ext/websocket/Cargo.toml @@ -19,9 +19,9 @@ deno_core.workspace = true deno_net.workspace = true deno_tls.workspace = true fastwebsockets.workspace = true -h2_04 = { package = "h2", version = "0.4" } -http-body-util = "0.1" -http_1 = { package = "http", version = "1.0" } +h2 = "0.4" +http = "1.0" +http-body-util.workspace = true hyper-util.workspace = true hyper1.workspace = true once_cell.workspace = true diff --git a/ext/websocket/lib.rs b/ext/websocket/lib.rs index a5a1d80e4e..d1692fe190 100644 --- a/ext/websocket/lib.rs +++ b/ext/websocket/lib.rs @@ -25,14 +25,14 @@ use deno_tls::create_client_config; use deno_tls::rustls::ClientConfig; use deno_tls::RootCertStoreProvider; use deno_tls::SocketUse; -use http_1::header::CONNECTION; -use http_1::header::UPGRADE; -use http_1::HeaderName; -use http_1::HeaderValue; -use http_1::Method; -use http_1::Request; -use http_1::StatusCode; -use http_1::Uri; +use http::header::CONNECTION; +use http::header::UPGRADE; +use http::HeaderName; +use http::HeaderValue; +use http::Method; +use http::Request; +use http::StatusCode; +use http::Uri; use once_cell::sync::Lazy; use rustls_tokio_stream::rustls::RootCertStore; use rustls_tokio_stream::rustls::ServerName; @@ -156,7 +156,7 @@ async fn handshake_websocket( uri: &Uri, protocols: &str, headers: Option>, -) -> Result<(WebSocket, http_1::HeaderMap), AnyError> { +) -> Result<(WebSocket, http::HeaderMap), AnyError> { let mut request = Request::builder().method(Method::GET).uri( uri .path_and_query() @@ -219,7 +219,7 @@ async fn handshake_websocket( async fn handshake_http1_ws( request: Request>, addr: &String, -) -> Result<(WebSocket, http_1::HeaderMap), AnyError> { +) -> Result<(WebSocket, http::HeaderMap), AnyError> { let tcp_socket = TcpStream::connect(addr).await?; handshake_connection(request, tcp_socket).await } @@ -229,7 +229,7 @@ async fn handshake_http1_wss( request: Request>, domain: &str, addr: &str, -) -> Result<(WebSocket, http_1::HeaderMap), AnyError> { +) -> Result<(WebSocket, http::HeaderMap), AnyError> { let tcp_socket = TcpStream::connect(addr).await?; let tls_config = create_ws_client_config(state, SocketUse::Http1Only)?; let dnsname = @@ -255,7 +255,7 @@ async fn handshake_http2_wss( domain: &str, headers: &Option>, addr: &str, -) -> Result<(WebSocket, http_1::HeaderMap), AnyError> { +) -> Result<(WebSocket, http::HeaderMap), AnyError> { let tcp_socket = TcpStream::connect(addr).await?; let tls_config = create_ws_client_config(state, SocketUse::Http2Only)?; let dnsname = @@ -267,7 +267,7 @@ async fn handshake_http2_wss( if handshake.alpn.is_none() { bail!("Didn't receive h2 alpn, aborting connection"); } - let h2 = h2_04::client::Builder::new(); + let h2 = h2::client::Builder::new(); let (mut send, conn) = h2.handshake::<_, Bytes>(tls_connector).await?; spawn(conn); let mut request = Request::builder(); @@ -280,13 +280,13 @@ async fn handshake_http2_wss( request = request.uri(uri); request = populate_common_request_headers(request, user_agent, protocols, headers)?; - request = request.extension(h2_04::ext::Protocol::from("websocket")); + request = request.extension(h2::ext::Protocol::from("websocket")); let (resp, send) = send.send_request(request.body(())?, false)?; let resp = resp.await?; if resp.status() != StatusCode::OK { bail!("Invalid status code: {}", resp.status()); } - let (http_1::response::Parts { headers, .. }, recv) = resp.into_parts(); + let (http::response::Parts { headers, .. }, recv) = resp.into_parts(); let mut stream = WebSocket::after_handshake( WebSocketStream::new(stream::WsStreamKind::H2(send, recv), None), Role::Client, @@ -303,7 +303,7 @@ async fn handshake_connection< >( request: Request>, socket: S, -) -> Result<(WebSocket, http_1::HeaderMap), AnyError> { +) -> Result<(WebSocket, http::HeaderMap), AnyError> { let (upgraded, response) = fastwebsockets::handshake::client(&LocalExecutor, request, socket).await?; @@ -339,11 +339,11 @@ pub fn create_ws_client_config( /// Headers common to both http/1.1 and h2 requests. fn populate_common_request_headers( - mut request: http_1::request::Builder, + mut request: http::request::Builder, user_agent: &str, protocols: &str, headers: &Option>, -) -> Result { +) -> Result { request = request .header("User-Agent", user_agent) .header("Sec-WebSocket-Version", "13"); @@ -361,14 +361,14 @@ fn populate_common_request_headers( let is_disallowed_header = matches!( name, - http_1::header::HOST - | http_1::header::SEC_WEBSOCKET_ACCEPT - | http_1::header::SEC_WEBSOCKET_EXTENSIONS - | http_1::header::SEC_WEBSOCKET_KEY - | http_1::header::SEC_WEBSOCKET_PROTOCOL - | http_1::header::SEC_WEBSOCKET_VERSION - | http_1::header::UPGRADE - | http_1::header::CONNECTION + http::header::HOST + | http::header::SEC_WEBSOCKET_ACCEPT + | http::header::SEC_WEBSOCKET_EXTENSIONS + | http::header::SEC_WEBSOCKET_KEY + | http::header::SEC_WEBSOCKET_PROTOCOL + | http::header::SEC_WEBSOCKET_VERSION + | http::header::UPGRADE + | http::header::CONNECTION ); if !is_disallowed_header { request = request.header(name, v); diff --git a/ext/websocket/stream.rs b/ext/websocket/stream.rs index 7e0201ae46..88c053dc5f 100644 --- a/ext/websocket/stream.rs +++ b/ext/websocket/stream.rs @@ -2,8 +2,8 @@ use bytes::Buf; use bytes::Bytes; use deno_net::raw::NetworkStream; -use h2_04::RecvStream; -use h2_04::SendStream; +use h2::RecvStream; +use h2::SendStream; use hyper1::upgrade::Upgraded; use hyper_util::rt::TokioIo; use std::io::ErrorKind; diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index fceb25d9ab..7ac7a803b6 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -101,7 +101,7 @@ fastwebsockets.workspace = true filetime = "0.2.16" fs3.workspace = true http.workspace = true -http-body-util = "0.1" +http-body-util.workspace = true http_1 = { package = "http", version = "1.0" } hyper = { workspace = true, features = ["server", "stream", "http1", "http2", "runtime"] } hyper-util.workspace = true diff --git a/test_util/Cargo.toml b/test_util/Cargo.toml index d51252a3b3..5f2ccbd593 100644 --- a/test_util/Cargo.toml +++ b/test_util/Cargo.toml @@ -25,9 +25,9 @@ fastwebsockets.workspace = true flate2 = { workspace = true, features = ["default"] } futures.workspace = true glob.workspace = true -h2_04 = { package = "h2", version = "0.4" } -http-body-util = "0.1" -http_1 = { package = "http", version = "1.0" } +h2 = "0.4" +http = "1.0" +http-body-util.workspace = true hyper-util.workspace = true hyper1.workspace = true lazy-regex.workspace = true diff --git a/test_util/src/servers/grpc.rs b/test_util/src/servers/grpc.rs index 08d297a4cd..096f8c85f5 100644 --- a/test_util/src/servers/grpc.rs +++ b/test_util/src/servers/grpc.rs @@ -1,7 +1,7 @@ // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. use futures::StreamExt; -use h2_04 as h2; +use h2; use hyper1::header::HeaderName; use hyper1::header::HeaderValue; use rustls_tokio_stream::TlsStream; diff --git a/test_util/src/servers/hyper_utils.rs b/test_util/src/servers/hyper_utils.rs new file mode 100644 index 0000000000..b8e9472a4a --- /dev/null +++ b/test_util/src/servers/hyper_utils.rs @@ -0,0 +1,146 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. + +use bytes::Bytes; +use futures::Future; +use futures::FutureExt; +use futures::Stream; +use futures::StreamExt; +use http; +use http::Request; +use http::Response; +use http_body_util::combinators::UnsyncBoxBody; +use hyper1 as hyper; +use hyper_util::rt::TokioIo; +use std::convert::Infallible; +use std::io; +use std::net::SocketAddr; +use std::pin::Pin; +use std::result::Result; +use tokio::net::TcpListener; + +#[derive(Debug, Clone, Copy)] +pub enum ServerKind { + Auto, + OnlyHttp1, + OnlyHttp2, +} + +#[derive(Debug, Clone, Copy)] +pub struct ServerOptions { + pub error_msg: &'static str, + pub addr: SocketAddr, + pub kind: ServerKind, +} + +type HandlerOutput = + Result>, anyhow::Error>; + +pub async fn run_server(options: ServerOptions, handler: F) +where + F: Fn(Request) -> S + Copy + 'static, + S: Future + 'static, +{ + let fut: Pin>>> = + async move { + let listener = TcpListener::bind(options.addr).await?; + loop { + let (stream, _) = listener.accept().await?; + let io = TokioIo::new(stream); + deno_unsync::spawn(hyper1_serve_connection( + io, + handler, + options.error_msg, + options.kind, + )); + } + } + .boxed_local(); + + if let Err(e) = fut.await { + eprintln!("{}: {:?}", options.error_msg, e); + } +} + +pub async fn run_server_with_acceptor<'a, A, F, S>( + mut acceptor: Pin>, + handler: F, + error_msg: &'static str, + kind: ServerKind, +) where + A: Stream> + ?Sized, + F: Fn(Request) -> S + Copy + 'static, + S: Future + 'static, +{ + let fut: Pin>>> = + async move { + while let Some(result) = acceptor.next().await { + let stream = result?; + let io = TokioIo::new(stream); + deno_unsync::spawn(hyper1_serve_connection( + io, handler, error_msg, kind, + )); + } + Ok(()) + } + .boxed_local(); + + if let Err(e) = fut.await { + eprintln!("{}: {:?}", error_msg, e); + } +} + +async fn hyper1_serve_connection( + io: I, + handler: F, + error_msg: &'static str, + kind: ServerKind, +) where + I: hyper::rt::Read + hyper::rt::Write + Unpin + 'static, + F: Fn(Request) -> S + Copy + 'static, + S: Future + 'static, +{ + let service = hyper1::service::service_fn(handler); + + let result: Result<(), anyhow::Error> = match kind { + ServerKind::Auto => { + let builder = + hyper_util::server::conn::auto::Builder::new(DenoUnsyncExecutor); + builder + .serve_connection(io, service) + .await + .map_err(|e| anyhow::anyhow!("{}", e)) + } + ServerKind::OnlyHttp1 => { + let builder = hyper1::server::conn::http1::Builder::new(); + builder + .serve_connection(io, service) + .await + .map_err(|e| e.into()) + } + ServerKind::OnlyHttp2 => { + let builder = + hyper1::server::conn::http2::Builder::new(DenoUnsyncExecutor); + builder + .serve_connection(io, service) + .await + .map_err(|e| e.into()) + } + }; + + if let Err(e) = result { + eprintln!("{}: {:?}", error_msg, e); + } +} + +#[derive(Clone)] +struct DenoUnsyncExecutor; + +impl hyper::rt::Executor for DenoUnsyncExecutor +where + Fut: Future + 'static, + Fut::Output: 'static, +{ + fn execute(&self, fut: Fut) { + deno_unsync::spawn(fut); + } +} diff --git a/test_util/src/servers/mod.rs b/test_util/src/servers/mod.rs index 18953b7f04..7c4d76e7a9 100644 --- a/test_util/src/servers/mod.rs +++ b/test_util/src/servers/mod.rs @@ -11,43 +11,44 @@ use denokv_proto::datapath::ReadRangeOutput; use denokv_proto::datapath::SnapshotRead; use denokv_proto::datapath::SnapshotReadOutput; use denokv_proto::datapath::SnapshotReadStatus; -use futures::Future; use futures::FutureExt; use futures::Stream; use futures::StreamExt; +use http; use http::HeaderValue; use http::Method; use http::Request; use http::Response; use http::StatusCode; -use http_1 as http; use http_body_util::combinators::UnsyncBoxBody; use http_body_util::BodyExt; use http_body_util::Empty; use http_body_util::Full; use hyper1 as hyper; -use hyper_util::rt::TokioIo; use pretty_assertions::assert_eq; use prost::Message; use std::collections::HashMap; use std::convert::Infallible; use std::env; -use std::io; use std::net::Ipv6Addr; use std::net::SocketAddr; use std::net::SocketAddrV6; use std::path::PathBuf; -use std::pin::Pin; use std::result::Result; use std::time::Duration; use tokio::io::AsyncWriteExt; -use tokio::net::TcpListener; use tokio::net::TcpStream; mod grpc; +mod hyper_utils; mod registry; mod ws; +use hyper_utils::run_server; +use hyper_utils::run_server_with_acceptor; +use hyper_utils::ServerKind; +use hyper_utils::ServerOptions; + use super::https::get_tls_listener_stream; use super::https::SupportedHttpVersions; use super::npm::CUSTOM_NPM_PACKAGE_CACHE; @@ -94,8 +95,6 @@ pub async fn run_all_servers() { return hyper_hello(port.parse::().unwrap()).await; } - // TODO(bartlomieju): in a follow up all these `wrap_` handlers could be removed - // in favor of spawning a hyper server directly with a config object let redirect_server_fut = wrap_redirect_server(REDIRECT_PORT); let double_redirects_server_fut = wrap_double_redirect_server(DOUBLE_REDIRECTS_PORT); @@ -185,7 +184,15 @@ async fn hyper_hello(port: u16) { http_body_util::Full::new(Bytes::from("Hello World!")), ))) }; - run_hyper1_server(addr, handler, "server error").await; + run_server( + ServerOptions { + addr, + error_msg: "server error", + kind: ServerKind::Auto, + }, + handler, + ) + .await; } fn redirect_resp(url: String) -> Response> { @@ -1159,221 +1166,93 @@ async fn download_npm_registry_file( Ok(()) } -#[derive(Clone)] -struct DenoUnsyncExecutor; - -impl hyper::rt::Executor for DenoUnsyncExecutor -where - Fut: Future + 'static, - Fut::Output: 'static, -{ - fn execute(&self, fut: Fut) { - deno_unsync::spawn(fut); - } -} - -#[derive(Debug, Clone, Copy)] -enum Hyper1ServerKind { - Auto, - OnlyHttp1, - OnlyHttp2, -} - -async fn hyper1_serve_connection( - io: I, - service_fn_handler: F, - error_msg: &'static str, - kind: Hyper1ServerKind, -) where - I: hyper::rt::Read + hyper::rt::Write + Unpin + 'static, - F: Fn(Request) -> S + Copy + 'static, - S: Future< - Output = Result< - Response>, - anyhow::Error, - >, - > + 'static, -{ - let service = hyper1::service::service_fn(service_fn_handler); - - let result: Result<(), anyhow::Error> = match kind { - Hyper1ServerKind::Auto => { - let builder = - hyper_util::server::conn::auto::Builder::new(DenoUnsyncExecutor); - builder - .serve_connection(io, service) - .await - .map_err(|e| anyhow::anyhow!("{}", e)) - } - Hyper1ServerKind::OnlyHttp1 => { - let builder = hyper1::server::conn::http1::Builder::new(); - builder - .serve_connection(io, service) - .await - .map_err(|e| e.into()) - } - Hyper1ServerKind::OnlyHttp2 => { - let builder = - hyper1::server::conn::http2::Builder::new(DenoUnsyncExecutor); - builder - .serve_connection(io, service) - .await - .map_err(|e| e.into()) - } - }; - - if let Err(e) = result { - eprintln!("{}: {:?}", error_msg, e); - } -} - -async fn run_hyper1_server_inner( - addr: SocketAddr, - service_fn_handler: F, - error_msg: &'static str, - kind: Hyper1ServerKind, -) where - F: Fn(Request) -> S + Copy + 'static, - S: Future< - Output = Result< - Response>, - anyhow::Error, - >, - > + 'static, -{ - let fut: Pin>>> = - async move { - let listener = TcpListener::bind(addr).await?; - loop { - let (stream, _) = listener.accept().await?; - let io = TokioIo::new(stream); - deno_unsync::spawn(hyper1_serve_connection( - io, - service_fn_handler, - error_msg, - kind, - )); - } - } - .boxed_local(); - - if let Err(e) = fut.await { - eprintln!("{}: {:?}", error_msg, e); - } -} - -async fn run_hyper1_server( - addr: SocketAddr, - service_fn_handler: F, - error_msg: &'static str, -) where - F: Fn(Request) -> S + Copy + 'static, - S: Future< - Output = Result< - Response>, - anyhow::Error, - >, - > + 'static, -{ - run_hyper1_server_inner( - addr, - service_fn_handler, - error_msg, - Hyper1ServerKind::Auto, - ) - .await -} - -// TODO(bartlomieju): dedup with `run_hyper1_server_inner` -async fn run_hyper1_server_with_acceptor<'a, A, F, S>( - mut acceptor: Pin>, - service_fn_handler: F, - error_msg: &'static str, - kind: Hyper1ServerKind, -) where - A: Stream> + ?Sized, - F: Fn(Request) -> S + Copy + 'static, - S: Future< - Output = Result< - Response>, - anyhow::Error, - >, - > + 'static, -{ - let fut: Pin>>> = - async move { - while let Some(result) = acceptor.next().await { - let stream = result?; - let io = TokioIo::new(stream); - deno_unsync::spawn(hyper1_serve_connection( - io, - service_fn_handler, - error_msg, - kind, - )); - } - Ok(()) - } - .boxed_local(); - - if let Err(e) = fut.await { - eprintln!("{}: {:?}", error_msg, e); - } -} - async fn wrap_redirect_server(port: u16) { let redirect_addr = SocketAddr::from(([127, 0, 0, 1], port)); - run_hyper1_server(redirect_addr, redirect, "Redirect error").await; + run_server( + ServerOptions { + addr: redirect_addr, + error_msg: "Redirect error", + kind: ServerKind::Auto, + }, + redirect, + ) + .await; } async fn wrap_double_redirect_server(port: u16) { let double_redirects_addr = SocketAddr::from(([127, 0, 0, 1], port)); - run_hyper1_server( - double_redirects_addr, + run_server( + ServerOptions { + addr: double_redirects_addr, + error_msg: "Double redirect error", + kind: ServerKind::Auto, + }, double_redirects, - "Double redirect error", ) .await; } async fn wrap_inf_redirect_server(port: u16) { let inf_redirects_addr = SocketAddr::from(([127, 0, 0, 1], port)); - run_hyper1_server(inf_redirects_addr, inf_redirects, "Inf redirect error") - .await; + run_server( + ServerOptions { + addr: inf_redirects_addr, + error_msg: "Inf redirect error", + kind: ServerKind::Auto, + }, + inf_redirects, + ) + .await; } async fn wrap_another_redirect_server(port: u16) { let another_redirect_addr = SocketAddr::from(([127, 0, 0, 1], port)); - run_hyper1_server( - another_redirect_addr, + run_server( + ServerOptions { + addr: another_redirect_addr, + error_msg: "Another redirect error", + kind: ServerKind::Auto, + }, another_redirect, - "Another redirect error", ) .await; } async fn wrap_auth_redirect_server(port: u16) { let auth_redirect_addr = SocketAddr::from(([127, 0, 0, 1], port)); - run_hyper1_server(auth_redirect_addr, auth_redirect, "Auth redirect error") - .await; + run_server( + ServerOptions { + addr: auth_redirect_addr, + error_msg: "Auth redirect error", + kind: ServerKind::Auto, + }, + auth_redirect, + ) + .await; } async fn wrap_basic_auth_redirect_server(port: u16) { let basic_auth_redirect_addr = SocketAddr::from(([127, 0, 0, 1], port)); - run_hyper1_server( - basic_auth_redirect_addr, + run_server( + ServerOptions { + addr: basic_auth_redirect_addr, + error_msg: "Basic auth redirect error", + kind: ServerKind::Auto, + }, basic_auth_redirect, - "Basic auth redirect error", ) .await; } async fn wrap_abs_redirect_server(port: u16) { let abs_redirect_addr = SocketAddr::from(([127, 0, 0, 1], port)); - run_hyper1_server( - abs_redirect_addr, + run_server( + ServerOptions { + addr: abs_redirect_addr, + error_msg: "Absolute redirect error", + kind: ServerKind::Auto, + }, absolute_redirect, - "Absolute redirect error", ) .await; } @@ -1392,17 +1271,25 @@ async fn wrap_main_ipv6_server(port: u16) { } async fn wrap_main_server_for_addr(main_server_addr: &SocketAddr) { - run_hyper1_server(*main_server_addr, main_server, "HTTP server error").await; + run_server( + ServerOptions { + addr: *main_server_addr, + kind: ServerKind::Auto, + error_msg: "HTTP server error", + }, + main_server, + ) + .await; } async fn wrap_main_https_server(port: u16) { let tls = get_tls_listener_stream("https", port, Default::default()).await; let tls_acceptor = tls.boxed_local(); - run_hyper1_server_with_acceptor( + run_server_with_acceptor( tls_acceptor, main_server, "HTTPS server error", - Hyper1ServerKind::Auto, + ServerKind::Auto, ) .await } @@ -1415,11 +1302,11 @@ async fn wrap_https_h1_only_tls_server(port: u16) { ) .await; - run_hyper1_server_with_acceptor( + run_server_with_acceptor( tls.boxed_local(), main_server, "HTTP1 only TLS server error", - Hyper1ServerKind::OnlyHttp1, + ServerKind::OnlyHttp1, ) .await } @@ -1432,33 +1319,37 @@ async fn wrap_https_h2_only_tls_server(port: u16) { ) .await; - run_hyper1_server_with_acceptor( + run_server_with_acceptor( tls.boxed_local(), main_server, "HTTP2 only TLS server error", - Hyper1ServerKind::OnlyHttp2, + ServerKind::OnlyHttp2, ) .await } async fn wrap_http_h1_only_server(port: u16) { let main_server_http_addr = SocketAddr::from(([127, 0, 0, 1], port)); - run_hyper1_server_inner( - main_server_http_addr, + run_server( + ServerOptions { + addr: main_server_http_addr, + error_msg: "HTTP1 only server error:", + kind: ServerKind::OnlyHttp1, + }, main_server, - "HTTP1 only server error:", - Hyper1ServerKind::OnlyHttp1, ) .await; } async fn wrap_http_h2_only_server(port: u16) { let main_server_http_addr = SocketAddr::from(([127, 0, 0, 1], port)); - run_hyper1_server_inner( - main_server_http_addr, + run_server( + ServerOptions { + addr: main_server_http_addr, + error_msg: "HTTP1 only server error:", + kind: ServerKind::OnlyHttp2, + }, main_server, - "HTTP1 only server error:", - Hyper1ServerKind::OnlyHttp2, ) .await; } @@ -1480,11 +1371,11 @@ async fn wrap_client_auth_https_server(port: u16) { } }; - run_hyper1_server_with_acceptor( + run_server_with_acceptor( tls.boxed_local(), main_server, "Auth TLS server error", - Hyper1ServerKind::Auto, + ServerKind::Auto, ) .await } diff --git a/test_util/src/servers/registry.rs b/test_util/src/servers/registry.rs index 8f6fd32aa4..3e04572538 100644 --- a/test_util/src/servers/registry.rs +++ b/test_util/src/servers/registry.rs @@ -1,6 +1,8 @@ // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. -use super::run_hyper1_server; +use super::run_server; +use super::ServerKind; +use super::ServerOptions; use bytes::Bytes; use http_body_util::combinators::UnsyncBoxBody; use http_body_util::Empty; @@ -16,10 +18,13 @@ use std::net::SocketAddr; pub async fn registry_server(port: u16) { let registry_server_addr = SocketAddr::from(([127, 0, 0, 1], port)); - run_hyper1_server( - registry_server_addr, + run_server( + ServerOptions { + addr: registry_server_addr, + error_msg: "Registry server error", + kind: ServerKind::Auto, + }, registry_server_handler, - "Registry server error", ) .await } diff --git a/test_util/src/servers/ws.rs b/test_util/src/servers/ws.rs index 188216c861..f820c8bbdd 100644 --- a/test_util/src/servers/ws.rs +++ b/test_util/src/servers/ws.rs @@ -11,10 +11,10 @@ use futures::future::join3; use futures::future::poll_fn; use futures::Future; use futures::StreamExt; -use h2_04::server::Handshake; -use h2_04::server::SendResponse; -use h2_04::Reason; -use h2_04::RecvStream; +use h2::server::Handshake; +use h2::server::SendResponse; +use h2::Reason; +use h2::RecvStream; use hyper1::upgrade::Upgraded; use hyper1::Method; use hyper1::Request; @@ -70,7 +70,7 @@ pub async fn run_wss2_server(port: u16) { .await; while let Some(Ok(tls)) = tls.next().await { tokio::spawn(async move { - let mut h2 = h2_04::server::Builder::new(); + let mut h2 = h2::server::Builder::new(); h2.enable_connect_protocol(); // Using Bytes is pretty alloc-heavy but this is a test server let server: Handshake<_, Bytes> = h2.handshake(tls); @@ -127,7 +127,7 @@ where S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + 'static, { let service = hyper1::service::service_fn( - move |mut req: http_1::Request| async move { + move |mut req: http::Request| async move { let (response, upgrade_fut) = fastwebsockets::upgrade::upgrade(&mut req) .map_err(|e| anyhow!("Error upgrading websocket connection: {}", e))?; @@ -161,13 +161,13 @@ where async fn handle_wss_stream( recv: Request, mut send: SendResponse, -) -> Result<(), h2_04::Error> { +) -> Result<(), h2::Error> { if recv.method() != Method::CONNECT { eprintln!("wss2: refusing non-CONNECT stream"); send.send_reset(Reason::REFUSED_STREAM); return Ok(()); } - let Some(protocol) = recv.extensions().get::() else { + let Some(protocol) = recv.extensions().get::() else { eprintln!("wss2: refusing no-:protocol stream"); send.send_reset(Reason::REFUSED_STREAM); return Ok(());