chore(hyper): address miscellaneous deprecations (#3444)

* chore(proxy/tap): address `Http` deprecation

this is a trivial deprecation fix, for
<linkerd/linkerd2#8733>.

Signed-off-by: katelyn martin <[email protected]>

* chore(app/outbound): address `Http` deprecation

see <linkerd/linkerd2#8733>.

this updates some test code to use the backported server connection
interfaces.

Signed-off-by: katelyn martin <[email protected]>

* chore(app/integration): address `conn::Builder` deprecation

this commit addresses uses of deprecated hyper interfaces in the
`linkerd-app-integration` crate.

see <linkerd/linkerd2#8733>.

Signed-off-by: katelyn martin <[email protected]>

* chore(app/inbound): remove stale `deprecated` allowance

this was fixed in a previous commit.

Signed-off-by: katelyn martin <[email protected]>

---------

Signed-off-by: katelyn martin <[email protected]>

Author: cratelyn

linkerd/app/inbound/src/http/tests.rs

@@ -651,7 +651,6 @@ fn hello_server(
 }
 
 #[tracing::instrument]
-#[allow(deprecated)] // linkerd/linkerd2#8733
 fn grpc_status_server(
     server: hyper::server::conn::http2::Builder<TracingExecutor>,
     status: tonic::Code,

linkerd/app/integration/Cargo.toml

@@ -23,6 +23,7 @@ h2 = "0.3"
 http = "0.2"
 http-body = "0.4"
 hyper = { version = "0.14", features = [
+    "backports",
     "deprecated",
     "http1",
     "http2",

linkerd/app/integration/src/controller.rs

@@ -372,9 +372,7 @@ where
                 let _ = listening_tx.send(());
             }
 
-            #[allow(deprecated)] // linkerd/linkerd2#8733
-            let mut http = hyper::server::conn::Http::new().with_executor(TracingExecutor);
-            http.http2_only(true);
+            let http = hyper::server::conn::http2::Builder::new(TracingExecutor);
             loop {
                 let (sock, addr) = listener.accept().await?;
                 let span = tracing::debug_span!("conn", %addr).or_current();

linkerd/app/integration/src/server.rs

@@ -194,12 +194,6 @@ impl Server {
             async move {
                 tracing::info!("support server running");
                 let mut new_svc = NewSvc(Arc::new(self.routes));
-                #[allow(deprecated)] // linkerd/linkerd2#8733
-                let mut http = hyper::server::conn::Http::new().with_executor(TracingExecutor);
-                match self.version {
-                    Run::Http1 => http.http1_only(true),
-                    Run::Http2 => http.http2_only(true),
-                };
                 if let Some(delay) = delay {
                     let _ = listening_tx.take().unwrap().send(());
                     delay.await;
@@ -218,7 +212,6 @@ impl Server {
                     let sock = accept_connection(sock, tls_config.clone())
                         .instrument(span.clone())
                         .await?;
-                    let http = http.clone();
                     let srv_conn_count = srv_conn_count.clone();
                     let svc = new_svc.call(());
                     let f = async move {
@@ -229,10 +222,16 @@ impl Server {
                         let svc = svc.map_err(|e| {
                             tracing::error!("support/server new_service error: {}", e)
                         })?;
-                        let result = http
-                            .serve_connection(sock, svc)
-                            .await
-                            .map_err(|e| tracing::error!("support/server error: {}", e));
+                        let result = match self.version {
+                            Run::Http1 => hyper::server::conn::http1::Builder::new()
+                                .serve_connection(sock, svc)
+                                .await
+                                .map_err(|e| tracing::error!("support/server error: {}", e)),
+                            Run::Http2 => hyper::server::conn::http2::Builder::new(TracingExecutor)
+                                .serve_connection(sock, svc)
+                                .await
+                                .map_err(|e| tracing::error!("support/server error: {}", e)),
+                        };
                         tracing::trace!(?result, "serve done");
                         result
                     };

linkerd/app/integration/src/tests/transparency.rs

@@ -1,4 +1,5 @@
 use crate::*;
+use linkerd_app_core::svc::http::TracingExecutor;
 use std::error::Error as _;
 use tokio::time::timeout;
 
@@ -1601,9 +1602,7 @@ async fn http2_request_without_authority() {
     let io = tokio::net::TcpStream::connect(&addr)
         .await
         .expect("connect error");
-    #[allow(deprecated)] // linkerd/linkerd2#8733
-    let (mut client, conn) = hyper::client::conn::Builder::new()
-        .http2_only(true)
+    let (mut client, conn) = hyper::client::conn::http2::Builder::new(TracingExecutor)
         .handshake(io)
         .await
         .expect("handshake error");

linkerd/app/outbound/Cargo.toml

@@ -54,7 +54,7 @@ linkerd-tonic-watch = { path = "../../tonic-watch" }
 [dev-dependencies]
 futures-util = "0.3"
 http-body = "0.4"
-hyper = { version = "0.14", features = ["deprecated", "http1", "http2"] }
+hyper = { version = "0.14", features = ["backports", "deprecated", "http1", "http2"] }
 tokio = { version = "1", features = ["macros", "sync", "time"] }
 tokio-rustls = "0.24"
 tokio-test = "0.4"

linkerd/app/outbound/src/http/endpoint/tests.rs

@@ -5,7 +5,7 @@ use linkerd_app_core::metrics::OutboundZoneLocality;
 use linkerd_app_core::{
     io,
     proxy::api_resolve::ProtocolHint,
-    svc::{NewService, ServiceExt},
+    svc::{http::TracingExecutor, NewService, ServiceExt},
     Infallible,
 };
 use std::net::SocketAddr;
@@ -239,16 +239,21 @@ fn serve(version: ::http::Version) -> io::Result<io::BoxedIo> {
         future::ok::<_, Infallible>(rsp.body(hyper::Body::default()).unwrap())
     });
 
-    #[allow(deprecated)] // linkerd/linkerd2#8733
-    let mut http = hyper::server::conn::Http::new();
+    let (client_io, server_io) = io::duplex(4096);
     match version {
-        ::http::Version::HTTP_10 | ::http::Version::HTTP_11 => http.http1_only(true),
-        ::http::Version::HTTP_2 => http.http2_only(true),
+        ::http::Version::HTTP_10 | ::http::Version::HTTP_11 => {
+            let http = hyper::server::conn::http1::Builder::new();
+            let fut = http.serve_connection(server_io, svc);
+            tokio::spawn(fut);
+        }
+        ::http::Version::HTTP_2 => {
+            let http = hyper::server::conn::http2::Builder::new(TracingExecutor);
+            let fut = http.serve_connection(server_io, svc);
+            tokio::spawn(fut);
+        }
         _ => unreachable!("unsupported HTTP version {:?}", version),
     };
 
-    let (client_io, server_io) = io::duplex(4096);
-    tokio::spawn(http.serve_connection(server_io, svc));
     Ok(io::BoxedIo::new(client_io))
 }
 

linkerd/proxy/tap/Cargo.toml

@@ -8,7 +8,7 @@ publish = false
 
 [dependencies]
 http = "0.2"
-hyper = { version = "0.14", features = ["deprecated", "http1", "http2"] }
+hyper = { version = "0.14", features = ["backports", "deprecated", "http1", "http2"] }
 futures = { version = "0.3", default-features = false }
 ipnet = "2.10"
 linkerd2-proxy-api = { workspace = true, features = ["tap"] }

linkerd/proxy/tap/src/accept.rs

@@ -45,10 +45,7 @@ impl AcceptPermittedClients {
     {
         let svc = TapServer::new(tap);
         Box::pin(async move {
-            #[allow(deprecated)] // linkerd/linkerd2#8733
-            hyper::server::conn::Http::new()
-                .with_executor(TracingExecutor)
-                .http2_only(true)
+            hyper::server::conn::http2::Builder::new(TracingExecutor)
                 .serve_connection(io, svc)
                 .await
                 .map_err(Into::into)