use std::error::Error as StdError;
use std::fmt;
use std::io;
use {StatusCode, Url};
pub struct Error {
inner: Box<Inner>,
}
struct Inner {
kind: Kind,
url: Option<Url>,
}
pub type Result<T> = ::std::result::Result<T, Error>;
impl Error {
fn new(kind: Kind, url: Option<Url>) -> Error {
Error {
inner: Box::new(Inner {
kind,
url,
}),
}
}
#[inline]
pub fn url(&self) -> Option<&Url> {
self.inner.url.as_ref()
}
pub(crate) fn with_url(mut self, url: Url) -> Error {
debug_assert_eq!(self.inner.url, None, "with_url overriding existing url");
self.inner.url = Some(url);
self
}
#[inline]
pub fn get_ref(&self) -> Option<&(dyn StdError + Send + Sync + 'static)> {
match self.inner.kind {
Kind::Http(ref e) => Some(e),
Kind::Hyper(ref e) => Some(e),
Kind::Mime(ref e) => Some(e),
Kind::Url(ref e) => Some(e),
#[cfg(all(feature = "default-tls", feature = "rustls-tls"))]
Kind::TlsIncompatible => None,
#[cfg(feature = "default-tls")]
Kind::NativeTls(ref e) => Some(e),
#[cfg(feature = "rustls-tls")]
Kind::Rustls(ref e) => Some(e),
#[cfg(feature = "trust-dns")]
Kind::DnsSystemConf(ref e) => Some(e),
Kind::Io(ref e) => Some(e),
Kind::UrlEncoded(ref e) => Some(e),
Kind::Json(ref e) => Some(e),
Kind::UrlBadScheme |
Kind::TooManyRedirects |
Kind::RedirectLoop |
Kind::Status(_) |
Kind::UnknownProxyScheme |
Kind::Timer => None,
}
}
#[inline]
pub fn is_http(&self) -> bool {
match self.inner.kind {
Kind::Http(_) => true,
Kind::Hyper(_) => true,
_ => false,
}
}
pub fn is_timeout(&self) -> bool {
match self.inner.kind {
Kind::Io(ref io) => io.kind() == io::ErrorKind::TimedOut,
Kind::Hyper(ref error) => {
error
.source()
.and_then(|cause| {
cause.downcast_ref::<io::Error>()
})
.map(|io| io.kind() == io::ErrorKind::TimedOut)
.unwrap_or(false)
},
_ => false,
}
}
#[inline]
pub fn is_serialization(&self) -> bool {
match self.inner.kind {
Kind::Json(_) |
Kind::UrlEncoded(_) => true,
_ => false,
}
}
#[inline]
pub fn is_redirect(&self) -> bool {
match self.inner.kind {
Kind::TooManyRedirects |
Kind::RedirectLoop => true,
_ => false,
}
}
#[inline]
pub fn is_client_error(&self) -> bool {
match self.inner.kind {
Kind::Status(code) => code.is_client_error(),
_ => false,
}
}
#[inline]
pub fn is_server_error(&self) -> bool {
match self.inner.kind {
Kind::Status(code) => code.is_server_error(),
_ => false,
}
}
#[inline]
pub fn status(&self) -> Option<StatusCode> {
match self.inner.kind {
Kind::Status(code) => Some(code),
_ => None,
}
}
}
impl fmt::Debug for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if let Some(ref url) = self.inner.url {
f.debug_tuple("Error")
.field(&self.inner.kind)
.field(url)
.finish()
} else {
f.debug_tuple("Error")
.field(&self.inner.kind)
.finish()
}
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if let Some(ref url) = self.inner.url {
fmt::Display::fmt(url, f)?;
f.write_str(": ")?;
}
match self.inner.kind {
Kind::Http(ref e) => fmt::Display::fmt(e, f),
Kind::Hyper(ref e) => fmt::Display::fmt(e, f),
Kind::Mime(ref e) => fmt::Display::fmt(e, f),
Kind::Url(ref e) => fmt::Display::fmt(e, f),
Kind::UrlBadScheme => f.write_str("URL scheme is not allowed"),
#[cfg(all(feature = "default-tls", feature = "rustls-tls"))]
Kind::TlsIncompatible => f.write_str("Incompatible TLS identity type"),
#[cfg(feature = "default-tls")]
Kind::NativeTls(ref e) => fmt::Display::fmt(e, f),
#[cfg(feature = "rustls-tls")]
Kind::Rustls(ref e) => fmt::Display::fmt(e, f),
#[cfg(feature = "trust-dns")]
Kind::DnsSystemConf(ref e) => {
write!(f, "failed to load DNS system conf: {}", e)
},
Kind::Io(ref e) => fmt::Display::fmt(e, f),
Kind::UrlEncoded(ref e) => fmt::Display::fmt(e, f),
Kind::Json(ref e) => fmt::Display::fmt(e, f),
Kind::TooManyRedirects => f.write_str("Too many redirects"),
Kind::RedirectLoop => f.write_str("Infinite redirect loop"),
Kind::Status(ref code) => {
let prefix = if code.is_client_error() {
"Client Error"
} else if code.is_server_error() {
"Server Error"
} else {
unreachable!("non-error status code: {:?}", code);
};
write!(f, "{}: {}", prefix, code)
}
Kind::UnknownProxyScheme => f.write_str("Unknown proxy scheme"),
Kind::Timer => f.write_str("timer unavailable"),
}
}
}
impl StdError for Error {
fn description(&self) -> &str {
match self.inner.kind {
Kind::Http(ref e) => e.description(),
Kind::Hyper(ref e) => e.description(),
Kind::Mime(ref e) => e.description(),
Kind::Url(ref e) => e.description(),
Kind::UrlBadScheme => "URL scheme is not allowed",
#[cfg(all(feature = "default-tls", feature = "rustls-tls"))]
Kind::TlsIncompatible => "Incompatible TLS identity type",
#[cfg(feature = "default-tls")]
Kind::NativeTls(ref e) => e.description(),
#[cfg(feature = "rustls-tls")]
Kind::Rustls(ref e) => e.description(),
#[cfg(feature = "trust-dns")]
Kind::DnsSystemConf(_) => "failed to load DNS system conf",
Kind::Io(ref e) => e.description(),
Kind::UrlEncoded(ref e) => e.description(),
Kind::Json(ref e) => e.description(),
Kind::TooManyRedirects => "Too many redirects",
Kind::RedirectLoop => "Infinite redirect loop",
Kind::Status(code) => {
if code.is_client_error() {
"Client Error"
} else if code.is_server_error() {
"Server Error"
} else {
unreachable!("non-error status code: {:?}", code);
}
}
Kind::UnknownProxyScheme => "Unknown proxy scheme",
Kind::Timer => "timer unavailable",
}
}
#[allow(deprecated)]
fn cause(&self) -> Option<&dyn StdError> {
match self.inner.kind {
Kind::Http(ref e) => e.cause(),
Kind::Hyper(ref e) => e.cause(),
Kind::Mime(ref e) => e.cause(),
Kind::Url(ref e) => e.cause(),
#[cfg(all(feature = "default-tls", feature = "rustls-tls"))]
Kind::TlsIncompatible => None,
#[cfg(feature = "default-tls")]
Kind::NativeTls(ref e) => e.cause(),
#[cfg(feature = "rustls-tls")]
Kind::Rustls(ref e) => e.cause(),
#[cfg(feature = "trust-dns")]
Kind::DnsSystemConf(ref e) => e.cause(),
Kind::Io(ref e) => e.cause(),
Kind::UrlEncoded(ref e) => e.cause(),
Kind::Json(ref e) => e.cause(),
Kind::UrlBadScheme |
Kind::TooManyRedirects |
Kind::RedirectLoop |
Kind::Status(_) |
Kind::UnknownProxyScheme |
Kind::Timer => None,
}
}
fn source(&self) -> Option<&(dyn StdError + 'static)> {
match self.inner.kind {
Kind::Http(ref e) => e.source(),
Kind::Hyper(ref e) => e.source(),
Kind::Mime(ref e) => e.source(),
Kind::Url(ref e) => e.source(),
#[cfg(all(feature = "default-tls", feature = "rustls-tls"))]
Kind::TlsIncompatible => None,
#[cfg(feature = "default-tls")]
Kind::NativeTls(ref e) => e.source(),
#[cfg(feature = "rustls-tls")]
Kind::Rustls(ref e) => e.source(),
#[cfg(feature = "trust-dns")]
Kind::DnsSystemConf(ref e) => e.source(),
Kind::Io(ref e) => e.source(),
Kind::UrlEncoded(ref e) => e.source(),
Kind::Json(ref e) => e.source(),
Kind::UrlBadScheme |
Kind::TooManyRedirects |
Kind::RedirectLoop |
Kind::Status(_) |
Kind::UnknownProxyScheme |
Kind::Timer => None,
}
}
}
#[derive(Debug)]
pub(crate) enum Kind {
Http(::http::Error),
Hyper(::hyper::Error),
Mime(::mime::FromStrError),
Url(::url::ParseError),
UrlBadScheme,
#[cfg(all(feature = "default-tls", feature = "rustls-tls"))]
TlsIncompatible,
#[cfg(feature = "default-tls")]
NativeTls(::native_tls::Error),
#[cfg(feature = "rustls-tls")]
Rustls(::rustls::TLSError),
#[cfg(feature = "trust-dns")]
DnsSystemConf(io::Error),
Io(io::Error),
UrlEncoded(::serde_urlencoded::ser::Error),
Json(::serde_json::Error),
TooManyRedirects,
RedirectLoop,
Status(StatusCode),
UnknownProxyScheme,
Timer,
}
impl From<::http::Error> for Kind {
#[inline]
fn from(err: ::http::Error) -> Kind {
Kind::Http(err)
}
}
impl From<::hyper::Error> for Kind {
#[inline]
fn from(err: ::hyper::Error) -> Kind {
Kind::Hyper(err)
}
}
impl From<::mime::FromStrError> for Kind {
#[inline]
fn from(err: ::mime::FromStrError) -> Kind {
Kind::Mime(err)
}
}
impl From<io::Error> for Kind {
#[inline]
fn from(err: io::Error) -> Kind {
Kind::Io(err)
}
}
impl From<::url::ParseError> for Kind {
#[inline]
fn from(err: ::url::ParseError) -> Kind {
Kind::Url(err)
}
}
impl From<::serde_urlencoded::ser::Error> for Kind {
#[inline]
fn from(err: ::serde_urlencoded::ser::Error) -> Kind {
Kind::UrlEncoded(err)
}
}
impl From<::serde_json::Error> for Kind {
#[inline]
fn from(err: ::serde_json::Error) -> Kind {
Kind::Json(err)
}
}
#[cfg(feature = "default-tls")]
impl From<::native_tls::Error> for Kind {
fn from(err: ::native_tls::Error) -> Kind {
Kind::NativeTls(err)
}
}
#[cfg(feature = "rustls-tls")]
impl From<::rustls::TLSError> for Kind {
fn from(err: ::rustls::TLSError) -> Kind {
Kind::Rustls(err)
}
}
impl<T> From<::wait::Waited<T>> for Kind
where T: Into<Kind> {
fn from(err: ::wait::Waited<T>) -> Kind {
match err {
::wait::Waited::TimedOut => io_timeout().into(),
::wait::Waited::Inner(e) => e.into(),
}
}
}
impl From<::tokio::timer::Error> for Kind {
fn from(_err: ::tokio::timer::Error) -> Kind {
Kind::Timer
}
}
fn io_timeout() -> io::Error {
io::Error::new(io::ErrorKind::TimedOut, "timed out")
}
#[allow(missing_debug_implementations)]
pub(crate) struct InternalFrom<T>(pub T, pub Option<Url>);
#[doc(hidden)]
impl From<InternalFrom<Error>> for Error {
#[inline]
fn from(other: InternalFrom<Error>) -> Error {
other.0
}
}
#[doc(hidden)]
impl<T> From<InternalFrom<T>> for Error
where
T: Into<Kind>,
{
#[inline]
fn from(other: InternalFrom<T>) -> Error {
Error::new(other.0.into(), other.1)
}
}
pub(crate) fn from<T>(err: T) -> Error
where
T: Into<Kind>,
{
InternalFrom(err, None).into()
}
pub(crate) fn into_io(e: Error) -> io::Error {
match e.inner.kind {
Kind::Io(io) => io,
_ => io::Error::new(io::ErrorKind::Other, e),
}
}
pub(crate) fn from_io(e: io::Error) -> Error {
if e.get_ref().map(|r| r.is::<Error>()).unwrap_or(false) {
*e
.into_inner()
.expect("io::Error::get_ref was Some(_)")
.downcast::<Error>()
.expect("StdError::is() was true")
} else {
from(e)
}
}
macro_rules! try_ {
($e:expr) => (
match $e {
Ok(v) => v,
Err(err) => {
return Err(::error::from(err));
}
}
);
($e:expr, $url:expr) => (
match $e {
Ok(v) => v,
Err(err) => {
return Err(::Error::from(::error::InternalFrom(err, Some($url.clone()))));
}
}
)
}
macro_rules! try_io {
($e:expr) => (
match $e {
Ok(v) => v,
Err(ref err) if err.kind() == ::std::io::ErrorKind::WouldBlock => {
return Ok(::futures::Async::NotReady);
}
Err(err) => {
return Err(::error::from_io(err));
}
}
)
}
pub(crate) fn loop_detected(url: Url) -> Error {
Error::new(Kind::RedirectLoop, Some(url))
}
pub(crate) fn too_many_redirects(url: Url) -> Error {
Error::new(Kind::TooManyRedirects, Some(url))
}
pub(crate) fn timedout(url: Option<Url>) -> Error {
Error::new(Kind::Io(io_timeout()), url)
}
pub(crate) fn status_code(url: Url, status: StatusCode) -> Error {
Error::new(Kind::Status(status), Some(url))
}
pub(crate) fn url_bad_scheme(url: Url) -> Error {
Error::new(Kind::UrlBadScheme, Some(url))
}
#[cfg(feature = "trust-dns")]
pub(crate) fn dns_system_conf(io: io::Error) -> Error {
Error::new(Kind::DnsSystemConf(io), None)
}
pub(crate) fn unknown_proxy_scheme() -> Error {
Error::new(Kind::UnknownProxyScheme, None)
}
#[cfg(test)]
mod tests {
use super::*;
#[allow(deprecated)]
#[test]
fn test_cause_chain() {
#[derive(Debug)]
struct Chain<T>(Option<T>);
impl<T: fmt::Display> fmt::Display for Chain<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if let Some(ref link) = self.0 {
write!(f, "chain: {}", link)
} else {
f.write_str("root")
}
}
}
impl<T: StdError> StdError for Chain<T> {
fn description(&self) -> &str {
if self.0.is_some() {
"chain"
} else {
"root"
}
}
fn cause(&self) -> Option<&dyn StdError> {
if let Some(ref e) = self.0 {
Some(e)
} else {
None
}
}
}
let root = Chain(None::<Error>);
let io = ::std::io::Error::new(::std::io::ErrorKind::Other, root);
let err = Error::new(Kind::Io(io), None);
assert!(err.cause().is_none());
assert_eq!(err.to_string(), "root");
let root = ::std::io::Error::new(::std::io::ErrorKind::Other, Chain(None::<Error>));
let link = Chain(Some(root));
let io = ::std::io::Error::new(::std::io::ErrorKind::Other, link);
let err = Error::new(Kind::Io(io), None);
assert!(err.cause().is_some());
assert_eq!(err.to_string(), "chain: root");
}
#[test]
fn mem_size_of() {
use std::mem::size_of;
assert_eq!(size_of::<Error>(), size_of::<usize>());
}
#[test]
fn roundtrip_io_error() {
let orig = unknown_proxy_scheme();
let io = into_io(orig);
let err = from_io(io);
match err.inner.kind {
Kind::UnknownProxyScheme => (),
_ => panic!("{:?}", err),
}
}
}