Enum ureq::Error

pub enum Error {
    Status(u16, Response),
    Transport(Transport),
}

An error that may occur when processing a Request.

This can represent connection-level errors (e.g. connection refused), protocol-level errors (malformed response), or status code errors (e.g. 404 Not Found). Status code errors are represented by the Status enum variant, while connection-level and protocol-level errors are represented by the Transport enum variant. You can use a match statement to extract a Response from a Status error. For instance, you may want to read the full body of a response because you expect it to contain a useful error message. Or you may want to handle certain error code responses differently.

Examples

Example of matching out all unexpected server status codes.

use ureq::Error;

match ureq::get("http://mypage.example.com/").call() {
    Ok(response) => { /* it worked */},
    Err(Error::Status(code, response)) => {
        /* the server returned an unexpected status
           code (such as 400, 500 etc) */
    }
    Err(_) => { /* some kind of io/transport error */ }
}

An example of a function that handles HTTP 429 and 500 errors differently than other errors. They get retried after a suitable delay, up to 4 times.

use std::{result::Result, time::Duration, thread};
use ureq::{Response, Error, Error::Status};

fn get_response(url: &str) -> Result<Response, Error> {
    for _ in 1..4 {
        match ureq::get(url).call() {
            Err(Status(503, r)) | Err(Status(429, r)) => {
                let retry: Option<u64> = r.header("retry-after")
                    .and_then(|h| h.parse().ok());
                let retry = retry.unwrap_or(5);
                eprintln!("{} for {}, retry in {}", r.status(), r.get_url(), retry);
                thread::sleep(Duration::from_secs(retry));
            }
            result => return result,
        };
    }
    // Ran out of retries; try one last time and return whatever result we get.
    ureq::get(url).call()
}

If you’d like to treat all status code errors as normal, successful responses, you can use OrAnyStatus::or_any_status like this:

use ureq::Error::Status;
use ureq::OrAnyStatus;

let resp = ureq::get("http://example.com/")
  .call()
  .or_any_status()?;

Variants

Status(u16, Response)

A response was successfully received but had status code >= 400. Values are (status_code, Response).

Transport(Transport)

There was an error making the request or receiving the response.

Implementations

impl Error

pub fn into_transport(self) -> Option<Transport>

Optionally turn this error into an underlying Transport.

None if the underlying error is Error::Status.

pub fn into_response(self) -> Option<Response>

Optionally turn this error into an underlying Response.

None if the underlying error is Error::Transport.

impl Error

pub fn kind(&self) -> ErrorKind

The type of this error.

let err = ureq::get("http://httpbin.org/status/500")
    .call().unwrap_err();
assert_eq!(err.kind(), ureq::ErrorKind::HTTP);

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, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for Error

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

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, demand: &mut Demand<'a>)

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

Provides type based access to context intended for error reports.

impl From<Error> for Error

fn from(err: Error) -> Error

Converts to this type from the input type.

impl From<ParseError> for Error

fn from(err: ParseError) -> Self

Converts to this type from the input type.

impl From<Response> for Error

fn from(resp: Response) -> Error

Converts to this type from the input type.

impl From<Transport> for Error

fn from(err: Transport) -> Error

Converts to this type from the input type.