Struct httprouter::Router

pub struct Router {
    pub redirect_trailing_slash: bool,
    pub redirect_fixed_path: bool,
    pub handle_method_not_allowed: bool,
    pub handle_options: bool,
    pub global_options: Option<Box<dyn Handler>>,
    pub not_found: Option<Box<dyn Handler>>,
    pub method_not_allowed: Option<Box<dyn Handler>>,
    // some fields omitted
}

Router dispatches requests to different handlers via configurable routes.

Fields

redirect_trailing_slash: bool

Enables automatic redirection if the current route can't be matched but a handler for the path with (without) the trailing slash exists. For example if /foo/ is requested but a route only exists for /foo, the client is redirected to /foo with HTTP status code 301 for GET requests and 307 for all other request methods.

redirect_fixed_path: bool

If enabled, the router tries to fix the current request path, if no handle is registered for it. First superfluous path elements like ../ or // are removed. Afterwards the router does a case-insensitive lookup of the cleaned path. If a handle can be found for this route, the router makes a redirection to the corrected path with status code 301 for GET requests and 307 for all other request methods. For example /FOO and /..//Foo could be redirected to /foo. redirect_trailing_slash is independent of this option.

handle_method_not_allowed: bool

If enabled, the router checks if another method is allowed for the current route, if the current request can not be routed. If this is the case, the request is answered with MethodNotAllowed and HTTP status code 405. If no other Method is allowed, the request is delegated to the NotFound handler.

handle_options: bool

If enabled, the router automatically replies to OPTIONS requests. Custom OPTIONS handlers take priority over automatic replies.

global_options: Option<Box<dyn Handler>>

An optional handler that is called on automatic OPTIONS requests. The handler is only called if handle_options is true and no OPTIONS handler for the specific path was set. The Allowed header is set before calling the handler.

not_found: Option<Box<dyn Handler>>

Configurable handler which is called when no matching route is found.

method_not_allowed: Option<Box<dyn Handler>>

A configurable handler which is called when a request cannot be routed and handle_method_not_allowed is true. The Allow header with allowed request methods is set before the handler is called.

Implementations

impl Router

pub fn handle(
    &mut self,
    path: &str,
    method: Method,
    handler: impl Handler + 'static
)

Insert a value into the router for a specific path indexed by a key.

use httprouter::Router;
use hyper::{Response, Body, Method};

let mut router: Router = Router::default();
router.handle("/teapot", Method::GET, |_| {
    async { Ok(Response::new(Body::from("I am a teapot!"))) }
});

pub fn lookup(
    &mut self,
    method: &Method,
    path: &str
) -> Result<Match<'_, Box<dyn Handler>>, bool>

Lookup allows the manual lookup of handler for a specific method and path. If the handler is not found, it returns a Err(bool) indicating whether a redirection should be performed to the same path with a trailing slash

use httprouter::Router;
use hyper::{Response, Body, Method};

let mut router = Router::default();
router.get("/home", |_| {
    async { Ok(Response::new(Body::from("Welcome!"))) }
});

let res = router.lookup(&Method::GET, "/home").unwrap();
assert!(res.params.is_empty());

pub fn serve_files()

TODO

pub fn get(&mut self, path: &str, handler: impl Handler + 'static)

Register a handler for GET requests

pub fn head(&mut self, path: &str, handler: impl Handler + 'static)

Register a handler for HEAD requests

pub fn options(&mut self, path: &str, handler: impl Handler + 'static)

Register a handler for OPTIONS requests

pub fn post(&mut self, path: &str, handler: impl Handler + 'static)

Register a handler for POST requests

pub fn put(&mut self, path: &str, handler: impl Handler + 'static)

Register a handler for PUT requests

pub fn patch(&mut self, path: &str, handler: impl Handler + 'static)

Register a handler for PATCH requests

pub fn delete(&mut self, path: &str, handler: impl Handler + 'static)

Register a handler for DELETE requests

pub fn allowed(&self, path: &str) -> Vec<String>

Returns a list of the allowed methods for a specific path

use httprouter::Router;
use hyper::{Response, Body, Method};

let mut router = Router::default();
router.get("/home", |_| {
    async { Ok(Response::new(Body::from("Welcome!"))) }
});

let allowed = router.allowed("/home");
assert!(allowed.contains(&"GET".to_string()));

impl Router

pub fn into_service<'a>(self) -> MakeRouterService

Converts the Router into a Service which you can serve directly with Hyper. If you have an existing Service that you want to incorporate a Router into, see Router::serve.

// Our router...
let router = Router::default();

// Convert it into a service...
let service = router.into_service();

// Serve with hyper
hyper::Server::bind(&([127, 0, 0, 1], 3030).into())
    .serve(service)
    .await?;

pub fn serve(
    &self,
    req: Request<Body>
) -> Pin<Box<dyn Future<Output = Result<Response<Body>>> + Send + Sync>>

An asynchronous function from a Request to a Response. You will generally not need to use this function directly, and instead use Router::into_service. However, it may be useful when incorporating the router into a larger service.

let mut router: Router = Router::default();

let router = Arc::new(router);
    
let make_svc = make_service_fn(move |_| {
    let router = router.clone();
    async move {
        Ok::<_, Infallible>(service_fn(move |req: Request<Body>| {
            let router = router.clone();
            async move { router.serve(req).await }
        }))
    }
});

let server = Server::bind(&([127, 0, 0, 1], 3000).into())
    .serve(make_svc)
    .await;

Trait Implementations

impl Default for Router

The default httprouter configuration

pub fn default() -> Self

Returns the "default value" for a type.