Update http-types

Author: rylev

examples/server.rs

@@ -1,12 +1,16 @@
 use std::pin::Pin;
+use std::str::FromStr;
 use std::sync::Arc;
 
 use async_h1::server;
 use async_std::io::{self, Read, Write};
 use async_std::net::{self, TcpStream};
 use async_std::prelude::*;
 use async_std::task::{self, Context, Poll};
-use http_types::{Response, StatusCode};
+use http_types::{
+    headers::{HeaderName, HeaderValue},
+    Response, StatusCode,
+};
 
 async fn accept(addr: String, stream: TcpStream) -> Result<(), async_h1::Exception> {
     // println!("starting new connection from {}", stream.peer_addr()?);
@@ -16,9 +20,12 @@ async fn accept(addr: String, stream: TcpStream) -> Result<(), async_h1::Excepti
 
     server::accept(&addr, stream.clone(), stream, |_| {
         async {
-            let resp = Response::new(StatusCode::Ok)
-                .set_header("Content-Type", "text/plain")?
-                .set_body_string("Hello".into())?;
+            let mut resp = Response::new(StatusCode::Ok);
+            resp.insert_header(
+                HeaderName::from_str("Content-Type")?,
+                HeaderValue::from_str("text/plain")?,
+            )?;
+            resp.set_body("Hello");
             // To try chunked encoding, replace `set_body_string` with the following method call
             // .set_body(io::Cursor::new(vec![
             //     0x48u8, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21,

src/client.rs

@@ -5,9 +5,13 @@ use async_std::prelude::*;
 use async_std::task::{Context, Poll};
 use futures_core::ready;
 use futures_io::AsyncRead;
-use http_types::{Request, Response, StatusCode};
+use http_types::{
+    headers::{HeaderName, HeaderValue, CONTENT_LENGTH},
+    Body, Request, Response, StatusCode,
+};
 
 use std::pin::Pin;
+use std::str::FromStr;
 
 use crate::{Exception, MAX_HEADERS};
 
@@ -58,8 +62,10 @@ pub async fn encode(req: Request) -> Result<Encoder, std::io::Error> {
         // See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Transfer-Encoding
         //      https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Trailer
     }
-    for (header, value) in req.headers().iter() {
-        write!(&mut buf, "{}: {}\r\n", header, value).await?;
+    for (header, values) in req.iter() {
+        for value in values.iter() {
+            write!(&mut buf, "{}: {}\r\n", header, value).await?;
+        }
     }
 
     write!(&mut buf, "\r\n").await?;
@@ -107,22 +113,24 @@ where
     use std::convert::TryFrom;
     let mut res = Response::new(StatusCode::try_from(code)?);
     for header in httparse_res.headers.iter() {
-        res = res.set_header(header.name, std::str::from_utf8(header.value)?)?;
+        res.insert_header(
+            HeaderName::from_str(header.name)?,
+            HeaderValue::from_str(std::str::from_utf8(header.value)?)?,
+        )?;
     }
 
     // Process the body if `Content-Length` was passed.
-    if let Some(content_length) = httparse_res
-        .headers
-        .iter()
-        .find(|h| h.name.eq_ignore_ascii_case("Content-Length"))
-    {
-        let length = std::str::from_utf8(content_length.value)
-            .ok()
-            .and_then(|s| s.parse::<usize>().ok());
-
-        if let Some(_len) = length {
-            // TODO: set size
-            res = res.set_body(reader);
+    if let Some(content_length) = res.header(&CONTENT_LENGTH) {
+        let length = content_length
+            .last()
+            .unwrap()
+            .as_str()
+            .parse::<usize>()
+            .ok();
+
+        if let Some(len) = length {
+            res.set_body(Body::from_reader(reader));
+            res.set_len(len);
         } else {
             return Err("Invalid value for Content-Length".into());
         }

src/server.rs

@@ -6,7 +6,10 @@ use async_std::io::{Read, Write};
 use async_std::prelude::*;
 use async_std::task::{Context, Poll};
 use futures_core::ready;
-use http_types::{Method, Request, Response};
+use http_types::{
+    headers::{HeaderName, HeaderValue, CONTENT_TYPE},
+    Body, Method, Request, Response,
+};
 use std::fmt;
 use std::str::FromStr;
 use std::time::Duration;
@@ -140,11 +143,10 @@ impl Encoder {
         let date = fmt_http_date(std::time::SystemTime::now());
         std::io::Write::write_fmt(&mut head, format_args!("Date: {}\r\n", date))?;
 
-        for (header, value) in self.res.headers().iter() {
-            std::io::Write::write_fmt(
-                &mut head,
-                format_args!("{}: {}\r\n", header.as_str(), value),
-            )?
+        for (header, values) in self.res.iter() {
+            for value in values.iter() {
+                std::io::Write::write_fmt(&mut head, format_args!("{}: {}\r\n", header, value))?
+            }
         }
 
         std::io::Write::write_fmt(&mut head, format_args!("\r\n"))?;
@@ -390,16 +392,20 @@ where
     }
     let mut req = Request::new(Method::from_str(method)?, uri);
     for header in httparse_req.headers.iter() {
-        req = req.set_header(header.name, std::str::from_utf8(header.value)?)?;
+        req.insert_header(
+            HeaderName::from_str(header.name)?,
+            HeaderValue::from_str(std::str::from_utf8(header.value)?)?,
+        )?;
     }
 
     // Check for content-length, that determines determines whether we can parse
     // it with a known length, or need to use chunked encoding.
-    let len = match req.header("Content-Length") {
-        Some(len) => len.parse::<usize>()?,
+    let len = match req.header(&CONTENT_TYPE) {
+        Some(len) => len.last().unwrap().as_str().parse::<usize>()?,
         None => return Ok(Some(DecodedRequest::WithoutBody(req, Box::new(reader)))),
     };
-    req = req.set_body_reader(reader).set_len(len);
+    req.set_body(Body::from_reader(reader));
+    req.set_len(len);
     Ok(Some(DecodedRequest::WithBody(req)))
 }
 
@@ -436,7 +442,7 @@ impl DecodedRequest {
     /// When it does not, the underlying body has been passed alongside the request.
     fn into_reader(self) -> Box<dyn BufRead + Unpin + Send + 'static> {
         match self {
-            DecodedRequest::WithBody(r) => r.into_body_reader(),
+            DecodedRequest::WithBody(r) => r.into_body().into_reader(),
             DecodedRequest::WithoutBody(_, s) => s,
         }
     }

tests/fixtures/response1.txt

@@ -1,5 +1,5 @@
 HTTP/1.1 200 OK
 Content-Length: 0
 Date: {DATE}
-Content-Type: text/plain; charset=utf-8
+content-type: text/plain; charset=utf-8
 

tests/server.rs

@@ -16,7 +16,11 @@ fn test_basic_request() {
         actual,
         expected,
         server::accept(addr, Cursor::new(request), &mut actual, |_req| {
-            async { Ok(Response::new(StatusCode::Ok).set_body_string("".to_owned())?) }
+            async {
+                let mut resp = Response::new(StatusCode::Ok);
+                resp.set_body("");
+                Ok(resp)
+            }
         })
     );
 }