Struct actix_web::middleware::ErrorHandlers
source · pub struct ErrorHandlers<B> { /* private fields */ }
Expand description
Middleware for registering custom status code based error handlers.
Register handlers with the ErrorHandlers::handler()
method to register a custom error handler
for a given status code. Handlers can modify existing responses or create completely new ones.
To register a default handler, use the ErrorHandlers::default_handler()
method. This
handler will be used only if a response has an error status code (400-599) that isn’t covered by
a more specific handler (set with the handler()
method). See examples
below.
To register a default for only client errors (400-499) or only server errors (500-599), use the
ErrorHandlers::default_handler_client()
and ErrorHandlers::default_handler_server()
methods, respectively.
Any response with a status code that isn’t covered by a specific handler or a default handler will pass by unchanged by this middleware.
Examples
Handler Response
Header
use actix_web::http::{header, StatusCode};
use actix_web::middleware::{ErrorHandlerResponse, ErrorHandlers};
use actix_web::{dev, web, App, HttpResponse, Result};
fn add_error_header<B>(mut res: dev::ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
res.response_mut().headers_mut().insert(
header::CONTENT_TYPE,
header::HeaderValue::from_static("Error"),
);
Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
}
let app = App::new()
.wrap(ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, add_error_header))
.service(web::resource("/").route(web::get().to(HttpResponse::InternalServerError)));
Body Content
use actix_web::http::{header, StatusCode};
use actix_web::middleware::{ErrorHandlerResponse, ErrorHandlers};
use actix_web::{dev, web, App, HttpResponse, Result};
fn add_error_body<B>(res: dev::ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
// Get the error message and status code
let error_message = "An error occurred";
// Destructures ServiceResponse into request and response components
let (req, res) = res.into_parts();
// Create a new response with the modified body
let res = res.set_body(error_message).map_into_boxed_body();
// Create a new ServiceResponse with the modified response
let res = dev::ServiceResponse::new(req, res).map_into_right_body();
Ok(ErrorHandlerResponse::Response(res))
}
let app = App::new()
.wrap(ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, add_error_body))
.service(web::resource("/").route(web::get().to(HttpResponse::InternalServerError)));
Registering default handler
fn add_error_header<B>(mut res: dev::ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
res.response_mut().headers_mut().insert(
header::CONTENT_TYPE,
header::HeaderValue::from_static("Error"),
);
Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
}
fn handle_bad_request<B>(mut res: dev::ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
res.response_mut().headers_mut().insert(
header::CONTENT_TYPE,
header::HeaderValue::from_static("Bad Request Error"),
);
Ok(ErrorHandlerResponse::Response(res.map_into_left_body()))
}
// Bad Request errors will hit `handle_bad_request()`, while all other errors will hit
// `add_error_header()`. The order in which the methods are called is not meaningful.
let app = App::new()
.wrap(
ErrorHandlers::new()
.default_handler(add_error_header)
.handler(StatusCode::BAD_REQUEST, handle_bad_request)
)
.service(web::resource("/").route(web::get().to(HttpResponse::InternalServerError)));
Alternatively, you can set default handlers for only client or only server errors:
// Bad request errors will hit `handle_bad_request()`, other client errors will hit
// `add_error_header()`, and server errors will pass through unchanged
let app = App::new()
.wrap(
ErrorHandlers::new()
.default_handler_client(add_error_header) // or .default_handler_server
.handler(StatusCode::BAD_REQUEST, handle_bad_request)
)
.service(web::resource("/").route(web::get().to(HttpResponse::InternalServerError)));
Implementations§
source§impl<B> ErrorHandlers<B>
impl<B> ErrorHandlers<B>
sourcepub fn handler<F>(self, status: StatusCode, handler: F) -> Selfwhere
F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
pub fn handler<F>(self, status: StatusCode, handler: F) -> Selfwhere F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
Register error handler for specified status code.
sourcepub fn default_handler<F>(self, handler: F) -> Selfwhere
F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
pub fn default_handler<F>(self, handler: F) -> Selfwhere F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
Register a default error handler.
Any request with a status code that hasn’t been given a specific other handler (by calling
.handler()
) will fall back on this.
Note that this will overwrite any default handlers previously set by calling
.default_handler_client()
or
.default_handler_server()
, but not any set by
calling .handler()
.
sourcepub fn default_handler_client<F>(self, handler: F) -> Selfwhere
F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
pub fn default_handler_client<F>(self, handler: F) -> Selfwhere F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
Register a handler on which to fall back for client error status codes (400-499).
sourcepub fn default_handler_server<F>(self, handler: F) -> Selfwhere
F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
pub fn default_handler_server<F>(self, handler: F) -> Selfwhere F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
Register a handler on which to fall back for server error status codes (500-599).