Enum Error 

#[non_exhaustive]
pub enum Error {
    Protocol(Error),
    InvalidStatusCodeWithDetails {
        status: StatusCode,
        body: String,
        headers: HeaderMap,
    },
    InvalidHeaderValue(InvalidHeaderValue),
    NoHeaders,
    StreamEnded,
    InvalidContentType(HeaderValue),
    Instance(Box<dyn Error + Send + Sync + 'static>),
    Unbuilt(Box<dyn Error + Send + Sync + 'static>),
}

Why an HTTP request failed: a protocol or header error, a non-success reply, the transport’s own error, or a client that could not be built.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Protocol(Error)

The request could not be built.

InvalidStatusCodeWithDetails

Failed HTTP response preserving its status, body, and headers. Transport failures without a response use Self::Instance, a protocol variant, or Self::Unbuilt when no client could be built.

Fields

status: StatusCode

The non-success status.

body: String

The raw response body.

headers: HeaderMap

The failed response’s headers, verbatim.

InvalidHeaderValue(InvalidHeaderValue)

A header value with characters a header cannot carry.

NoHeaders

The request builder failed earlier, so its headers cannot be read.

StreamEnded

The response stream ended before it was done.

InvalidContentType(HeaderValue)

The response’s content type was not the one expected.

Instance(Box<dyn Error + Send + Sync + 'static>)

Available on non-target_family=wasm only.

The transport’s own error, without a response.

Unbuilt(Box<dyn Error + Send + Sync + 'static>)

Available on non-target_family=wasm only.

The transport’s client could not be built, so nothing was sent. Sending again fails the same way.

Implementations

impl Error

pub fn non_success_status(&self) -> Option<StatusCode>

Preserved HTTP failure status, or None for other error variants.

pub fn non_success_body(&self) -> Option<&str>

The response body this error preserved, when it has one. Companion to Self::non_success_status and Self::non_success_headers.

pub fn non_success_with_details( status: StatusCode, headers: HeaderMap, body: String, ) -> Self

Constructs a failure from its HTTP status, headers, and body without validating that the status is non-successful.

pub fn non_success_headers(&self) -> Option<&HeaderMap>

Returns the failed response’s headers, when this error preserved them.

The following example reads the seconds form of Retry-After:

fn retry_after(error: &Error) -> Option<Duration> {
    let seconds = error
        .non_success_headers()?
        .get(http::header::RETRY_AFTER)?
        .to_str()
        .ok()?
        .parse()
        .ok()?;
    Some(Duration::from_secs(seconds))
}

Returns None for a response-less failure: every non-success error carries its headers.

impl Error

pub fn instance<E: Error + Send + Sync + 'static>(error: E) -> Self

Available on non-target_family=wasm only.

Wrap a transport’s native error as Error::Instance. Transports use this for response-less failures (connect, decode, timeout); non-success responses go through Error::non_success_with_details instead so the status stays inspectable.

pub fn unbuilt<E: Error + Send + Sync + 'static>(error: E) -> Self

Available on non-target_family=wasm only.

Wrap why a transport’s client could not be built as Error::Unbuilt.

Trait Implementations

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Error

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Box<dyn Error + Sync + Send>> for Error

fn from(source: Box<dyn Error + Send + Sync + 'static>) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<InvalidHeaderValue> for Error

fn from(source: InvalidHeaderValue) -> Self

Converts to this type from the input type.