Merge pull request #48 from yoshuawuyts/fix-warnings

Migrate to new error types

Author: yoshuawuyts

examples/client.rs

@@ -5,9 +5,9 @@ use async_h1::client;
 use async_std::io::{self, Read, Write};
 use async_std::net::{self, TcpStream};
 use async_std::task::{self, Context, Poll};
-use http_types::{Method, Request, Url};
+use http_types::{Error, Method, Request, Url};
 
-fn main() -> Result<(), async_h1::Exception> {
+fn main() -> Result<(), Error> {
     task::block_on(async {
         let stream = net::TcpStream::connect("127.0.0.1:8080").await?;
         let peer_addr = stream.peer_addr()?;

examples/server.rs

@@ -8,9 +8,9 @@ use async_std::net::{self, TcpStream};
 use async_std::prelude::*;
 use async_std::task::{self, Context, Poll};
 use http_types::headers::{HeaderName, HeaderValue};
-use http_types::{Response, StatusCode};
+use http_types::{Error, Response, StatusCode};
 
-async fn accept(addr: String, stream: TcpStream) -> Result<(), async_h1::Exception> {
+async fn accept(addr: String, stream: TcpStream) -> Result<(), Error> {
     // println!("starting new connection from {}", stream.peer_addr()?);
 
     // TODO: Delete this line when we implement `Clone` for `TcpStream`.
@@ -35,7 +35,7 @@ async fn accept(addr: String, stream: TcpStream) -> Result<(), async_h1::Excepti
     .await
 }
 
-fn main() -> Result<(), async_h1::Exception> {
+fn main() -> Result<(), Error> {
     task::block_on(async {
         let listener = net::TcpListener::bind(("127.0.0.1", 8080)).await?;
         let addr = format!("http://{}", listener.local_addr()?);

src/client.rs

@@ -8,14 +8,14 @@ use http_types::{
     headers::{HeaderName, HeaderValue, CONTENT_LENGTH, DATE, TRANSFER_ENCODING},
     Body, Request, Response, StatusCode,
 };
+use http_types::{Error, ErrorKind};
 
 use std::pin::Pin;
 use std::str::FromStr;
 
 use crate::chunked::ChunkedDecoder;
 use crate::date::fmt_http_date;
-use crate::error::HttpError;
-use crate::{Exception, MAX_HEADERS};
+use crate::MAX_HEADERS;
 
 /// An HTTP encoder.
 #[derive(Debug)]
@@ -98,7 +98,7 @@ pub async fn encode(req: Request) -> Result<Encoder, std::io::Error> {
 }
 
 /// Decode an HTTP response on the client.
-pub async fn decode<R>(reader: R) -> Result<Response, Exception>
+pub async fn decode<R>(reader: R) -> Result<Response, Error>
 where
     R: Read + Unpin + Send + Sync + 'static,
 {
@@ -125,15 +125,34 @@ where
     // Convert our header buf into an httparse instance, and validate.
     let status = httparse_res.parse(&buf)?;
     if status.is_partial() {
-        dbg!(String::from_utf8(buf).unwrap());
-        return Err("Malformed HTTP head".into());
+        return Err(Error::from_str(
+            ErrorKind::InvalidData,
+            "Malformed HTTP head",
+            StatusCode::BadRequest,
+        ));
     }
-    let code = httparse_res.code.ok_or_else(|| "No status code found")?;
+    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(|| "No version found")?;
+    let version = httparse_res.version.ok_or_else(|| {
+        Error::from_str(
+            ErrorKind::InvalidData,
+            "No version found",
+            StatusCode::BadRequest,
+        )
+    })?;
     if version != 1 {
-        return Err("Unsupported HTTP version".into());
+        return Err(Error::from_str(
+            ErrorKind::InvalidData,
+            "Unsupported HTTP version",
+            StatusCode::BadRequest,
+        ));
     }
     use std::convert::TryFrom;
     let mut res = Response::new(StatusCode::try_from(code)?);
@@ -153,7 +172,11 @@ where
 
     if content_length.is_some() && transfer_encoding.is_some() {
         // This is always an error.
-        return Err(HttpError::UnexpectedContentLengthHeader.into());
+        return Err(Error::from_str(
+            ErrorKind::InvalidData,
+            "Unexpected Content-Length header",
+            StatusCode::BadRequest,
+        ));
     }
 
     // Check for Transfer-Encoding

src/date.rs

@@ -1,8 +1,9 @@
-use crate::Exception;
 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};
+
 const IMF_FIXDATE_LENGTH: usize = 29;
 const RFC850_MAX_LENGTH: usize = 23;
 const ASCTIME_LENGTH: usize = 24;
@@ -37,7 +38,7 @@ pub struct HttpDate {
 /// Supports the preferred IMF-fixdate and the legacy RFC 805 and
 /// ascdate formats. Two digit years are mapped to dates between
 /// 1970 and 2069.
-pub(crate) fn parse_http_date(s: &str) -> Result<SystemTime, Exception> {
+pub(crate) fn parse_http_date(s: &str) -> Result<SystemTime, Error> {
     s.parse::<HttpDate>().map(|d| d.into())
 }
 
@@ -64,15 +65,19 @@ impl HttpDate {
     }
 }
 
-fn parse_imf_fixdate(s: &[u8]) -> Result<HttpDate, Exception> {
+fn err(msg: &'static str) -> Error {
+    Error::from_str(ErrorKind::InvalidData, msg, StatusCode::BadRequest)
+}
+
+fn parse_imf_fixdate(s: &[u8]) -> Result<HttpDate, Error> {
     // 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("Date time not in imf fixdate format".into());
+        return Err(err("Date time not in imf fixdate format"));
     }
     Ok(HttpDate {
         second: from_utf8(&s[23..25])?.parse()?,
@@ -92,7 +97,7 @@ fn parse_imf_fixdate(s: &[u8]) -> Result<HttpDate, Exception> {
             b" Oct " => 10,
             b" Nov " => 11,
             b" Dec " => 12,
-            _ => return Err("Invalid Month".into()),
+            _ => return Err(err("Invalid Month")),
         },
         year: from_utf8(&s[12..16])?.parse()?,
         week_day: match &s[..5] {
@@ -103,15 +108,15 @@ fn parse_imf_fixdate(s: &[u8]) -> Result<HttpDate, Exception> {
             b"Fri, " => 5,
             b"Sat, " => 6,
             b"Sun, " => 7,
-            _ => return Err("Invalid Day".into()),
+            _ => return Err(err("Invalid Day")),
         },
     })
 }
 
-fn parse_rfc850_date(s: &[u8]) -> Result<HttpDate, Exception> {
+fn parse_rfc850_date(s: &[u8]) -> Result<HttpDate, Error> {
     // Example: `Sunday, 06-Nov-94 08:49:37 GMT`
     if s.len() < RFC850_MAX_LENGTH {
-        return Err("Date time not in rfc850 format".into());
+        return Err(err("Date time not in rfc850 format"));
     }
 
     fn week_day<'a>(s: &'a [u8], week_day: u8, name: &'static [u8]) -> Option<(u8, &'a [u8])> {
@@ -127,9 +132,9 @@ fn parse_rfc850_date(s: &[u8]) -> Result<HttpDate, Exception> {
         .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::<&'static str>("Invalid day")?;
+        .ok_or_else(|| err("Invalid day"))?;
     if s.len() != 22 || s[12] != b':' || s[15] != b':' || &s[18..22] != b" GMT" {
-        return Err("Date time not in rfc850 format".into());
+        return Err(err("Date time not in rfc850 format"));
     }
     let mut year = from_utf8(&s[7..9])?.parse::<u16>()?;
     if year < 70 {
@@ -155,18 +160,18 @@ fn parse_rfc850_date(s: &[u8]) -> Result<HttpDate, Exception> {
             b"-Oct-" => 10,
             b"-Nov-" => 11,
             b"-Dec-" => 12,
-            _ => return Err("Invalid month".into()),
+            _ => return Err(err("Invalid month")),
         },
         year: year,
         week_day: week_day,
     })
 }
 
-fn parse_asctime(s: &[u8]) -> Result<HttpDate, Exception> {
+fn parse_asctime(s: &[u8]) -> Result<HttpDate, Error> {
     // 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("Date time not in asctime format".into());
+        return Err(err("Date time not in asctime format"));
     }
     Ok(HttpDate {
         second: from_utf8(&s[17..19])?.parse()?,
@@ -189,7 +194,7 @@ fn parse_asctime(s: &[u8]) -> Result<HttpDate, Exception> {
             b"Oct " => 10,
             b"Nov " => 11,
             b"Dec " => 12,
-            _ => return Err("Invalid month".into()),
+            _ => return Err(err("Invalid month")),
         },
         year: from_utf8(&s[20..24])?.parse()?,
         week_day: match &s[0..4] {
@@ -200,7 +205,7 @@ fn parse_asctime(s: &[u8]) -> Result<HttpDate, Exception> {
             b"Fri " => 5,
             b"Sat " => 6,
             b"Sun " => 7,
-            _ => return Err("Invalid day".into()),
+            _ => return Err(err("Invalid day")),
         },
     })
 }
@@ -323,18 +328,18 @@ impl From<HttpDate> for SystemTime {
 }
 
 impl FromStr for HttpDate {
-    type Err = Exception;
+    type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if !s.is_ascii() {
-            return Err("Not ascii".into());
+            return Err(err("Not 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("Invalid date time".into());
+            return Err(err("Invalid date time"));
         }
         Ok(date)
     }

src/error.rs

@@ -39,15 +39,9 @@ const MAX_HEADERS: usize = 128;
 pub use check::check;
 
 mod check;
-mod error;
-
-pub use crate::error::HttpError;
 
 pub mod client;
 pub mod server;
 
 mod chunked;
 mod date;
-
-/// A generic fallible type.
-pub type Exception = Box<dyn std::error::Error + Send + Sync + 'static>;

src/lib.rs

@@ -11,24 +11,23 @@ use async_std::prelude::*;
 use async_std::task::{Context, Poll};
 use futures_core::ready;
 use http_types::headers::{HeaderName, HeaderValue, CONTENT_LENGTH, TRANSFER_ENCODING};
-use http_types::{Body, Method, Request, Response};
+use http_types::{Body, Error, ErrorKind, Method, Request, Response, StatusCode};
 
 use crate::chunked::ChunkedDecoder;
 use crate::date::fmt_http_date;
-use crate::error::HttpError;
-use crate::{Exception, MAX_HEADERS};
+use crate::MAX_HEADERS;
 
 const CR: u8 = b'\r';
 const LF: u8 = b'\n';
 
 /// Parse an incoming HTTP connection.
 ///
 /// Supports `KeepAlive` requests by default.
-pub async fn accept<RW, F, Fut>(addr: &str, mut io: RW, endpoint: F) -> Result<(), Exception>
+pub async fn accept<RW, F, Fut>(addr: &str, mut io: RW, endpoint: F) -> http_types::Result<()>
 where
     RW: Read + Write + Clone + Send + Sync + Unpin + 'static,
     F: Fn(Request) -> Fut,
-    Fut: Future<Output = Result<Response, Exception>>,
+    Fut: Future<Output = Result<Response, Error>>,
 {
     // TODO: make configurable
     let timeout_duration = Duration::from_secs(10);
@@ -56,7 +55,7 @@ where
             req = match timeout(timeout_duration, decode(addr, io.clone())).await {
                 Ok(Ok(Some(r))) => r,
                 Ok(Ok(None)) | Err(TimeoutError { .. }) => break, /* EOF or timeout */
-                Ok(Err(e)) => return Err(e),
+                Ok(Err(e)) => return Err(e).into(),
             };
             // Loop back with the new request and stream and start again
         }
@@ -336,7 +335,7 @@ impl Read for Encoder {
 const HTTP_1_1_VERSION: u8 = 1;
 
 /// Decode an HTTP request on the server.
-async fn decode<R>(addr: &str, reader: R) -> Result<Option<Request>, Exception>
+async fn decode<R>(addr: &str, reader: R) -> Result<Option<Request>, Error>
 where
     R: Read + Unpin + Send + Sync + 'static,
 {
@@ -362,18 +361,23 @@ where
 
     // Convert our header buf into an httparse instance, and validate.
     let status = httparse_req.parse(&buf)?;
+
+    let err = |msg| Error::from_str(ErrorKind::InvalidData, msg, StatusCode::BadRequest);
+
     if status.is_partial() {
-        return Err("Malformed HTTP head".into());
+        return Err(err("Malformed HTTP head"));
     }
 
     // Convert httparse headers + body into a `http::Request` type.
-    let method = httparse_req.method.ok_or_else(|| "No method found")?;
-    let uri = httparse_req.path.ok_or_else(|| "No uri found")?;
+    let method = httparse_req.method.ok_or_else(|| err("No method found"))?;
+    let uri = httparse_req.path.ok_or_else(|| err("No uri found"))?;
     let uri = url::Url::parse(&format!("{}{}", addr, uri))?;
 
-    let version = httparse_req.version.ok_or_else(|| "No version found")?;
+    let version = httparse_req
+        .version
+        .ok_or_else(|| err("No version found"))?;
     if version != HTTP_1_1_VERSION {
-        return Err("Unsupported HTTP version".into());
+        return Err(err("Unsupported HTTP version"));
     }
 
     let mut req = Request::new(Method::from_str(method)?, uri);
@@ -388,7 +392,11 @@ where
 
     if content_length.is_some() && transfer_encoding.is_some() {
         // This is always an error.
-        return Err(HttpError::UnexpectedContentLengthHeader.into());
+        return Err(Error::from_str(
+            ErrorKind::InvalidData,
+            "Unexpected Content-Length header",
+            StatusCode::BadRequest,
+        ));
     }
 
     // Check for Transfer-Encoding

src/server.rs

@@ -63,7 +63,7 @@ impl TestCase {
         expected
     }
 
-    pub async fn assert(self) {
+    pub(crate) async fn assert(self) {
         let mut actual = self.read_result().await;
         let mut expected = self.read_expected().await;
         assert!(!actual.is_empty(), "Received empty reply");