rename body to recv temporarily

""" We'll eventually want to bikshed the name Recv, but to free up the name Body for #2839, this can be done quickly. """ Resolve #2963
hyperium · Aug 25, 2022 · 7039392 · 7039392
1 parent 9e8fc8f
commit 7039392
Show file tree

Hide file tree

Showing 29 changed files with 155 additions and 155 deletions.
diff --git a/examples/echo.rs b/examples/echo.rs
@@ -7,12 +7,12 @@ use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full};
 use hyper::body::HttpBody as _;
 use hyper::server::conn::Http;
 use hyper::service::service_fn;
-use hyper::{Body, Method, Request, Response, StatusCode};
+use hyper::{Recv, Method, Request, Response, StatusCode};
 use tokio::net::TcpListener;
 
 /// This is our service handler. It receives a Request, routes on its
 /// path, and returns a Future of a Response.
-async fn echo(req: Request<Body>) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
+async fn echo(req: Request<Recv>) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
     match (req.method(), req.uri().path()) {
         // Serve some instructions at /
         (&Method::GET, "/") => Ok(Response::new(full(

diff --git a/examples/hello.rs b/examples/hello.rs
@@ -7,10 +7,10 @@ use bytes::Bytes;
 use http_body_util::Full;
 use hyper::server::conn::Http;
 use hyper::service::service_fn;
-use hyper::{Body, Request, Response};
+use hyper::{Recv, Request, Response};
 use tokio::net::TcpListener;
 
-async fn hello(_: Request<Body>) -> Result<Response<Full<Bytes>>, Infallible> {
+async fn hello(_: Request<Recv>) -> Result<Response<Full<Bytes>>, Infallible> {
     Ok(Response::new(Full::new(Bytes::from("Hello World!"))))
 }
 

diff --git a/examples/http_proxy.rs b/examples/http_proxy.rs
@@ -8,7 +8,7 @@ use hyper::client::conn::Builder;
 use hyper::server::conn::Http;
 use hyper::service::service_fn;
 use hyper::upgrade::Upgraded;
-use hyper::{Body, Method, Request, Response};
+use hyper::{Recv, Method, Request, Response};
 
 use tokio::net::{TcpListener, TcpStream};
 
@@ -43,7 +43,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 }
 
-async fn proxy(req: Request<Body>) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
+async fn proxy(req: Request<Recv>) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
     println!("req: {:?}", req);
 
     if Method::CONNECT == req.method() {

diff --git a/examples/multi_server.rs b/examples/multi_server.rs
@@ -8,17 +8,17 @@ use futures_util::future::join;
 use http_body_util::Full;
 use hyper::server::conn::Http;
 use hyper::service::service_fn;
-use hyper::{Body, Request, Response};
+use hyper::{Recv, Request, Response};
 use tokio::net::TcpListener;
 
 static INDEX1: &[u8] = b"The 1st service!";
 static INDEX2: &[u8] = b"The 2nd service!";
 
-async fn index1(_: Request<Body>) -> Result<Response<Full<Bytes>>, hyper::Error> {
+async fn index1(_: Request<Recv>) -> Result<Response<Full<Bytes>>, hyper::Error> {
     Ok(Response::new(Full::new(Bytes::from(INDEX1))))
 }
 
-async fn index2(_: Request<Body>) -> Result<Response<Full<Bytes>>, hyper::Error> {
+async fn index2(_: Request<Recv>) -> Result<Response<Full<Bytes>>, hyper::Error> {
     Ok(Response::new(Full::new(Bytes::from(INDEX2))))
 }
 

diff --git a/examples/params.rs b/examples/params.rs
@@ -5,7 +5,7 @@ use bytes::Bytes;
 use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full};
 use hyper::server::conn::Http;
 use hyper::service::service_fn;
-use hyper::{Body, Method, Request, Response, StatusCode};
+use hyper::{Recv, Method, Request, Response, StatusCode};
 use tokio::net::TcpListener;
 
 use std::collections::HashMap;
@@ -19,7 +19,7 @@ static NOTNUMERIC: &[u8] = b"Number field is not numeric";
 
 // Using service_fn, we can turn this function into a `Service`.
 async fn param_example(
-    req: Request<Body>,
+    req: Request<Recv>,
 ) -> Result<Response<BoxBody<Bytes, Infallible>>, hyper::Error> {
     match (req.method(), req.uri().path()) {
         (&Method::GET, "/") | (&Method::GET, "/post") => Ok(Response::new(full(INDEX))),

diff --git a/examples/send_file.rs b/examples/send_file.rs
@@ -8,7 +8,7 @@ use tokio::net::TcpListener;
 use bytes::Bytes;
 use http_body_util::Full;
 use hyper::service::service_fn;
-use hyper::{Body, Method, Request, Response, Result, StatusCode};
+use hyper::{Recv, Method, Request, Response, Result, StatusCode};
 
 static INDEX: &str = "examples/send_file_index.html";
 static NOTFOUND: &[u8] = b"Not Found";
@@ -36,7 +36,7 @@ async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
     }
 }
 
-async fn response_examples(req: Request<Body>) -> Result<Response<Full<Bytes>>> {
+async fn response_examples(req: Request<Recv>) -> Result<Response<Full<Bytes>>> {
     match (req.method(), req.uri().path()) {
         (&Method::GET, "/") | (&Method::GET, "/index.html") => simple_file_send(INDEX).await,
         (&Method::GET, "/no_file.html") => {

diff --git a/examples/service_struct_impl.rs b/examples/service_struct_impl.rs
@@ -2,7 +2,7 @@ use bytes::Bytes;
 use http_body_util::Full;
 use hyper::server::conn::Http;
 use hyper::service::Service;
-use hyper::{Body, Request, Response};
+use hyper::{Recv, Request, Response};
 use tokio::net::TcpListener;
 
 use std::future::Future;
@@ -37,7 +37,7 @@ struct Svc {
     counter: Counter,
 }
 
-impl Service<Request<Body>> for Svc {
+impl Service<Request<Recv>> for Svc {
     type Response = Response<Full<Bytes>>;
     type Error = hyper::Error;
     type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
@@ -46,7 +46,7 @@ impl Service<Request<Body>> for Svc {
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, req: Request<Body>) -> Self::Future {
+    fn call(&mut self, req: Request<Recv>) -> Self::Future {
         fn mk_response(s: String) -> Result<Response<Full<Bytes>>, hyper::Error> {
             Ok(Response::builder().body(Full::new(Bytes::from(s))).unwrap())
         }

diff --git a/examples/upgrades.rs b/examples/upgrades.rs
@@ -14,7 +14,7 @@ use hyper::header::{HeaderValue, UPGRADE};
 use hyper::server::conn::Http;
 use hyper::service::service_fn;
 use hyper::upgrade::Upgraded;
-use hyper::{Body, Request, Response, StatusCode};
+use hyper::{Recv, Request, Response, StatusCode};
 
 // A simple type alias so as to DRY.
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
@@ -38,7 +38,7 @@ async fn server_upgraded_io(mut upgraded: Upgraded) -> Result<()> {
 }
 
 /// Our server HTTP handler to initiate HTTP upgrades.
-async fn server_upgrade(mut req: Request<Body>) -> Result<Response<Empty<Bytes>>> {
+async fn server_upgrade(mut req: Request<Recv>) -> Result<Response<Empty<Bytes>>> {
     let mut res = Response::new(Empty::new());
 
     // Send a 400 to any request that doesn't have

diff --git a/examples/web_api.rs b/examples/web_api.rs
@@ -6,7 +6,7 @@ use bytes::{Buf, Bytes};
 use http_body_util::{BodyExt, Full};
 use hyper::server::conn::Http;
 use hyper::service::service_fn;
-use hyper::{header, Body, Method, Request, Response, StatusCode};
+use hyper::{header, Recv, Method, Request, Response, StatusCode};
 use tokio::net::{TcpListener, TcpStream};
 
 type GenericError = Box<dyn std::error::Error + Send + Sync>;
@@ -46,7 +46,7 @@ async fn client_request_response() -> Result<Response<BoxBody>> {
     Ok(Response::new(res_body))
 }
 
-async fn api_post_response(req: Request<Body>) -> Result<Response<BoxBody>> {
+async fn api_post_response(req: Request<Recv>) -> Result<Response<BoxBody>> {
     // Aggregate the body...
     let whole_body = hyper::body::aggregate(req).await?;
     // Decode as JSON...
@@ -77,7 +77,7 @@ async fn api_get_response() -> Result<Response<BoxBody>> {
     Ok(res)
 }
 
-async fn response_examples(req: Request<Body>) -> Result<Response<BoxBody>> {
+async fn response_examples(req: Request<Recv>) -> Result<Response<BoxBody>> {
     match (req.method(), req.uri().path()) {
         (&Method::GET, "/") | (&Method::GET, "/index.html") => Ok(Response::new(full(INDEX))),
         (&Method::GET, "/test.html") => client_request_response().await,

diff --git a/src/body/body.rs b/src/body/body.rs
@@ -24,7 +24,7 @@ type TrailersSender = oneshot::Sender<HeaderMap>;
 /// Note: To read the full body, use [`body::to_bytes`](crate::body::to_bytes)
 /// or [`body::aggregate`](crate::body::aggregate).
 #[must_use = "streams do nothing unless polled"]
-pub struct Body {
+pub struct Recv {
     kind: Kind,
 }
 
@@ -70,16 +70,16 @@ pub struct Sender {
 const WANT_PENDING: usize = 1;
 const WANT_READY: usize = 2;
 
-impl Body {
+impl Recv {
     /// Create a `Body` stream with an associated sender half.
     ///
     /// Useful when wanting to stream chunks from another thread.
     #[inline]
-    pub fn channel() -> (Sender, Body) {
+    pub fn channel() -> (Sender, Recv) {
         Self::new_channel(DecodedLength::CHUNKED, /*wanter =*/ false)
     }
 
-    pub(crate) fn new_channel(content_length: DecodedLength, wanter: bool) -> (Sender, Body) {
+    pub(crate) fn new_channel(content_length: DecodedLength, wanter: bool) -> (Sender, Recv) {
         let (data_tx, data_rx) = mpsc::channel(0);
         let (trailers_tx, trailers_rx) = oneshot::channel();
 
@@ -94,7 +94,7 @@ impl Body {
             data_tx,
             trailers_tx: Some(trailers_tx),
         };
-        let rx = Body::new(Kind::Chan {
+        let rx = Recv::new(Kind::Chan {
             content_length,
             want_tx,
             data_rx,
@@ -104,18 +104,18 @@ impl Body {
         (tx, rx)
     }
 
-    fn new(kind: Kind) -> Body {
-        Body { kind }
+    fn new(kind: Kind) -> Recv {
+        Recv { kind }
     }
 
     #[allow(dead_code)]
-    pub(crate) fn empty() -> Body {
-        Body::new(Kind::Empty)
+    pub(crate) fn empty() -> Recv {
+        Recv::new(Kind::Empty)
     }
 
     #[cfg(feature = "ffi")]
-    pub(crate) fn ffi() -> Body {
-        Body::new(Kind::Ffi(crate::ffi::UserBody::new()))
+    pub(crate) fn ffi() -> Recv {
+        Recv::new(Kind::Ffi(crate::ffi::UserBody::new()))
     }
 
     #[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
@@ -129,7 +129,7 @@ impl Body {
         if !content_length.is_exact() && recv.is_end_stream() {
             content_length = DecodedLength::ZERO;
         }
-        let body = Body::new(Kind::H2 {
+        let body = Recv::new(Kind::H2 {
             ping,
             content_length,
             recv,
@@ -194,7 +194,7 @@ impl Body {
     }
 }
 
-impl HttpBody for Body {
+impl HttpBody for Recv {
     type Data = Bytes;
     type Error = crate::Error;
 
@@ -270,7 +270,7 @@ impl HttpBody for Body {
     }
 }
 
-impl fmt::Debug for Body {
+impl fmt::Debug for Recv {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         #[derive(Debug)]
         struct Streaming;
@@ -382,14 +382,14 @@ mod tests {
     use std::mem;
     use std::task::Poll;
 
-    use super::{Body, DecodedLength, HttpBody, Sender, SizeHint};
+    use super::{Recv, DecodedLength, HttpBody, Sender, SizeHint};
 
     #[test]
     fn test_size_of() {
         // These are mostly to help catch *accidentally* increasing
         // the size by too much.
 
-        let body_size = mem::size_of::<Body>();
+        let body_size = mem::size_of::<Recv>();
         let body_expected_size = mem::size_of::<u64>() * 6;
         assert!(
             body_size <= body_expected_size,
@@ -398,7 +398,7 @@ mod tests {
             body_expected_size,
         );
 
-        assert_eq!(body_size, mem::size_of::<Option<Body>>(), "Option<Body>");
+        assert_eq!(body_size, mem::size_of::<Option<Recv>>(), "Option<Body>");
 
         assert_eq!(
             mem::size_of::<Sender>(),
@@ -415,18 +415,18 @@ mod tests {
 
     #[test]
     fn size_hint() {
-        fn eq(body: Body, b: SizeHint, note: &str) {
+        fn eq(body: Recv, b: SizeHint, note: &str) {
             let a = body.size_hint();
             assert_eq!(a.lower(), b.lower(), "lower for {:?}", note);
             assert_eq!(a.upper(), b.upper(), "upper for {:?}", note);
         }
 
-        eq(Body::empty(), SizeHint::with_exact(0), "empty");
+        eq(Recv::empty(), SizeHint::with_exact(0), "empty");
 
-        eq(Body::channel().1, SizeHint::new(), "channel");
+        eq(Recv::channel().1, SizeHint::new(), "channel");
 
         eq(
-            Body::new_channel(DecodedLength::new(4), /*wanter =*/ false).1,
+            Recv::new_channel(DecodedLength::new(4), /*wanter =*/ false).1,
             SizeHint::with_exact(4),
             "channel with length",
         );
@@ -435,7 +435,7 @@ mod tests {
     #[cfg(not(miri))]
     #[tokio::test]
     async fn channel_abort() {
-        let (tx, mut rx) = Body::channel();
+        let (tx, mut rx) = Recv::channel();
 
         tx.abort();
 
@@ -446,7 +446,7 @@ mod tests {
     #[cfg(not(miri))]
     #[tokio::test]
     async fn channel_abort_when_buffer_is_full() {
-        let (mut tx, mut rx) = Body::channel();
+        let (mut tx, mut rx) = Recv::channel();
 
         tx.try_send_data("chunk 1".into()).expect("send 1");
         // buffer is full, but can still send abort
@@ -461,7 +461,7 @@ mod tests {
 
     #[test]
     fn channel_buffers_one() {
-        let (mut tx, _rx) = Body::channel();
+        let (mut tx, _rx) = Recv::channel();
 
         tx.try_send_data("chunk 1".into()).expect("send 1");
 
@@ -473,14 +473,14 @@ mod tests {
     #[cfg(not(miri))]
     #[tokio::test]
     async fn channel_empty() {
-        let (_, mut rx) = Body::channel();
+        let (_, mut rx) = Recv::channel();
 
         assert!(rx.data().await.is_none());
     }
 
     #[test]
     fn channel_ready() {
-        let (mut tx, _rx) = Body::new_channel(DecodedLength::CHUNKED, /*wanter = */ false);
+        let (mut tx, _rx) = Recv::new_channel(DecodedLength::CHUNKED, /*wanter = */ false);
 
         let mut tx_ready = tokio_test::task::spawn(tx.ready());
 
@@ -489,7 +489,7 @@ mod tests {
 
     #[test]
     fn channel_wanter() {
-        let (mut tx, mut rx) = Body::new_channel(DecodedLength::CHUNKED, /*wanter = */ true);
+        let (mut tx, mut rx) = Recv::new_channel(DecodedLength::CHUNKED, /*wanter = */ true);
 
         let mut tx_ready = tokio_test::task::spawn(tx.ready());
         let mut rx_data = tokio_test::task::spawn(rx.data());
@@ -510,7 +510,7 @@ mod tests {
 
     #[test]
     fn channel_notices_closure() {
-        let (mut tx, rx) = Body::new_channel(DecodedLength::CHUNKED, /*wanter = */ true);
+        let (mut tx, rx) = Recv::new_channel(DecodedLength::CHUNKED, /*wanter = */ true);
 
         let mut tx_ready = tokio_test::task::spawn(tx.ready());
 

diff --git a/src/body/mod.rs b/src/body/mod.rs
@@ -20,7 +20,7 @@ pub use http_body::Body as HttpBody;
 pub use http_body::SizeHint;
 
 pub use self::aggregate::aggregate;
-pub use self::body::{Body, Sender};
+pub use self::body::{Recv, Sender};
 pub(crate) use self::length::DecodedLength;
 pub use self::to_bytes::to_bytes;
 
@@ -33,6 +33,6 @@ fn _assert_send_sync() {
     fn _assert_send<T: Send>() {}
     fn _assert_sync<T: Sync>() {}
 
-    _assert_send::<Body>();
-    _assert_sync::<Body>();
+    _assert_send::<Recv>();
+    _assert_sync::<Recv>();
 }