body helpers

actix-http/CHANGES.md

@@ -1,5 +1,15 @@
 # Changes
 
+### Added
+
+* Debug impl for ResponseBuilder
+
+* From SizedStream and BodyStream for Body
+
+### Changed
+
+* SizedStream accepts u64
+
 ## [0.2.2] - 2019-05-29
 
 ### Fixed

actix-http/src/body.rs

@@ -234,6 +234,25 @@ impl From<BytesMut> for Body {
     }
 }
 
+impl<S> From<SizedStream<S>> for Body
+where
+    S: Stream<Item = Bytes, Error = Error> + 'static,
+{
+    fn from(s: SizedStream<S>) -> Body {
+        Body::from_message(s)
+    }
+}
+
+impl<S, E> From<BodyStream<S, E>> for Body
+where
+    S: Stream<Item = Bytes, Error = E> + 'static,
+    E: Into<Error> + 'static,
+{
+    fn from(s: BodyStream<S, E>) -> Body {
+        Body::from_message(s)
+    }
+}
+
 impl MessageBody for Bytes {
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len())
@@ -366,7 +385,7 @@ where
 /// Type represent streaming body. This body implementation should be used
 /// if total size of stream is known. Data get sent as is without using transfer encoding.
 pub struct SizedStream<S> {
-    size: usize,
+    size: u64,
     stream: S,
 }
 
@@ -374,7 +393,7 @@ impl<S> SizedStream<S>
 where
     S: Stream<Item = Bytes, Error = Error>,
 {
-    pub fn new(size: usize, stream: S) -> Self {
+    pub fn new(size: u64, stream: S) -> Self {
         SizedStream { size, stream }
     }
 }
@@ -384,7 +403,7 @@ where
     S: Stream<Item = Bytes, Error = Error>,
 {
     fn size(&self) -> BodySize {
-        BodySize::Sized(self.size)
+        BodySize::Sized64(self.size)
     }
 
     fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {

actix-http/src/response.rs

@@ -764,6 +764,25 @@ impl IntoFuture for ResponseBuilder {
     }
 }
 
+impl fmt::Debug for ResponseBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let head = self.head.as_ref().unwrap();
+
+        let res = writeln!(
+            f,
+            "\nResponseBuilder {:?} {}{}",
+            head.version,
+            head.status,
+            head.reason.unwrap_or(""),
+        );
+        let _ = writeln!(f, "  headers:");
+        for (key, val) in head.headers.iter() {
+            let _ = writeln!(f, "    {:?}: {:?}", key, val);
+        }
+        res
+    }
+}
+
 /// Helper converters
 impl<I: Into<Response>, E: Into<Error>> From<Result<I, E>> for Response {
     fn from(res: Result<I, E>) -> Self {

actix-http/tests/test_server.rs

@@ -12,7 +12,6 @@ use futures::stream::{once, Stream};
 use regex::Regex;
 use tokio_timer::sleep;
 
-use actix_http::body::Body;
 use actix_http::error::PayloadError;
 use actix_http::{
     body, error, http, http::header, Error, HttpService, KeepAlive, Request, Response,
@@ -218,30 +217,28 @@ fn test_expect_continue_h1() {
 
 #[test]
 fn test_chunked_payload() {
-    let chunk_sizes = vec![ 32768, 32, 32768 ];
+    let chunk_sizes = vec![32768, 32, 32768];
     let total_size: usize = chunk_sizes.iter().sum();
 
     let srv = TestServer::new(|| {
-        HttpService::build()
+        HttpService::build().h1(|mut request: Request| {
-            .h1(|mut request: Request| {
+            request
-                request.take_payload()
+                .take_payload()
-                    .map_err(|e| panic!(format!("Error reading payload: {}", e)))
+                .map_err(|e| panic!(format!("Error reading payload: {}", e)))
-                    .fold(0usize, |acc, chunk| {
+                .fold(0usize, |acc, chunk| future::ok::<_, ()>(acc + chunk.len()))
-                        future::ok::<_, ()>(acc + chunk.len())
+                .map(|req_size| Response::Ok().body(format!("size={}", req_size)))
-                    })
+        })
-                    .map(|req_size| {
-                        Response::Ok().body(format!("size={}", req_size))
-                    })
-            })
     });
 
     let returned_size = {
         let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
-        let _ = stream.write_all(b"POST /test HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n");
+        let _ = stream
+            .write_all(b"POST /test HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n");
 
         for chunk_size in chunk_sizes.iter() {
             let mut bytes = Vec::new();
-            let random_bytes: Vec<u8> = (0..*chunk_size).map(|_| rand::random::<u8>()).collect();
+            let random_bytes: Vec<u8> =
+                (0..*chunk_size).map(|_| rand::random::<u8>()).collect();
 
             bytes.extend(format!("{:X}\r\n", chunk_size).as_bytes());
             bytes.extend(&random_bytes[..]);
@@ -826,8 +823,7 @@ fn test_h1_body_length() {
         HttpService::build().h1(|_| {
             let body = once(Ok(Bytes::from_static(STR.as_ref())));
             ok::<_, ()>(
-                Response::Ok()
+                Response::Ok().body(body::SizedStream::new(STR.len() as u64, body)),
-                    .body(Body::from_message(body::SizedStream::new(STR.len(), body))),
             )
         })
     });
@@ -852,9 +848,10 @@ fn test_h2_body_length() {
                 HttpService::build()
                     .h2(|_| {
                         let body = once(Ok(Bytes::from_static(STR.as_ref())));
-                        ok::<_, ()>(Response::Ok().body(Body::from_message(
+                        ok::<_, ()>(
-                            body::SizedStream::new(STR.len(), body),
+                            Response::Ok()
-                        )))
+                                .body(body::SizedStream::new(STR.len() as u64, body)),
+                        )
                     })
                     .map_err(|_| ()),
             )