Struct vkrs::api::HttpError

pub struct HttpError { /* private fields */ }

The Errors that may occur when processing a Request.

Examples

extern crate serde;
extern crate reqwest;

use serde::Deserialize;

#[derive(Deserialize)]
struct Simple {
   key: String
}

fn run() {
   match make_request() {
       Err(e) => handler(e),
       Ok(_)  => return,
   }
}
// Response is not a json object conforming to the Simple struct
fn make_request() -> Result<Simple, reqwest::Error> {
  reqwest::get("http://httpbin.org/ip")?.json()
}

fn handler(e: reqwest::Error) {
   if e.is_http() {
       match e.url() {
           None => println!("No Url given"),
           Some(url) => println!("Problem making request to: {}", url),
       }
   }
   // Inspect the internal error and output it
   if e.is_serialization() {
      let serde_error = match e.get_ref() {
           None => return,
           Some(err) => err,
       };
       println!("problem parsing information {}", serde_error);
   }
   if e.is_redirect() {
       println!("server redirecting too many times or making loop");
   }
}

Implementations

impl Error

pub fn url(&self) -> Option<&Url>

Returns a possible URL related to this error.

Examples

// displays last stop of a redirect loop
let response = reqwest::get("http://site.with.redirect.loop");
if let Err(e) = response {
    if e.is_redirect() {
        if let Some(final_stop) = e.url() {
            println!("redirect loop at {}", final_stop);
        }
    }
}

pub fn get_ref(&self) -> Option<&(dyn Error + Sync + Send + 'static)>

Returns a reference to the internal error, if available.

The 'static bounds allows using downcast_ref to check the details of the error.

Examples

extern crate url;
// retries requests with no host on localhost
let invalid_request = "http://";
let mut response = reqwest::get(invalid_request);
if let Err(e) = response {
    match e.get_ref().and_then(|e| e.downcast_ref::<url::ParseError>()) {
        Some(&url::ParseError::EmptyHost) => {
            let valid_request = format!("{}{}",invalid_request, "localhost");
            response = reqwest::get(&valid_request);
        },
        _ => (),
    }
}

pub fn is_http(&self) -> bool

Returns true if the error is related to HTTP.

pub fn is_timeout(&self) -> bool

Returns true if the error is related to a timeout.

pub fn is_serialization(&self) -> bool

Returns true if the error is serialization related.

pub fn is_redirect(&self) -> bool

Returns true if the error is from a RedirectPolicy.

pub fn is_client_error(&self) -> bool

Returns true if the error is from a request returning a 4xx error.

pub fn is_server_error(&self) -> bool

Returns true if the error is from a request returning a 5xx error.

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

Returns the status code, if the error was generated from a response.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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 source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

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 ClientError

fn from(err: Error) -> ClientError

Converts to this type from the input type.

impl From<Error> for Error

fn from(err: HttpError) -> Error

Converts to this type from the input type.