Struct poem::error::Error

source · [−]

pub struct Error { /* private fields */ }

Expand description

General response error.

Create from any error types

use poem::{error::InternalServerError, handler, Result};

#[handler]
async fn index() -> Result<String> {
    Ok(std::fs::read_to_string("example.txt").map_err(InternalServerError)?)
}

Create you own error type

use poem::{error::ResponseError, handler, http::StatusCode, Endpoint, Request, Result};

#[derive(Debug, thiserror::Error)]
#[error("my error")]
struct MyError;

impl ResponseError for MyError {
    fn status(&self) -> StatusCode {
        StatusCode::BAD_GATEWAY
    }
}

fn do_something() -> Result<(), MyError> {
    Err(MyError)
}

#[handler]
async fn index() -> Result<()> {
    Ok(do_something()?)
}

let resp = index.get_response(Request::default()).await;
assert_eq!(resp.status(), StatusCode::BAD_GATEWAY);
assert_eq!(resp.into_body().into_string().await.unwrap(), "my error");

Custom error response

use poem::{error::ResponseError, handler, http::StatusCode, Response, Result, Request, Body, Endpoint};

#[derive(Debug, thiserror::Error)]
#[error("my error")]
struct MyError;

impl ResponseError for MyError {
    fn status(&self) -> StatusCode {
        StatusCode::BAD_GATEWAY
    }

    fn as_response(&self) -> Response {
        let body = Body::from_json(serde_json::json!({
            "code": 1000,
            "message": self.to_string(),
        })).unwrap();
        Response::builder().status(self.status()).body(body)
    }
}

fn do_something() -> Result<(), MyError> {
    Err(MyError)
}

#[handler]
async fn index() -> Result<()> {
    Ok(do_something()?)
}

let resp = index.get_response(Request::default()).await;
assert_eq!(resp.status(), StatusCode::BAD_GATEWAY);
assert_eq!(resp.into_body().into_json::<serde_json::Value>().await.unwrap(),
serde_json::json!({
    "code": 1000,
    "message": "my error",
}));

Downcast the error to concrete error type

use poem::{error::NotFoundError, Error};

let err: Error = NotFoundError.into();

assert!(err.is::<NotFoundError>());
assert_eq!(err.downcast_ref::<NotFoundError>(), Some(&NotFoundError));

Implementations

source

impl Error

source

pub fn new<T: StdError + Send + Sync + 'static>(
err: T,
status: StatusCode
) -> Self

Create a new error object from any error type with a status code.

source

pub fn from_response(resp: Response) -> Self

Create a new error object from response.

source

pub fn from_status(status: StatusCode) -> Self

create a new error object from status code.

source

pub fn from_string(msg: impl Into<String>, status: StatusCode) -> Self

Create a new error object from a string with a status code.

source

pub fn downcast_ref<T: StdError + Send + Sync + 'static>(&self) -> Option<&T>

Downcast this error object by reference.

source

pub fn downcast<T: StdError + Send + Sync + 'static>(self) -> Result<T, Error>

Attempts to downcast the error to a concrete error type.

source

pub fn is<T: StdError + Debug + Send + Sync + 'static>(&self) -> bool

Returns true if the error type is the same as T.

source

pub fn into_response(self) -> Response

Consumes this to return a response object.

source

pub fn has_source(&self) -> bool

Returns whether the error has a source or not.

source

pub fn set_data(&mut self, data: impl Send + Sync + 'static)

Inserts a value to extensions

Passed to Response::extensions when this error converted to Response.

Examples

let mut err = Error::from_status(StatusCode::BAD_REQUEST);
err.set_data(100i32);

let resp = err.into_response();
assert_eq!(resp.data::<i32>(), Some(&100));