Struct rocket::route::Route

pub struct Route {
    pub name: Option<Cow<'static, str>>,
    pub method: Option<Method>,
    pub handler: Box<dyn Handler>,
    pub uri: RouteUri<'static>,
    pub rank: isize,
    pub format: Option<MediaType>,
    /* private fields */
}

A request handling route.

A route consists of exactly the information in its fields. While a Route can be instantiated directly, doing so should be a rare or nonexistent event. Instead, a Rocket application should use Rocket’s #[route] series of attributes to generate a Route.

#[get("/route/<path..>?query", rank = 2, format = "json")]
fn route_name(path: PathBuf) { /* handler procedure */ }

use rocket::http::{Method, MediaType};

let route = routes![route_name].remove(0);
assert_eq!(route.name.unwrap(), "route_name");
assert_eq!(route.method, Some(Method::Get));
assert_eq!(route.uri, "/route/<path..>?query");
assert_eq!(route.rank, 2);
assert_eq!(route.format.unwrap(), MediaType::JSON);

Note that the rank and format attribute parameters are optional. See #[route] for details on macro usage. Note also that a route’s mounted base becomes part of its URI; see RouteUri for details.

Routing

A request is routed to a route if it has the highest precedence (lowest rank) among all routes that match the request. See Route::matches() for details on what it means for a request to match.

Note that a single request may be routed to multiple routes if a route forwards. If a route fails, the request is instead routed to the highest precedence Catcher.

Collisions

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

Note that because query parsing is always lenient – extra and missing query parameters are allowed – queries do not directly impact whether two routes collide.

Resolving Collisions

Collisions are resolved through ranking. Routes with lower ranks have higher precedence during routing than routes with higher ranks. Thus, routes are attempted in ascending rank order. If a higher precedence route returns an Outcome of Forward, the next highest precedence route is attempted, and so on, until a route returns Success or Error, or there are no more routes to try. When all routes have been attempted, Rocket issues a 404 error, handled by the appropriate Catcher.

Default Ranking

Most collisions are automatically resolved by Rocket’s default rank. The default rank prefers static components over dynamic components in both paths and queries: the more static a route’s path and query are, the lower its rank and thus the higher its precedence.

There are three “colors” to paths and queries:

1. static - all components are static
2. partial - at least one, but not all, components are dynamic
3. wild - all components are dynamic

Static paths carry more weight than static queries. The same is true for partial and wild paths. This results in the following default ranking table:

path	query	rank
static	static	-12
static	partial	-11
static	wild	-10
static	none	-9
partial	static	-8
partial	partial	-7
partial	wild	-6
partial	none	-5
wild	static	-4
wild	partial	-3
wild	wild	-2
wild	none	-1

Recall that lower ranks have higher precedence.

Example

use rocket::Route;
use rocket::http::Method;

macro_rules! assert_rank {
    ($($uri:expr => $rank:expr,)*) => {$(
        let route = Route::new(Method::Get, $uri, rocket::route::dummy_handler);
        assert_eq!(route.rank, $rank);
    )*}
}

assert_rank! {
    "/?foo" => -12,                 // static path, static query
    "/foo/bar?a=b&bob" => -12,      // static path, static query
    "/?a=b&bob" => -12,             // static path, static query

    "/?a&<zoo..>" => -11,           // static path, partial query
    "/foo?a&<zoo..>" => -11,        // static path, partial query
    "/?a&<zoo>" => -11,             // static path, partial query

    "/?<zoo..>" => -10,             // static path, wild query
    "/foo?<zoo..>" => -10,          // static path, wild query
    "/foo?<a>&<b>" => -10,          // static path, wild query

    "/" => -9,                      // static path, no query
    "/foo/bar" => -9,               // static path, no query

    "/a/<b>?foo" => -8,             // partial path, static query
    "/a/<b..>?foo" => -8,           // partial path, static query
    "/<a>/b?foo" => -8,             // partial path, static query

    "/a/<b>?<b>&c" => -7,           // partial path, partial query
    "/a/<b..>?a&<c..>" => -7,       // partial path, partial query

    "/a/<b>?<c..>" => -6,           // partial path, wild query
    "/a/<b..>?<c>&<d>" => -6,       // partial path, wild query
    "/a/<b..>?<c>" => -6,           // partial path, wild query

    "/a/<b>" => -5,                 // partial path, no query
    "/<a>/b" => -5,                 // partial path, no query
    "/a/<b..>" => -5,               // partial path, no query

    "/<b>/<c>?foo&bar" => -4,       // wild path, static query
    "/<a>/<b..>?foo" => -4,         // wild path, static query
    "/<b..>?cat" => -4,             // wild path, static query

    "/<b>/<c>?<foo>&bar" => -3,     // wild path, partial query
    "/<a>/<b..>?a&<b..>" => -3,     // wild path, partial query
    "/<b..>?cat&<dog>" => -3,       // wild path, partial query

    "/<b>/<c>?<foo>" => -2,         // wild path, wild query
    "/<a>/<b..>?<b..>" => -2,       // wild path, wild query
    "/<b..>?<c>&<dog>" => -2,       // wild path, wild query

    "/<b>/<c>" => -1,               // wild path, no query
    "/<a>/<b..>" => -1,             // wild path, no query
    "/<b..>" => -1,                 // wild path, no query
}

Fields

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

The name of this route, if one was given.

method: Option<Method>

The method this route matches, or None to match any method.

handler: Box<dyn Handler>

The function that should be called when the route matches.

uri: RouteUri<'static>

The route URI.

rank: isize

The rank of this route. Lower ranks have higher priorities.

format: Option<MediaType>

The media type this route matches against, if any.

Implementations

impl Route

pub fn new<M: Into<Option<Method>>, H: Handler>( method: M, uri: &str, handler: H, ) -> Route

Creates a new route with the given method, path, and handler with a base of / and a computed default rank.

Panics

Panics if path is not a valid Rocket route URI.

A valid route URI is any valid Origin URI that is normalized, that is, does not contain any empty segments except for an optional trailing slash. Unlike a strict Origin, route URIs are also allowed to contain any UTF-8 characters.

Example

use rocket::Route;
use rocket::http::Method;

// this is a route matching requests to `GET /`
let index = Route::new(Method::Get, "/", handler);
assert_eq!(index.rank, -9);
assert_eq!(index.method, Some(Method::Get));
assert_eq!(index.uri, "/");

pub fn ranked<M, H, R>(rank: R, method: M, uri: &str, handler: H) -> Route

where M: Into<Option<Method>>, H: Handler + 'static, R: Into<Option<isize>>,

Creates a new route with the given rank, method, path, and handler with a base of /. If rank is None, the computed default rank is used.

Panics

Panics if path is not a valid Rocket route URI.

A valid route URI is any valid Origin URI that is normalized, that is, does not contain any empty segments except for an optional trailing slash. Unlike a strict Origin, route URIs are also allowed to contain any UTF-8 characters.

Example

use rocket::Route;
use rocket::http::Method;

let foo = Route::ranked(1, Method::Post, "/foo?bar", handler);
assert_eq!(foo.rank, 1);
assert_eq!(foo.method, Some(Method::Post));
assert_eq!(foo.uri, "/foo?bar");

let foo = Route::ranked(None, Method::Post, "/foo?bar", handler);
assert_eq!(foo.rank, -12);
assert_eq!(foo.method, Some(Method::Post));
assert_eq!(foo.uri, "/foo?bar");

pub fn rebase(self, base: Origin<'_>) -> Self

Prefix base to any existing mount point base in self.

If the the current mount point base is /, then the base is replaced by base. Otherwise, base is prefixed to the existing base.

use rocket::Route;
use rocket::http::Method;

// The default base is `/`.
let index = Route::new(Method::Get, "/foo/bar", handler);

// Since the base is `/`, rebasing replaces the base.
let rebased = index.rebase(uri!("/boo"));
assert_eq!(rebased.uri.base(), "/boo");

// Now every rebase prefixes.
let rebased = rebased.rebase(uri!("/base"));
assert_eq!(rebased.uri.base(), "/base/boo");

// Rebasing to `/` does nothing.
let rebased = rebased.rebase(uri!("/"));
assert_eq!(rebased.uri.base(), "/base/boo");

// Note that trailing slashes are preserved:
let index = Route::new(Method::Get, "/foo", handler);
let rebased = index.rebase(uri!("/boo/"));
assert_eq!(rebased.uri.base(), "/boo/");

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

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

Maps the base of this route using mapper, returning a new Route with the returned base.

Note: Prefer to use Route::rebase() whenever possible!

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::Route;
use rocket::http::Method;

let index = Route::new(Method::Get, "/foo/bar", handler);
assert_eq!(index.uri.base(), "/");
assert_eq!(index.uri.unmounted().path(), "/foo/bar");
assert_eq!(index.uri.path(), "/foo/bar");

let mapped = index.map_base(|base| format!("{}{}", "/boo", base)).unwrap();
assert_eq!(mapped.uri.base(), "/boo/");
assert_eq!(mapped.uri.unmounted().path(), "/foo/bar");
assert_eq!(mapped.uri.path(), "/boo/foo/bar");

// Note that this produces different `base` results than `rebase`!
let rebased = index.rebase(uri!("/boo"));
assert_eq!(rebased.uri.base(), "/boo");
assert_eq!(rebased.uri.unmounted().path(), "/foo/bar");
assert_eq!(rebased.uri.path(), "/boo/foo/bar");

impl Route

pub fn collides_with(&self, other: &Route) -> bool

Returns true if self collides with other.

A collision between two routes occurs when there exists a request that could match either route. That is, a routing ambiguity would ensue if both routes were made available to the router.

Specifically, a collision occurs when two routes a and b:

• Have the same method.
• Have the same rank.
• The routes’ methods don’t support a payload or the routes’ methods support a payload and the formats overlap. Formats overlap when:
  • The top-level type of either is * or the top-level types are equivalent.
  • The sub-level type of either is * or the sub-level types are equivalent.
• Have overlapping route URIs. This means that either:
  • The URIs have the same number of segments n, and for i in 0..n, either a.uri[i] is dynamic or b.uri[i] is dynamic or they’re both static with the same value.
  • One URI has fewer segments and ends with a trailing dynamic parameter and the preceding segments in both routes match the conditions above.

Collisions are symmetric: for any routes a and b, a.collides_with(b) => b.collides_with(a).

Example

use rocket::Route;
use rocket::http::{Method, MediaType};

// Two routes with the same method, rank, URI, and formats collide.
let a = Route::new(Method::Get, "/", handler);
let b = Route::new(Method::Get, "/", handler);
assert!(a.collides_with(&b));

// Two routes with the same method, rank, URI, and overlapping formats.
let mut a = Route::new(Method::Post, "/", handler);
a.format = Some(MediaType::new("*", "custom"));
let mut b = Route::new(Method::Post, "/", handler);
b.format = Some(MediaType::new("text", "*"));
assert!(a.collides_with(&b));

// Two routes with different ranks don't collide.
let a = Route::ranked(1, Method::Get, "/", handler);
let b = Route::ranked(2, Method::Get, "/", handler);
assert!(!a.collides_with(&b));

// Two routes with different methods don't collide.
let a = Route::new(Method::Put, "/", handler);
let b = Route::new(Method::Post, "/", handler);
assert!(!a.collides_with(&b));

// Two routes with non-overlapping URIs do not collide.
let a = Route::new(Method::Get, "/foo", handler);
let b = Route::new(Method::Get, "/bar/<baz>", handler);
assert!(!a.collides_with(&b));

// Two payload-supporting routes with non-overlapping formats.
let mut a = Route::new(Method::Post, "/", handler);
a.format = Some(MediaType::HTML);
let mut b = Route::new(Method::Post, "/", handler);
b.format = Some(MediaType::JSON);
assert!(!a.collides_with(&b));

// Two non payload-supporting routes with non-overlapping formats
// collide. A request with `Accept: */*` matches both.
let mut a = Route::new(Method::Get, "/", handler);
a.format = Some(MediaType::HTML);
let mut b = Route::new(Method::Get, "/", handler);
b.format = Some(MediaType::JSON);
assert!(a.collides_with(&b));

impl Route

pub fn matches(&self, request: &Request<'_>) -> bool

Returns true if self matches request.

A match occurs when:

• The route’s method matches that of the incoming request.
• Either the route has no format or:
  • If the route’s method supports a payload, the request’s Content-Type is fully specified and collides with the route’s format.
  • If the route’s method does not support a payload, the request either has no Accept header or it collides with with the route’s format.
• All static segments in the route’s URI match the corresponding components in the same position in the incoming request URI.
• The route URI has no query part or all static segments in the route’s query string are in the request query string, though in any position.

For a request to be routed to a particular route, that route must both match and have the highest precedence among all matching routes for that request. In other words, a match is a necessary but insufficient condition to determine if a route will handle a particular request.

The precedence of a route is determined by its rank. Routes with lower ranks have higher precedence. By default, more specific routes are assigned a lower ranking.

Example

use rocket::Route;
use rocket::http::Method;

// This route handles GET requests to `/<hello>`.
let a = Route::new(Method::Get, "/<hello>", handler);

// This route handles GET requests to `/здрасти`.
let b = Route::new(Method::Get, "/здрасти", handler);

// Let's say `request` is `GET /hello`. The request matches only `a`:
let request = client.get("/hello");
assert!(a.matches(&request));
assert!(!b.matches(&request));

// Now `request` is `GET /здрасти`. It matches both `a` and `b`:
let request = client.get("/здрасти");
assert!(a.matches(&request));
assert!(b.matches(&request));

// But `b` is more specific, so it has lower rank (higher precedence)
// by default, so Rocket would route the request to `b`, not `a`.
assert!(b.rank < a.rank);

Trait Implementations

impl Clone for Route

fn clone(&self) -> Route

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Route

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

Formats the value using the given formatter.

impl<'r> FromRequest<'r> for &'r Route

type Error = Infallible

The associated error to be returned if derivation fails.

fn from_request<'life0, 'async_trait>( request: &'r Request<'life0>, ) -> Pin<Box<dyn Future<Output = Outcome<Self, Infallible>> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait,

Derives an instance of Self from the incoming request metadata.

impl Trace for Route

fn trace(&self, level: Level)

fn trace_info(&self)

fn trace_warn(&self)

fn trace_error(&self)

fn trace_debug(&self)

fn trace_trace(&self)