Upgrade to Hyper 1.0 & Axum 0.7

examples/Cargo.toml

@@ -271,21 +271,21 @@ routeguide = ["dep:async-stream", "tokio-stream", "dep:rand", "dep:serde", "dep:
 reflection = ["dep:tonic-reflection"]
 autoreload = ["tokio-stream/net", "dep:listenfd"]
 health = ["dep:tonic-health"]
-grpc-web = ["dep:tonic-web", "dep:bytes", "dep:http", "dep:hyper", "dep:tracing-subscriber", "dep:tower"]
+grpc-web = ["dep:tonic-web", "dep:bytes", "dep:http", "dep:hyper", "dep:hyper-util", "dep:tracing-subscriber", "dep:tower"]
 tracing = ["dep:tracing", "dep:tracing-subscriber"]
-uds = ["tokio-stream/net", "dep:tower", "dep:hyper"]
+uds = ["tokio-stream/net", "dep:tower", "dep:hyper", "dep:hyper-util"]
 streaming = ["tokio-stream", "dep:h2"]
-mock = ["tokio-stream", "dep:tower"]
-tower = ["dep:hyper", "dep:tower", "dep:http"]
+mock = ["tokio-stream", "dep:tower", "dep:hyper-util"]
+tower = ["dep:hyper", "dep:hyper-util", "dep:tower", "dep:http"]
 json-codec = ["dep:serde", "dep:serde_json", "dep:bytes"]
 compression = ["tonic/gzip"]
 tls = ["tonic/tls"]
-tls-rustls = ["dep:hyper", "dep:hyper-rustls", "dep:tower", "tower-http/util", "tower-http/add-extension", "dep:rustls-pemfile", "dep:tokio-rustls"]
+tls-rustls = ["dep:hyper", "dep:hyper-util", "dep:hyper-rustls", "dep:tower", "tower-http/util", "tower-http/add-extension", "dep:rustls-pemfile", "dep:tokio-rustls", "dep:pin-project", "dep:http-body-util"]
 dynamic-load-balance = ["dep:tower"]
 timeout = ["tokio/time", "dep:tower"]
 tls-client-auth = ["tonic/tls"]
 types = ["dep:tonic-types"]
-h2c = ["dep:hyper", "dep:tower", "dep:http"]
+h2c = ["dep:hyper", "dep:tower", "dep:http", "dep:hyper-util"]
 cancellation = ["dep:tokio-util"]
 
 full = ["gcp", "routeguide", "reflection", "autoreload", "health", "grpc-web", "tracing", "uds", "streaming", "mock", "tower", "json-codec", "compression", "tls", "tls-rustls", "dynamic-load-balance", "timeout", "tls-client-auth", "types", "cancellation", "h2c"]
@@ -311,16 +311,19 @@ serde_json = { version = "1.0", optional = true }
 tracing = { version = "0.1.16", optional = true }
 tracing-subscriber = { version = "0.3", features = ["tracing-log", "fmt"], optional = true }
 prost-types = { version = "0.12", optional = true }
-http = { version = "0.2", optional = true }
-http-body = { version = "0.4.2", optional = true }
-hyper = { version = "0.14", optional = true }
+http = { version = "1", optional = true }
+http-body = { version = "1", optional = true }
+http-body-util = { version = "0.1", optional = true }
+hyper = { version = "1", optional = true }
+hyper-util = { version = ">=0.1.4, <0.2", optional = true }
 listenfd = { version = "1.0", optional = true }
 bytes = { version = "1", optional = true }
 h2 = { version = "0.3", optional = true }
-tokio-rustls = { version = "0.24.0", optional = true }
-hyper-rustls = { version = "0.24.0", features = ["http2"], optional = true }
-rustls-pemfile = { version = "1", optional = true }
-tower-http = { version = "0.4", optional = true }
+tokio-rustls = { version = "0.26", optional = true, features = ["ring", "tls12"], default-features = false }
+hyper-rustls = { version = "0.27.0", features = ["http2", "ring", "tls12"], optional = true, default-features = false }
+rustls-pemfile = { version = "2.0.0", optional = true }
+tower-http = { version = "0.5", optional = true }
+pin-project = { version = "1.0.11", optional = true }
 
 [build-dependencies]
 tonic-build = { path = "../tonic-build", features = ["prost"] }

examples/src/grpc-web/client.rs

@@ -1,4 +1,5 @@
 use hello_world::{greeter_client::GreeterClient, HelloRequest};
+use hyper_util::rt::TokioExecutor;
 use tonic_web::GrpcWebClientLayer;
 
 pub mod hello_world {
@@ -8,7 +9,7 @@ pub mod hello_world {
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Must use hyper directly...
-    let client = hyper::Client::builder().build_http();
+    let client = hyper_util::client::legacy::Client::builder(TokioExecutor::new()).build_http();
 
     let svc = tower::ServiceBuilder::new()
         .layer(GrpcWebClientLayer::new())

examples/src/h2c/client.rs

@@ -1,7 +1,8 @@
 use hello_world::greeter_client::GreeterClient;
 use hello_world::HelloRequest;
 use http::Uri;
-use hyper::Client;
+use hyper_util::client::legacy::Client;
+use hyper_util::rt::TokioExecutor;
 
 pub mod hello_world {
     tonic::include_proto!("helloworld");
@@ -11,7 +12,7 @@ pub mod hello_world {
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let origin = Uri::from_static("http://[::1]:50051");
     let h2c_client = h2c::H2cChannel {
-        client: Client::new(),
+        client: Client::builder(TokioExecutor::new()).build_http(),
     };
 
     let mut client = GreeterClient::with_origin(h2c_client, origin);
@@ -33,16 +34,20 @@ mod h2c {
         task::{Context, Poll},
     };
 
-    use hyper::{client::HttpConnector, Client};
-    use tonic::body::BoxBody;
+    use hyper::body::Incoming;
+    use hyper_util::{
+        client::legacy::{connect::HttpConnector, Client},
+        rt::TokioExecutor,
+    };
+    use tonic::body::{empty_body, BoxBody};
     use tower::Service;
 
     pub struct H2cChannel {
-        pub client: Client<HttpConnector>,
+        pub client: Client<HttpConnector, BoxBody>,
     }
 
     impl Service<http::Request<BoxBody>> for H2cChannel {
-        type Response = http::Response<hyper::Body>;
+        type Response = http::Response<Incoming>;
         type Error = hyper::Error;
         type Future =
             Pin<Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>>;
@@ -60,7 +65,7 @@ mod h2c {
                 let h2c_req = hyper::Request::builder()
                     .uri(origin)
                     .header(http::header::UPGRADE, "h2c")
-                    .body(hyper::Body::empty())
+                    .body(empty_body())
                     .unwrap();
 
                 let res = client.request(h2c_req).await.unwrap();
@@ -72,11 +77,11 @@ mod h2c {
                 let upgraded_io = hyper::upgrade::on(res).await.unwrap();
 
                 // In an ideal world you would somehow cache this connection
-                let (mut h2_client, conn) = hyper::client::conn::Builder::new()
-                    .http2_only(true)
-                    .handshake(upgraded_io)
-                    .await
-                    .unwrap();
+                let (mut h2_client, conn) =
+                    hyper::client::conn::http2::Builder::new(TokioExecutor::new())
+                        .handshake(upgraded_io)
+                        .await
+                        .unwrap();
                 tokio::spawn(conn);
 
                 h2_client.send_request(request).await

examples/src/h2c/server.rs

@@ -1,8 +1,13 @@
+use std::net::SocketAddr;
+
+use hyper_util::rt::{TokioExecutor, TokioIo};
+use hyper_util::server::conn::auto::Builder;
+use hyper_util::service::TowerToHyperService;
+use tokio::net::TcpListener;
 use tonic::{transport::Server, Request, Response, Status};
 
 use hello_world::greeter_server::{Greeter, GreeterServer};
 use hello_world::{HelloReply, HelloRequest};
-use tower::make::Shared;
 
 pub mod hello_world {
     tonic::include_proto!("helloworld");
@@ -28,28 +33,45 @@ impl Greeter for MyGreeter {
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let addr = "[::1]:50051".parse().unwrap();
+    let addr: SocketAddr = "[::1]:50051".parse().unwrap();
     let greeter = MyGreeter::default();
 
     println!("GreeterServer listening on {}", addr);
 
+    let incoming = TcpListener::bind(addr).await?;
     let svc = Server::builder()
         .add_service(GreeterServer::new(greeter))
         .into_router();
 
     let h2c = h2c::H2c { s: svc };
 
-    let server = hyper::Server::bind(&addr).serve(Shared::new(h2c));
-    server.await.unwrap();
-
-    Ok(())
+    loop {
+        match incoming.accept().await {
+            Ok((io, _)) => {
+                let router = h2c.clone();
+                tokio::spawn(async move {
+                    let builder = Builder::new(TokioExecutor::new());
+                    let conn = builder.serve_connection_with_upgrades(
+                        TokioIo::new(io),
+                        TowerToHyperService::new(router),
+                    );
+                    let _ = conn.await;
+                });
+            }
+            Err(e) => {
+                eprintln!("Error accepting connection: {}", e);
+            }
+        }
+    }
 }
 
 mod h2c {
     use std::pin::Pin;
 
     use http::{Request, Response};
-    use hyper::Body;
+    use hyper::body::Incoming;
+    use hyper_util::{rt::TokioExecutor, service::TowerToHyperService};
+    use tonic::{body::empty_body, transport::AxumBoxBody};
     use tower::Service;
 
     #[derive(Clone)]
@@ -59,17 +81,14 @@ mod h2c {
 
     type BoxError = Box<dyn std::error::Error + Send + Sync>;
 
-    impl<S> Service<Request<Body>> for H2c<S>
+    impl<S> Service<Request<Incoming>> for H2c<S>
     where
-        S: Service<Request<Body>, Response = Response<tonic::transport::AxumBoxBody>>
-            + Clone
-            + Send
-            + 'static,
+        S: Service<Request<Incoming>, Response = Response<AxumBoxBody>> + Clone + Send + 'static,
         S::Future: Send + 'static,
         S::Error: Into<BoxError> + Sync + Send + 'static,
         S::Response: Send + 'static,
     {
-        type Response = hyper::Response<Body>;
+        type Response = hyper::Response<tonic::body::BoxBody>;
         type Error = hyper::Error;
         type Future =
             Pin<Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>>;
@@ -81,20 +100,19 @@ mod h2c {
             std::task::Poll::Ready(Ok(()))
         }
 
-        fn call(&mut self, mut req: hyper::Request<Body>) -> Self::Future {
+        fn call(&mut self, mut req: hyper::Request<Incoming>) -> Self::Future {
             let svc = self.s.clone();
             Box::pin(async move {
                 tokio::spawn(async move {
                     let upgraded_io = hyper::upgrade::on(&mut req).await.unwrap();
 
-                    hyper::server::conn::Http::new()
-                        .http2_only(true)
-                        .serve_connection(upgraded_io, svc)
+                    hyper::server::conn::http2::Builder::new(TokioExecutor::new())
+                        .serve_connection(upgraded_io, TowerToHyperService::new(svc))
                         .await
                         .unwrap();
                 });
 
-                let mut res = hyper::Response::new(hyper::Body::empty());
+                let mut res = hyper::Response::new(empty_body());
                 *res.status_mut() = http::StatusCode::SWITCHING_PROTOCOLS;
                 res.headers_mut().insert(
                     hyper::header::UPGRADE,

examples/src/interceptor/server.rs

@@ -57,6 +57,7 @@ fn intercept(mut req: Request<()>) -> Result<Request<()>, Status> {
     Ok(req)
 }
 
+#[derive(Clone)]
 struct MyExtension {
     some_piece_of_data: String,
 }

examples/src/mock/mock.rs

@@ -1,3 +1,4 @@
+use hyper_util::rt::TokioIo;
 use tonic::{
     transport::{Endpoint, Server, Uri},
     Request, Response, Status,
@@ -36,7 +37,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
             async move {
                 if let Some(client) = client {
-                    Ok(client)
+                    Ok(TokioIo::new(client))
                 } else {
                     Err(std::io::Error::new(
                         std::io::ErrorKind::Other,

examples/src/tls_rustls/client.rs

@@ -5,7 +5,8 @@ pub mod pb {
     tonic::include_proto!("/grpc.examples.unaryecho");
 }
 
-use hyper::{client::HttpConnector, Uri};
+use hyper::Uri;
+use hyper_util::{client::legacy::connect::HttpConnector, rt::TokioExecutor};
 use pb::{echo_client::EchoClient, EchoRequest};
 use tokio_rustls::rustls::{ClientConfig, RootCertStore};
 
@@ -17,11 +18,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut roots = RootCertStore::empty();
 
     let mut buf = std::io::BufReader::new(&fd);
-    let certs = rustls_pemfile::certs(&mut buf)?;
-    roots.add_parsable_certificates(&certs);
+    let certs = rustls_pemfile::certs(&mut buf).collect::<Result<Vec<_>, _>>()?;
+    roots.add_parsable_certificates(certs.into_iter());
 
     let tls = ClientConfig::builder()
-        .with_safe_defaults()
         .with_root_certificates(roots)
         .with_no_client_auth();
 
@@ -47,7 +47,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .map_request(|_| Uri::from_static("https://[::1]:50051"))
         .service(http);
 
-    let client = hyper::Client::builder().build(connector);
+    let client = hyper_util::client::legacy::Client::builder(TokioExecutor::new()).build(connector);
 
     // Using `with_origin` will let the codegenerated client set the `scheme` and
     // `authority` from the porvided `Uri`.