Merge pull request #58 from yoshuawuyts/update-errors

Update errors

Author: yoshuawuyts

src/client.rs

@@ -4,12 +4,13 @@ use async_std::io::{self, BufReader, Read, Write};
 use async_std::prelude::*;
 use async_std::task::{Context, Poll};
 use futures_core::ready;
+use http_types::{ensure, ensure_eq, format_err};
 use http_types::{
     headers::{HeaderName, HeaderValue, CONTENT_LENGTH, DATE, TRANSFER_ENCODING},
     Body, Request, Response, StatusCode,
 };
-use http_types::{Error, ErrorKind};
 
+use std::convert::TryFrom;
 use std::pin::Pin;
 use std::str::FromStr;
 
@@ -50,7 +51,7 @@ impl Encoder {
 }
 
 /// Opens an HTTP/1.1 connection to a remote host.
-pub async fn connect<RW>(mut stream: RW, req: Request) -> Result<Response, Error>
+pub async fn connect<RW>(mut stream: RW, req: Request) -> http_types::Result<Response>
 where
     RW: Read + Write + Send + Sync + Unpin + 'static,
 {
@@ -67,7 +68,7 @@ where
 
 /// Encode an HTTP request on the client.
 #[doc(hidden)]
-async fn encode(req: Request) -> Result<Encoder, Error> {
+async fn encode(req: Request) -> http_types::Result<Encoder> {
     let mut buf: Vec<u8> = vec![];
 
     let mut url = req.url().path().to_owned();
@@ -86,13 +87,8 @@ async fn encode(req: Request) -> Result<Encoder, Error> {
 
     // Insert Host header
     // Insert host
-    let host = req.url().host_str().ok_or_else(|| {
-        Error::from_str(
-            ErrorKind::InvalidInput,
-            "missing hostname",
-            StatusCode::BadRequest,
-        )
-    })?;
+    let host = req.url().host_str();
+    let host = host.ok_or_else(|| format_err!("Missing hostname"))?;
     let val = if let Some(port) = req.url().port() {
         format!("host: {}:{}\r\n", host, port)
     } else {
@@ -135,7 +131,7 @@ async fn encode(req: Request) -> Result<Encoder, Error> {
 
 /// Decode an HTTP response on the client.
 #[doc(hidden)]
-pub async fn decode<R>(reader: R) -> Result<Response, Error>
+pub async fn decode<R>(reader: R) -> http_types::Result<Response>
 where
     R: Read + Unpin + Send + Sync + 'static,
 {
@@ -148,9 +144,7 @@ where
     loop {
         let bytes_read = reader.read_until(b'\n', &mut buf).await?;
         // No more bytes are yielded from the stream.
-        if bytes_read == 0 {
-            panic!("empty response");
-        }
+        assert!(bytes_read != 0, "Empty response"); // TODO: ensure?
 
         // We've hit the end delimiter of the stream.
         let idx = buf.len() - 1;
@@ -161,37 +155,16 @@ where
 
     // Convert our header buf into an httparse instance, and validate.
     let status = httparse_res.parse(&buf)?;
-    if status.is_partial() {
-        return Err(Error::from_str(
-            ErrorKind::InvalidData,
-            "Malformed HTTP head",
-            StatusCode::BadRequest,
-        ));
-    }
-    let code = httparse_res.code.ok_or_else(|| {
-        Error::from_str(
-            ErrorKind::InvalidData,
-            "No status code found",
-            StatusCode::BadRequest,
-        )
-    })?;
-
-    // Convert httparse headers + body into a `http::Response` type.
-    let version = httparse_res.version.ok_or_else(|| {
-        Error::from_str(
-            ErrorKind::InvalidData,
-            "No version found",
-            StatusCode::BadRequest,
-        )
-    })?;
-    if version != 1 {
-        return Err(Error::from_str(
-            ErrorKind::InvalidData,
-            "Unsupported HTTP version",
-            StatusCode::BadRequest,
-        ));
-    }
-    use std::convert::TryFrom;
+    ensure!(!status.is_partial(), "Malformed HTTP head");
+
+    let code = httparse_res.code;
+    let code = code.ok_or_else(|| format_err!("No status code found"))?;
+
+    // Convert httparse headers + body into a `http_types::Response` type.
+    let version = httparse_res.version;
+    let version = version.ok_or_else(|| format_err!("No version found"))?;
+    ensure_eq!(version, 1, "Unsupported HTTP version");
+
     let mut res = Response::new(StatusCode::try_from(code)?);
     for header in httparse_res.headers.iter() {
         let name = HeaderName::from_str(header.name)?;
@@ -207,24 +180,18 @@ where
     let content_length = res.header(&CONTENT_LENGTH);
     let transfer_encoding = res.header(&TRANSFER_ENCODING);
 
-    if content_length.is_some() && transfer_encoding.is_some() {
-        // This is always an error.
-        return Err(Error::from_str(
-            ErrorKind::InvalidData,
-            "Unexpected Content-Length header",
-            StatusCode::BadRequest,
-        ));
-    }
+    ensure!(
+        content_length.is_none() || transfer_encoding.is_none(),
+        "Unexpected Content-Length header"
+    );
 
     // Check for Transfer-Encoding
     match transfer_encoding {
         Some(encoding) if !encoding.is_empty() => {
             if encoding.last().unwrap().as_str() == "chunked" {
                 let trailers_sender = res.send_trailers();
-                res.set_body(Body::from_reader(
-                    BufReader::new(ChunkedDecoder::new(reader, trailers_sender)),
-                    None,
-                ));
+                let reader = BufReader::new(ChunkedDecoder::new(reader, trailers_sender));
+                res.set_body(Body::from_reader(reader, None));
                 return Ok(res);
             }
             // Fall through to Content-Length

src/date.rs

@@ -2,7 +2,7 @@ use std::fmt::{self, Display, Formatter};
 use std::str::{from_utf8, FromStr};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
-use http_types::{Error, ErrorKind, StatusCode};
+use http_types::{bail, ensure, format_err};
 
 const IMF_FIXDATE_LENGTH: usize = 29;
 const RFC850_MAX_LENGTH: usize = 23;
@@ -39,7 +39,7 @@ pub struct HttpDate {
 /// ascdate formats. Two digit years are mapped to dates between
 /// 1970 and 2069.
 #[allow(dead_code)]
-pub(crate) fn parse_http_date(s: &str) -> Result<SystemTime, Error> {
+pub(crate) fn parse_http_date(s: &str) -> http_types::Result<SystemTime> {
     s.parse::<HttpDate>().map(|d| d.into())
 }
 
@@ -66,19 +66,15 @@ impl HttpDate {
     }
 }
 
-fn err(msg: &'static str) -> Error {
-    Error::from_str(ErrorKind::InvalidData, msg, StatusCode::BadRequest)
-}
-
-fn parse_imf_fixdate(s: &[u8]) -> Result<HttpDate, Error> {
+fn parse_imf_fixdate(s: &[u8]) -> http_types::Result<HttpDate> {
     // Example: `Sun, 06 Nov 1994 08:49:37 GMT`
     if s.len() != IMF_FIXDATE_LENGTH
         || &s[25..] != b" GMT"
         || s[16] != b' '
         || s[19] != b':'
         || s[22] != b':'
     {
-        return Err(err("Date time not in imf fixdate format"));
+        bail!("Date time not in imf fixdate format");
     }
     Ok(HttpDate {
         second: from_utf8(&s[23..25])?.parse()?,
@@ -98,7 +94,7 @@ fn parse_imf_fixdate(s: &[u8]) -> Result<HttpDate, Error> {
             b" Oct " => 10,
             b" Nov " => 11,
             b" Dec " => 12,
-            _ => return Err(err("Invalid Month")),
+            _ => bail!("Invalid Month"),
         },
         year: from_utf8(&s[12..16])?.parse()?,
         week_day: match &s[..5] {
@@ -109,16 +105,17 @@ fn parse_imf_fixdate(s: &[u8]) -> Result<HttpDate, Error> {
             b"Fri, " => 5,
             b"Sat, " => 6,
             b"Sun, " => 7,
-            _ => return Err(err("Invalid Day")),
+            _ => bail!("Invalid Day"),
         },
     })
 }
 
-fn parse_rfc850_date(s: &[u8]) -> Result<HttpDate, Error> {
+fn parse_rfc850_date(s: &[u8]) -> http_types::Result<HttpDate> {
     // Example: `Sunday, 06-Nov-94 08:49:37 GMT`
-    if s.len() < RFC850_MAX_LENGTH {
-        return Err(err("Date time not in rfc850 format"));
-    }
+    ensure!(
+        s.len() >= RFC850_MAX_LENGTH,
+        "Date time not in rfc850 format"
+    );
 
     fn week_day<'a>(s: &'a [u8], week_day: u8, name: &'static [u8]) -> Option<(u8, &'a [u8])> {
         if &s[0..name.len()] == name {
@@ -133,9 +130,9 @@ fn parse_rfc850_date(s: &[u8]) -> Result<HttpDate, Error> {
         .or_else(|| week_day(s, 5, b"Friday, "))
         .or_else(|| week_day(s, 6, b"Saturday, "))
         .or_else(|| week_day(s, 7, b"Sunday, "))
-        .ok_or_else(|| err("Invalid day"))?;
+        .ok_or_else(|| format_err!("Invalid day"))?;
     if s.len() != 22 || s[12] != b':' || s[15] != b':' || &s[18..22] != b" GMT" {
-        return Err(err("Date time not in rfc850 format"));
+        bail!("Date time not in rfc950 fmt");
     }
     let mut year = from_utf8(&s[7..9])?.parse::<u16>()?;
     if year < 70 {
@@ -161,18 +158,18 @@ fn parse_rfc850_date(s: &[u8]) -> Result<HttpDate, Error> {
             b"-Oct-" => 10,
             b"-Nov-" => 11,
             b"-Dec-" => 12,
-            _ => return Err(err("Invalid month")),
+            _ => bail!("Invalid month"),
         },
         year: year,
         week_day: week_day,
     })
 }
 
-fn parse_asctime(s: &[u8]) -> Result<HttpDate, Error> {
+fn parse_asctime(s: &[u8]) -> http_types::Result<HttpDate> {
     // Example: `Sun Nov  6 08:49:37 1994`
     if s.len() != ASCTIME_LENGTH || s[10] != b' ' || s[13] != b':' || s[16] != b':' || s[19] != b' '
     {
-        return Err(err("Date time not in asctime format"));
+        bail!("Date time not in asctime format");
     }
     Ok(HttpDate {
         second: from_utf8(&s[17..19])?.parse()?,
@@ -195,7 +192,7 @@ fn parse_asctime(s: &[u8]) -> Result<HttpDate, Error> {
             b"Oct " => 10,
             b"Nov " => 11,
             b"Dec " => 12,
-            _ => return Err(err("Invalid month")),
+            _ => bail!("Invalid month"),
         },
         year: from_utf8(&s[20..24])?.parse()?,
         week_day: match &s[0..4] {
@@ -206,7 +203,7 @@ fn parse_asctime(s: &[u8]) -> Result<HttpDate, Error> {
             b"Fri " => 5,
             b"Sat " => 6,
             b"Sun " => 7,
-            _ => return Err(err("Invalid day")),
+            _ => bail!("Invalid day"),
         },
     })
 }
@@ -329,19 +326,15 @@ impl From<HttpDate> for SystemTime {
 }
 
 impl FromStr for HttpDate {
-    type Err = Error;
+    type Err = http_types::Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if !s.is_ascii() {
-            return Err(err("Not ascii"));
-        }
+        ensure!(s.is_ascii(), "String slice is not valid ASCII");
         let x = s.trim().as_bytes();
         let date = parse_imf_fixdate(x)
             .or_else(|_| parse_rfc850_date(x))
             .or_else(|_| parse_asctime(x))?;
-        if !date.is_valid() {
-            return Err(err("Invalid date time"));
-        }
+        ensure!(date.is_valid(), "Invalid date time");
         Ok(date)
     }
 }