impl Body for IncomingBody. uncomment the BodyKind stuff and use it.

Author: pchickey

src/http/response.rs

@@ -16,39 +16,34 @@ pub struct Response<B: Body> {
     body: B,
 }
 
-// #[derive(Debug)]
-// enum BodyKind {
-//     Fixed(u64),
-//     Chunked,
-// }
-
-// impl BodyKind {
-//     fn from_headers(headers: &Fields) -> BodyKind {
-//         dbg!(&headers);
-//         if let Some(values) = headers.0.get("content-length") {
-//             let value = values
-//                 .get(0)
-//                 .expect("no value found for content-length; violates HTTP/1.1");
-//             let content_length = String::from_utf8(value.to_owned())
-//                 .unwrap()
-//                 .parse::<u64>()
-//                 .expect("content-length should be a u64; violates HTTP/1.1");
-//             BodyKind::Fixed(content_length)
-//         } else if let Some(values) = headers.0.get("transfer-encoding") {
-//             dbg!(values);
-//             BodyKind::Chunked
-//         } else {
-//             dbg!("Encoding neither has a content-length nor transfer-encoding");
-//             BodyKind::Chunked
-//         }
-//     }
-// }
+#[derive(Debug)]
+enum BodyKind {
+    Fixed(u64),
+    Chunked,
+}
+
+impl BodyKind {
+    fn from_headers(headers: &HeaderMap) -> BodyKind {
+        if let Some(value) = headers.get("content-length") {
+            let content_length = std::str::from_utf8(value.as_ref())
+                .unwrap()
+                .parse::<u64>()
+                .expect("content-length should be a u64; violates HTTP/1.1");
+            BodyKind::Fixed(content_length)
+        } else if headers.contains_key("transfer-encoding") {
+            BodyKind::Chunked
+        } else {
+            BodyKind::Chunked
+        }
+    }
+}
 
 impl Response<IncomingBody> {
     pub(crate) fn try_from_incoming_response(incoming: IncomingResponse) -> super::Result<Self> {
         let headers: HeaderMap = header_map_from_wasi(incoming.headers())?;
         let status = incoming.status().into();
 
+        let kind = BodyKind::from_headers(&headers);
         // `body_stream` is a child of `incoming_body` which means we cannot
         // drop the parent before we drop the child
         let incoming_body = incoming
@@ -59,6 +54,7 @@ impl Response<IncomingBody> {
             .expect("cannot call `stream` twice on an incoming body");
 
         let body = IncomingBody {
+            kind,
             buf_offset: 0,
             buf: None,
             body_stream,
@@ -97,6 +93,7 @@ impl<B: Body> Response<B> {
 /// An incoming HTTP body
 #[derive(Debug)]
 pub struct IncomingBody {
+    kind: BodyKind,
     buf: Option<Vec<u8>>,
     // How many bytes have we already read from the buf?
     buf_offset: usize,
@@ -147,3 +144,18 @@ impl AsyncRead for IncomingBody {
         Ok(len)
     }
 }
+
+impl Body for IncomingBody {
+    fn len(&self) -> Option<usize> {
+        match self.kind {
+            BodyKind::Fixed(l) => {
+                if l > (usize::MAX as u64) {
+                    None
+                } else {
+                    Some(l as usize)
+                }
+            }
+            BodyKind::Chunked => None,
+        }
+    }
+}