Merge pull request #71 from yoshuawuyts/box-errs

Remove ErrorKind

Author: yoshuawuyts

src/error.rs

@@ -2,7 +2,6 @@
 
 use std::error::Error as StdError;
 use std::fmt::{self, Debug, Display};
-use std::io;
 
 use crate::StatusCode;
 
@@ -12,146 +11,9 @@ use crate::StatusCode;
 /// produce an error.
 pub type Result<T> = std::result::Result<T, Error>;
 
-/// A list specifying general categories of HTTP errors.
-///
-/// This list is intended to grow over time and it is not recommended to
-/// exhaustively match against it.
-///
-/// It is used with the [`http_types::Error`] type.
-///
-/// [`http_types::Error`]: struct.Error.html
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[non_exhaustive]
-pub enum ErrorKind {
-    /// An entity was not found, often a file.
-    NotFound,
-    /// The operation lacked the necessary privileges to complete.
-    PermissionDenied,
-    /// The connection was refused by the remote server.
-    ConnectionRefused,
-    /// The connection was reset by the remote server.
-    ConnectionReset,
-    /// The connection was aborted (terminated) by the remote server.
-    ConnectionAborted,
-    /// The network operation failed because it was not connected yet.
-    NotConnected,
-    /// A socket address could not be bound because the address is already in
-    /// use elsewhere.
-    AddrInUse,
-    /// A nonexistent interface was requested or the requested address was not
-    /// local.
-    AddrNotAvailable,
-    /// The operation failed because a pipe was closed.
-    BrokenPipe,
-    /// An entity already exists, often a file.
-    AlreadyExists,
-    /// The operation needs to block to complete, but the blocking operation was
-    /// requested to not occur.
-    WouldBlock,
-    /// A parameter was incorrect.
-    InvalidInput,
-    /// Data not valid for the operation were encountered.
-    ///
-    /// Unlike [`InvalidInput`], this typically means that the operation
-    /// parameters were valid, however the error was caused by malformed
-    /// input data.
-    ///
-    /// For example, a function that reads a file into a string will error with
-    /// `InvalidData` if the file's contents are not valid UTF-8.
-    ///
-    /// [`InvalidInput`]: #variant.InvalidInput
-    InvalidData,
-    /// The I/O operation's timeout expired, causing it to be canceled.
-    TimedOut,
-    /// An error returned when an operation could not be completed because a
-    /// call to [`write`] returned [`Ok(0)`].
-    ///
-    /// This typically means that an operation could only succeed if it wrote a
-    /// particular number of bytes but only a smaller number of bytes could be
-    /// written.
-    ///
-    /// [`write`]: ../../std/io/trait.Write.html#tymethod.write
-    /// [`Ok(0)`]: ../../std/io/type.Result.html
-    WriteZero,
-    /// This operation was interrupted.
-    ///
-    /// Interrupted operations can typically be retried.
-    Interrupted,
-    /// Any I/O error not part of this list.
-    Other,
-
-    /// An error returned when an operation could not be completed because an
-    /// "end of file" was reached prematurely.
-    ///
-    /// This typically means that an operation could only succeed if it read a
-    /// particular number of bytes but only a smaller number of bytes could be
-    /// read.
-    UnexpectedEof,
-}
-
-impl From<io::ErrorKind> for ErrorKind {
-    fn from(kind: io::ErrorKind) -> Self {
-        match kind {
-            io::ErrorKind::NotFound => ErrorKind::NotFound,
-            io::ErrorKind::PermissionDenied => ErrorKind::PermissionDenied,
-            io::ErrorKind::ConnectionRefused => ErrorKind::ConnectionRefused,
-            io::ErrorKind::ConnectionReset => ErrorKind::ConnectionReset,
-            io::ErrorKind::ConnectionAborted => ErrorKind::ConnectionAborted,
-            io::ErrorKind::NotConnected => ErrorKind::NotConnected,
-            io::ErrorKind::AddrInUse => ErrorKind::AddrInUse,
-            io::ErrorKind::AddrNotAvailable => ErrorKind::AddrNotAvailable,
-            io::ErrorKind::BrokenPipe => ErrorKind::BrokenPipe,
-            io::ErrorKind::AlreadyExists => ErrorKind::AlreadyExists,
-            io::ErrorKind::WouldBlock => ErrorKind::WouldBlock,
-            io::ErrorKind::InvalidInput => ErrorKind::InvalidInput,
-            io::ErrorKind::InvalidData => ErrorKind::InvalidData,
-            io::ErrorKind::TimedOut => ErrorKind::TimedOut,
-            io::ErrorKind::WriteZero => ErrorKind::WriteZero,
-            io::ErrorKind::Interrupted => ErrorKind::Interrupted,
-            io::ErrorKind::UnexpectedEof => ErrorKind::UnexpectedEof,
-            io::ErrorKind::Other => ErrorKind::Other,
-            _ => ErrorKind::Other,
-        }
-    }
-}
-
-impl From<ErrorKind> for io::Error {
-    fn from(kind: ErrorKind) -> Self {
-        let kind = match kind {
-            ErrorKind::NotFound => io::ErrorKind::NotFound,
-            ErrorKind::PermissionDenied => io::ErrorKind::PermissionDenied,
-            ErrorKind::ConnectionRefused => io::ErrorKind::ConnectionRefused,
-            ErrorKind::ConnectionReset => io::ErrorKind::ConnectionReset,
-            ErrorKind::ConnectionAborted => io::ErrorKind::ConnectionAborted,
-            ErrorKind::NotConnected => io::ErrorKind::NotConnected,
-            ErrorKind::AddrInUse => io::ErrorKind::AddrInUse,
-            ErrorKind::AddrNotAvailable => io::ErrorKind::AddrNotAvailable,
-            ErrorKind::BrokenPipe => io::ErrorKind::BrokenPipe,
-            ErrorKind::AlreadyExists => io::ErrorKind::AlreadyExists,
-            ErrorKind::WouldBlock => io::ErrorKind::WouldBlock,
-            ErrorKind::InvalidInput => io::ErrorKind::InvalidInput,
-            ErrorKind::InvalidData => io::ErrorKind::InvalidData,
-            ErrorKind::TimedOut => io::ErrorKind::TimedOut,
-            ErrorKind::WriteZero => io::ErrorKind::WriteZero,
-            ErrorKind::Interrupted => io::ErrorKind::Interrupted,
-            ErrorKind::UnexpectedEof => io::ErrorKind::UnexpectedEof,
-            ErrorKind::Other => io::ErrorKind::Other,
-        };
-        io::Error::from(kind)
-    }
-}
-
-/// Internal representation of the error state.
-#[derive(Debug)]
-enum Repr {
-    Io(io::Error),
-    Custom(anyhow::Error),
-}
-
 /// The error type for HTTP operations.
 pub struct Error {
-    repr: Repr,
-    kind: ErrorKind,
+    error: anyhow::Error,
     status: crate::StatusCode,
 }
 
@@ -161,27 +23,24 @@ impl Error {
     /// The error type must be threadsafe and 'static, so that the Error will be
     /// as well. If the error type does not provide a backtrace, a backtrace will
     /// be created here to ensure that a backtrace exists.
-    pub fn new<E>(kind: ErrorKind, error: E, status: StatusCode) -> Self
+    pub fn new<E>(status: StatusCode, error: E) -> Self
     where
         E: StdError + Send + Sync + 'static,
     {
-        let error = anyhow::Error::new(error);
         Self {
-            kind,
-            repr: Repr::Custom(error),
             status,
+            error: anyhow::Error::new(error),
         }
     }
 
     /// Create a new error object from static string.
-    pub fn from_str<M>(kind: ErrorKind, msg: M, status: StatusCode) -> Self
+    pub fn from_str<M>(status: StatusCode, msg: M) -> Self
     where
         M: Display + Debug + Send + Sync + 'static,
     {
         Self {
-            kind,
-            repr: Repr::Custom(anyhow::format_err!(msg)),
             status,
+            error: anyhow::Error::msg(msg),
         }
     }
 
@@ -190,16 +49,7 @@ impl Error {
     where
         M: Display + Debug + Send + Sync + 'static,
     {
-        Self::from_str(ErrorKind::Other, message, StatusCode::InternalServerError)
-    }
-
-    /// Create a new error object from an I/O error.
-    pub fn from_io(error: std::io::Error, status: StatusCode) -> Self {
-        Self {
-            kind: error.kind().into(),
-            repr: Repr::Io(error),
-            status,
-        }
+        Self::from_str(StatusCode::InternalServerError, message)
     }
 
     /// Get the status code associated with this error.
@@ -212,11 +62,6 @@ impl Error {
         self.status = status;
     }
 
-    /// Returns the corresponding ErrorKind for this error.
-    pub fn kind(&self) -> ErrorKind {
-        self.kind.clone()
-    }
-
     /// Get the backtrace for this Error.
     ///
     /// Backtraces are only available on the nightly channel. Tracking issue:
@@ -230,21 +75,18 @@ impl Error {
     /// [tracking]: https://github.com/rust-lang/rust/issues/53487
     #[cfg(backtrace)]
     pub fn backtrace(&self) -> &std::backtrace::Backtrace {
-        match self {
-            Repr::Io => std::backtrace::Backtrace::capture(),
-            Repr::Custom(err) => err.backtrace(),
-        }
+        self.error.downcast_ref::<E>()
     }
 
     /// Attempt to downcast the error object to a concrete type.
     pub fn downcast<E>(self) -> std::result::Result<E, Self>
     where
         E: Display + Debug + Send + Sync + 'static,
     {
-        match self.repr {
-            Repr::Io(err) => Ok(anyhow::Error::new(err).downcast().unwrap()),
-            Repr::Custom(err) if err.downcast_ref::<E>().is_some() => Ok(err.downcast().unwrap()),
-            _ => Err(self),
+        if self.error.downcast_ref::<E>().is_some() {
+            Ok(self.error.downcast().unwrap())
+        } else {
+            Err(self)
         }
     }
 
@@ -253,39 +95,27 @@ impl Error {
     where
         E: Display + Debug + Send + Sync + 'static,
     {
-        match self.repr {
-            Repr::Custom(ref err) => err.downcast_ref::<E>(),
-            _ => None,
-        }
+        self.error.downcast_ref::<E>()
     }
 
     /// Downcast this error object by mutable reference.
     pub fn downcast_mut<E>(&mut self) -> Option<&mut E>
     where
         E: Display + Debug + Send + Sync + 'static,
     {
-        match self.repr {
-            Repr::Custom(ref mut err) => err.downcast_mut::<E>(),
-            _ => None,
-        }
+        self.error.downcast_mut::<E>()
     }
 }
 
 impl Display for Error {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.repr {
-            Repr::Io(io) => write!(formatter, "{}", io),
-            Repr::Custom(err) => write!(formatter, "{}", err),
-        }
+        write!(formatter, "{}", self.error)
     }
 }
 
 impl Debug for Error {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.repr {
-            Repr::Io(io) => write!(formatter, "{}", io),
-            Repr::Custom(err) => write!(formatter, "{}", err),
-        }
+        write!(formatter, "{}", self.error)
     }
 }
 
@@ -295,52 +125,44 @@ where
 {
     fn from(error: E) -> Self {
         Self {
-            kind: ErrorKind::Other,
-            repr: Repr::Custom(anyhow::Error::new(error)),
+            error: anyhow::Error::new(error),
             status: StatusCode::InternalServerError,
         }
     }
 }
 
-impl From<ErrorKind> for Error {
-    fn from(kind: ErrorKind) -> Self {
-        Self {
-            kind: kind.clone(),
-            repr: Repr::Io(kind.into()),
-            status: StatusCode::InternalServerError,
-        }
+impl AsRef<dyn StdError + Send + Sync> for Error {
+    fn as_ref(&self) -> &(dyn StdError + Send + Sync + 'static) {
+        self.error.as_ref()
     }
 }
 
-impl AsRef<dyn StdError + Send + Sync> for Error {
-    fn as_ref(&self) -> &(dyn StdError + Send + Sync + 'static) {
-        match &self.repr {
-            Repr::Io(ref io) => io,
-            Repr::Custom(ref err) => err.as_ref(),
-        }
+impl AsRef<StatusCode> for Error {
+    fn as_ref(&self) -> &StatusCode {
+        &self.status
+    }
+}
+
+impl AsMut<StatusCode> for Error {
+    fn as_mut(&mut self) -> &mut StatusCode {
+        &mut self.status
     }
 }
 
 impl AsRef<dyn StdError> for Error {
     fn as_ref(&self) -> &(dyn StdError + 'static) {
-        match &self.repr {
-            Repr::Io(ref io) => io,
-            Repr::Custom(ref err) => err.as_ref(),
-        }
+        self.error.as_ref()
     }
 }
 
 impl From<Error> for Box<dyn StdError + Send + Sync + 'static> {
     fn from(error: Error) -> Self {
-        match error.repr {
-            Repr::Io(io) => io.into(),
-            Repr::Custom(err) => err.into(),
-        }
+        error.error.into()
     }
 }
 
 impl From<Error> for Box<dyn StdError + 'static> {
     fn from(error: Error) -> Self {
-        Box::<dyn StdError + Send + Sync>::from(error)
+        Box::<dyn StdError + Send + Sync>::from(error.error)
     }
 }

src/headers/header_name.rs

@@ -2,7 +2,7 @@ use std::borrow::Cow;
 use std::fmt::{self, Debug, Display};
 use std::str::FromStr;
 
-use crate::{Error, ErrorKind};
+use crate::Error;
 
 /// A header name.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -11,11 +11,11 @@ pub struct HeaderName(Cow<'static, str>);
 impl HeaderName {
     /// Create a new `HeaderName`.
     pub fn from_ascii(mut bytes: Vec<u8>) -> Result<Self, Error> {
-        if !bytes.is_ascii() {
-            return Err(Error::from(ErrorKind::InvalidData));
-        }
+        crate::ensure!(bytes.is_ascii(), "Bytes should be valid ASCII");
         bytes.make_ascii_lowercase();
-        let string = String::from_utf8(bytes).map_err(|_| Error::from(ErrorKind::InvalidData))?;
+
+        // This is permitted because ASCII is valid UTF-8, and we just checked that.
+        let string = unsafe { String::from_utf8_unchecked(bytes.to_vec()) };
         Ok(HeaderName(Cow::Owned(string)))
     }
 
@@ -58,9 +58,7 @@ impl FromStr for HeaderName {
     ///
     /// This checks it's valid ASCII, and lowercases it.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if !s.is_ascii() {
-            return Err(Error::from(ErrorKind::InvalidData));
-        }
+        crate::ensure!(s.is_ascii(), "String slice should be valid ASCII");
         Ok(HeaderName(Cow::Owned(s.to_ascii_lowercase())))
     }
 }