Struct rocket::catcher::Catcher

pub struct Catcher {
    pub name: Option<Cow<'static, str>>,
    pub base: Origin<'static>,
    pub code: Option<u16>,
    pub handler: Box<dyn Handler>,
}

An error catching route.

Catchers are routes that run when errors are produced by the application. They consist of a Handler and an optional status code to match against arising errors. Errors arise from the the following sources:

• A failing guard.
• A failing responder.
• A forwarding guard.
• Routing failure.

Each error or forward is paired with a status code. Guards and responders indicate the status code themselves via their Err and Outcome return value. A complete routing failure is always a 404. Rocket invokes the error handler for the catcher with an error’s status code, or in the case of every route resulting in a forward, the last forwarded status code.

Error Handler Restrictions

Because error handlers are a last resort, they should not fail to produce a response. If an error handler does fail, Rocket invokes its default 500 error catcher. Error handlers cannot forward.

Routing

If a route fails by returning an error Outcome, Rocket routes the erroring request to the highest precedence catcher among all the catchers that match. Precedence is determined by the catcher’s base, which is provided as the first argument to Rocket::register(). Catchers with more non-empty segments have a higher precedence.

Rocket provides built-in defaults, but default catchers can also be registered. A default catcher is a catcher with no explicit status code: None.

Collisions

Two catchers are said to collide if there exists an error that matches both catchers. Colliding catchers present a routing ambiguity and are thus disallowed by Rocket. Because catchers can be constructed dynamically, collision checking is done at ignite time, after it becomes statically impossible to register any more catchers on an instance of Rocket.

Built-In Default

Rocket’s provides a built-in default catcher that can handle all errors. It produces HTML or JSON, depending on the value of the Accept header. As such, catchers only need to be registered if an error needs to be handled in a custom fashion. The built-in default never conflicts with any user-registered catchers.

Code Generation

Catchers should rarely be constructed or used directly. Instead, they are typically generated via the catch attribute, as follows:

#[macro_use] extern crate rocket;

use rocket::Request;
use rocket::http::Status;

#[catch(500)]
fn internal_error() -> &'static str {
    "Whoops! Looks like we messed up."
}

#[catch(404)]
fn not_found(req: &Request) -> String {
    format!("I couldn't find '{}'. Try something else?", req.uri())
}

#[catch(default)]
fn default(status: Status, req: &Request) -> String {
    format!("{} ({})", status, req.uri())
}

#[launch]
fn rocket() -> _ {
    rocket::build().register("/", catchers![internal_error, not_found, default])
}

A function decorated with #[catch] may take zero, one, or two arguments. It’s type signature must be one of the following, where R:Responder:

• fn() -> R
• fn(&Request) -> R
• fn(Status, &Request) -> R

See the catch documentation for full details.

Fields

name: Option<Cow<'static, str>>

The name of this catcher, if one was given.

base: Origin<'static>

The mount point.

code: Option<u16>

The HTTP status to match against if this route is not default.

handler: Box<dyn Handler>

The catcher’s associated error handler.

Implementations

impl Catcher

pub fn new<S, H>(code: S, handler: H) -> Catcher

where S: Into<Option<u16>>, H: Handler,

Creates a catcher for the given status, or a default catcher if status is None, using the given error handler. This should only be used when routing manually.

Examples

use rocket::request::Request;
use rocket::catcher::{Catcher, BoxFuture};
use rocket::response::Responder;
use rocket::http::Status;

fn handle_404<'r>(status: Status, req: &'r Request<'_>) -> BoxFuture<'r> {
   let res = (status, format!("404: {}", req.uri()));
   Box::pin(async move { res.respond_to(req) })
}

fn handle_500<'r>(_: Status, req: &'r Request<'_>) -> BoxFuture<'r> {
    Box::pin(async move{ "Whoops, we messed up!".respond_to(req) })
}

fn handle_default<'r>(status: Status, req: &'r Request<'_>) -> BoxFuture<'r> {
   let res = (status, format!("{}: {}", status, req.uri()));
   Box::pin(async move { res.respond_to(req) })
}

let not_found_catcher = Catcher::new(404, handle_404);
let internal_server_error_catcher = Catcher::new(500, handle_500);
let default_error_catcher = Catcher::new(None, handle_default);

Panics

Panics if code is not in the HTTP status code error range [400, 600).

pub fn map_base<'a, F>(self, mapper: F) -> Result<Self, Error<'static>>

where F: FnOnce(Origin<'a>) -> String,

Maps the base of this catcher using mapper, returning a new Catcher with the returned base.

mapper is called with the current base. The returned String is used as the new base if it is a valid URI. If the returned base URI contains a query, it is ignored. Returns an error if the base produced by mapper is not a valid origin URI.

Example

use rocket::request::Request;
use rocket::catcher::{Catcher, BoxFuture};
use rocket::response::Responder;
use rocket::http::Status;

fn handle_404<'r>(status: Status, req: &'r Request<'_>) -> BoxFuture<'r> {
   let res = (status, format!("404: {}", req.uri()));
   Box::pin(async move { res.respond_to(req) })
}

let catcher = Catcher::new(404, handle_404);
assert_eq!(catcher.base.path(), "/");

let catcher = catcher.map_base(|_| format!("/bar")).unwrap();
assert_eq!(catcher.base.path(), "/bar");

let catcher = catcher.map_base(|base| format!("/foo{}", base)).unwrap();
assert_eq!(catcher.base.path(), "/foo/bar");

let catcher = catcher.map_base(|base| format!("/foo ? {}", base));
assert!(catcher.is_err());

Trait Implementations

impl Clone for Catcher

fn clone(&self) -> Catcher

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Catcher

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

Formats the value using the given formatter.

impl Default for Catcher

fn default() -> Self

Returns the “default value” for a type.

impl Display for Catcher

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

Formats the value using the given formatter.