[][src]Struct actix_web::middleware::ErrorHandlers

pub struct ErrorHandlers<S> { /* fields omitted */ }

Middleware for allowing custom handlers for responses.

You can use ErrorHandlers::handler() method to register a custom error handler for specific status code. You can modify existing response or create completely new one.

Example

use actix_web::middleware::{ErrorHandlers, Response};
use actix_web::{http, App, HttpRequest, HttpResponse, Result};

fn render_500<S>(_: &HttpRequest<S>, resp: HttpResponse) -> Result<Response> {
    let mut builder = resp.into_builder();
    builder.header(http::header::CONTENT_TYPE, "application/json");
    Ok(Response::Done(builder.into()))
}

fn main() {
    let app = App::new()
        .middleware(
            ErrorHandlers::new()
                .handler(http::StatusCode::INTERNAL_SERVER_ERROR, render_500),
        )
        .resource("/test", |r| {
            r.method(http::Method::GET).f(|_| HttpResponse::Ok());
            r.method(http::Method::HEAD)
                .f(|_| HttpResponse::MethodNotAllowed());
        })
        .finish();
}

Methods

impl<S> ErrorHandlers<S>[src]

pub fn new() -> Self[src]

Construct new ErrorHandlers instance

pub fn handler<F>(self, status: StatusCode, handler: F) -> Self where
    F: Fn(&HttpRequest<S>, HttpResponse) -> Result<Response> + 'static, 
[src]

Register error handler for specified status code

Trait Implementations

impl<S: 'static> Middleware<S> for ErrorHandlers<S>[src]

fn start(&self, req: &HttpRequest<S>) -> Result<Started>[src]

Method is called when request is ready. It may return future, which should resolve before next middleware get called. Read more

fn finish(&self, req: &HttpRequest<S>, resp: &HttpResponse) -> Finished[src]

Method is called after body stream get sent to peer.

impl<S> Default for ErrorHandlers<S>[src]

Auto Trait Implementations

impl<S> !Send for ErrorHandlers<S>

impl<S> !Sync for ErrorHandlers<S>

Blanket Implementations

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T> From for T[src]

impl<T, U> TryFrom for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Erased for T