chore(misc): allow Body::channel() deprecation

see linkerd/linkerd2#8733.

`Body::channel()` is no longer exposed in hyper's 1.0 release.

this commit adds `#[allow(deprecated)]` attributes. an upstream patch
will mark this as deprecated.

* linkerd/linkerd2#8733
* hyperium/hyper#2962
* hyperium/hyper#2970

Signed-off-by: katelyn martin <kate@buoyant.io>

linkerd/app/admin/src/server/log/stream.rs

@@ -99,6 +99,7 @@ where
     // https://github.com/hawkw/thingbuf/issues/62 would allow us to avoid the
     // copy by passing the channel's pooled buffer directly to hyper, and
     // returning it to the channel to be reused when hyper is done with it.
+    #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
     let (mut tx, body) = hyper::Body::channel();
     tokio::spawn(
         async move {

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

@@ -711,6 +711,7 @@ fn grpc_status_server(
                     server_io,
                     hyper::service::service_fn(move |request: Request<hyper::Body>| async move {
                         tracing::info!(?request);
+                        #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
                         let (mut tx, rx) = hyper::Body::channel();
                         tokio::spawn(async move {
                             let mut trls = ::http::HeaderMap::new();

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

@@ -287,6 +287,7 @@ mod cross_version {
             .await;
 
         let client = test.client;
+        #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
         let (mut tx, body) = hyper::body::Body::channel();
         let req = client
             .request_builder("/0.5")
@@ -386,6 +387,7 @@ mod cross_version {
             .await;
 
         let client = test.client;
+        #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
         let (mut tx, body) = hyper::body::Body::channel();
         let req = client
             .request_builder("/0.5")
@@ -661,6 +663,7 @@ mod grpc_retry {
                     let mut trailers = HeaderMap::with_capacity(1);
                     trailers.insert(GRPC_STATUS.clone(), status);
                     tracing::debug!(?trailers);
+                    #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
                     let (mut tx, body) = hyper::body::Body::channel();
                     tx.send_trailers(trailers).await.unwrap();
                     Ok::<_, Error>(Response::builder().status(200).body(body).unwrap())
@@ -704,6 +707,7 @@ mod grpc_retry {
                     let mut trailers = HeaderMap::with_capacity(1);
                     trailers.insert(GRPC_STATUS.clone(), GRPC_STATUS_OK.clone());
                     tracing::debug!(?trailers);
+                    #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
                     let (mut tx, body) = hyper::body::Body::channel();
                     tx.send_data("hello world".into()).await.unwrap();
                     tx.send_trailers(trailers).await.unwrap();
@@ -752,6 +756,7 @@ mod grpc_retry {
                     let mut trailers = HeaderMap::with_capacity(1);
                     trailers.insert(GRPC_STATUS.clone(), GRPC_STATUS_OK.clone());
                     tracing::debug!(?trailers);
+                    #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
                     let (mut tx, body) = hyper::body::Body::channel();
                     tokio::spawn(async move {
                         tx.send_data("hello".into()).await.unwrap();

linkerd/app/outbound/src/http/logical/policy/route/backend/metrics/tests.rs

@@ -172,6 +172,7 @@ async fn body_data_layer_records_frames() -> Result<(), Error> {
     // Create a response whose body is backed by a channel that we can send chunks to, send it.
     tracing::info!("sending response");
     let mut resp_tx = {
+        #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
         let (tx, body) = hyper::Body::channel();
         let body = BoxBody::new(body);
         let resp = http::Response::builder()

linkerd/app/outbound/src/http/logical/policy/route/metrics/tests.rs

@@ -277,6 +277,7 @@ async fn http_route_request_body_frames() {
     // Create a request whose body is backed by a channel that we can send chunks to.
     tracing::info!("creating request");
     let (req, tx) = {
+        #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
         let (tx, body) = hyper::Body::channel();
         let body = BoxBody::new(body);
         let req = http::Request::builder()

linkerd/http/retry/src/replay.rs

@@ -829,6 +829,7 @@ mod tests {
         // initial body will complete, but the replay will immediately fail.
         let _trace = linkerd_tracing::test::with_default_filter("linkerd_http_retry=trace");
 
+        #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
         let (mut tx, body) = hyper::Body::channel();
         let mut initial = ReplayBody::try_new(body, 8).expect("channel body must not be too large");
         let mut replay = initial.clone();
@@ -859,6 +860,7 @@ mod tests {
         // cap, we allow the request to continue, but stop buffering.
         let _trace = linkerd_tracing::test::with_default_filter("linkerd_http_retry=debug");
 
+        #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
         let (mut tx, body) = hyper::Body::channel();
         let mut initial = ReplayBody::try_new(body, 8).expect("channel body must not be too large");
         let mut replay = initial.clone();
@@ -907,6 +909,7 @@ mod tests {
             "over-sized body is too big"
         );
 
+        #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
         let (_sender, body) = hyper::Body::channel();
         assert!(
             ReplayBody::try_new(body, max_size).is_ok(),
@@ -925,6 +928,7 @@ mod tests {
 
     impl Test {
         fn new() -> Self {
+            #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
             let (tx, body) = hyper::Body::channel();
             let initial = ReplayBody::try_new(body, 64 * 1024).expect("body too large");
             let replay = initial.clone();

linkerd/proxy/http/src/server/tests.rs

@@ -225,6 +225,7 @@ impl TestServer {
             _ = (&mut call0) => unreachable!("client cannot receive a response"),
             next = self.server.next_request() => next.expect("server not dropped"),
         };
+        #[allow(deprecated, reason = "linkerd/linkerd2#8733")]
         let (tx, rx) = hyper::Body::channel();
         next.send_response(http::Response::new(BoxBody::new(rx)));
         let rsp = call0.await.expect("response");