awc/client/
error.rs

1use std::{fmt, io};
2
3use derive_more::{Display, From};
4
5use actix_http::error::{HttpError, ParseError};
6
7// #[cfg(feature = "openssl")]
8// use actix_tls::accept::openssl::reexports::Error as OpensslError;
9
10use crate::BoxError;
11
12/// A set of errors that can occur while connecting to an HTTP host
13#[derive(Debug, Display, From)]
14#[non_exhaustive]
15pub enum ConnectError {
16    /// SSL feature is not enabled
17    #[display(fmt = "SSL is not supported")]
18    SslIsNotSupported,
19
20    // /// SSL error
21    // #[cfg(feature = "openssl")]
22    // #[display(fmt = "{}", _0)]
23    // SslError(OpensslError),
24
25    /// Failed to resolve the hostname
26    #[display(fmt = "Failed resolving hostname: {}", _0)]
27    Resolver(Box<dyn std::error::Error>),
28
29    /// No dns records
30    #[display(fmt = "No DNS records found for the input")]
31    NoRecords,
32
33    /// Http2 error
34    #[display(fmt = "{}", _0)]
35    H2(h2::Error),
36
37    /// Connecting took too long
38    #[display(fmt = "Timeout while establishing connection")]
39    Timeout,
40
41    /// Connector has been disconnected
42    #[display(fmt = "Internal error: connector has been disconnected")]
43    Disconnected,
44
45    /// Unresolved host name
46    #[display(fmt = "Connector received `Connect` method with unresolved host")]
47    Unresolved,
48
49    /// Connection io error
50    #[display(fmt = "{}", _0)]
51    Io(io::Error),
52}
53
54impl std::error::Error for ConnectError {}
55
56impl From<actix_tls::connect::ConnectError> for ConnectError {
57    fn from(err: actix_tls::connect::ConnectError) -> ConnectError {
58        match err {
59            actix_tls::connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
60            actix_tls::connect::ConnectError::NoRecords => ConnectError::NoRecords,
61            actix_tls::connect::ConnectError::InvalidInput => panic!(),
62            actix_tls::connect::ConnectError::Unresolved => ConnectError::Unresolved,
63            actix_tls::connect::ConnectError::Io(e) => ConnectError::Io(e),
64        }
65    }
66}
67
68#[derive(Debug, Display, From)]
69#[non_exhaustive]
70pub enum InvalidUrl {
71    #[display(fmt = "Missing URL scheme")]
72    MissingScheme,
73
74    #[display(fmt = "Unknown URL scheme")]
75    UnknownScheme,
76
77    #[display(fmt = "Missing host name")]
78    MissingHost,
79
80    #[display(fmt = "URL parse error: {}", _0)]
81    HttpError(http::Error),
82}
83
84impl std::error::Error for InvalidUrl {}
85
86/// A set of errors that can occur during request sending and response reading
87#[derive(Debug, Display, From)]
88#[non_exhaustive]
89pub enum SendRequestError {
90    /// Invalid URL
91    #[display(fmt = "Invalid URL: {}", _0)]
92    Url(InvalidUrl),
93
94    /// Failed to connect to host
95    #[display(fmt = "Failed to connect to host: {}", _0)]
96    Connect(ConnectError),
97
98    /// Error sending request
99    Send(io::Error),
100
101    /// Error parsing response
102    Response(ParseError),
103
104    /// Http error
105    #[display(fmt = "{}", _0)]
106    Http(HttpError),
107
108    /// Http2 error
109    #[display(fmt = "{}", _0)]
110    H2(h2::Error),
111
112    /// Response took too long
113    #[display(fmt = "Timeout while waiting for response")]
114    Timeout,
115
116    /// Tunnels are not supported for HTTP/2 connection
117    #[display(fmt = "Tunnels are not supported for http2 connection")]
118    TunnelNotSupported,
119
120    /// Error sending request body
121    Body(BoxError),
122
123    /// Other errors that can occur after submitting a request.
124    #[display(fmt = "{:?}: {}", _1, _0)]
125    Custom(BoxError, Box<dyn fmt::Debug>),
126}
127
128impl std::error::Error for SendRequestError {}
129
130/// A set of errors that can occur during freezing a request
131#[derive(Debug, Display, From)]
132#[non_exhaustive]
133pub enum FreezeRequestError {
134    /// Invalid URL
135    #[display(fmt = "Invalid URL: {}", _0)]
136    Url(InvalidUrl),
137
138    /// HTTP error
139    #[display(fmt = "{}", _0)]
140    Http(HttpError),
141
142    /// Other errors that can occur after submitting a request.
143    #[display(fmt = "{:?}: {}", _1, _0)]
144    Custom(BoxError, Box<dyn fmt::Debug>),
145}
146
147impl std::error::Error for FreezeRequestError {}
148
149impl From<FreezeRequestError> for SendRequestError {
150    fn from(err: FreezeRequestError) -> Self {
151        match err {
152            FreezeRequestError::Url(err) => err.into(),
153            FreezeRequestError::Http(err) => err.into(),
154            FreezeRequestError::Custom(err, msg) => SendRequestError::Custom(err, msg),
155        }
156    }
157}