Struct axum::routing::MethodRouter[−][src]

pub struct MethodRouter<B = Body, E = Infallible> { /* fields omitted */ }
Expand description

A Service that accepts requests based on a MethodFilter and allows chaining additional handlers and services.

Implementations

Create a default MethodRouter that will respond with 405 Method Not Allowed to all requests.

Chain an additional handler that will accept requests matching the given MethodFilter.

Example
use axum::{
    routing::get,
    Router,
    routing::MethodFilter
};

async fn handler() {}

async fn other_handler() {}

// Requests to `GET /` will go to `handler` and `DELETE /` will go to
// `other_handler`
let app = Router::new().route("/", get(handler).on(MethodFilter::DELETE, other_handler));

Chain an additional handler that will only accept DELETE requests.

See MethodRouter::get for an example.

Chain an additional handler that will only accept GET requests.

Example
use axum::{routing::post, Router};

async fn handler() {}

async fn other_handler() {}

// Requests to `GET /` will go to `handler` and `POST /` will go to
// `other_handler`.
let app = Router::new().route("/", post(handler).get(other_handler));

Note that get routes will also be called for HEAD requests but will have the response body removed. Make sure to add explicit HEAD routes afterwards.

Chain an additional handler that will only accept HEAD requests.

See MethodRouter::get for an example.

Chain an additional handler that will only accept OPTIONS requests.

See MethodRouter::get for an example.

Chain an additional handler that will only accept PATCH requests.

See MethodRouter::get for an example.

Chain an additional handler that will only accept POST requests.

See MethodRouter::get for an example.

Chain an additional handler that will only accept PUT requests.

See MethodRouter::get for an example.

Chain an additional handler that will only accept TRACE requests.

See MethodRouter::get for an example.

Chain an additional service that will accept requests matching the given MethodFilter.

Example
use axum::{
    http::Request,
    Router,
    routing::{MethodFilter, on_service},
};
use http::Response;
use std::convert::Infallible;
use hyper::Body;

let service = tower::service_fn(|request: Request<Body>| async {
    Ok::<_, Infallible>(Response::new(Body::empty()))
});

// Requests to `DELETE /` will go to `service`
let app = Router::new().route("/", on_service(MethodFilter::DELETE, service));

Chain an additional service that will only accept DELETE requests.

See MethodRouter::get_service for an example.

Chain an additional service that will only accept GET requests.

Example
use axum::{
    http::Request,
    Router,
    routing::post_service,
};
use http::Response;
use std::convert::Infallible;
use hyper::Body;

let service = tower::service_fn(|request: Request<Body>| async {
    Ok::<_, Infallible>(Response::new(Body::empty()))
});

let other_service = tower::service_fn(|request: Request<Body>| async {
    Ok::<_, Infallible>(Response::new(Body::empty()))
});

// Requests to `GET /` will go to `service` and `POST /` will go to
// `other_service`.
let app = Router::new().route("/", post_service(service).get_service(other_service));

Note that get routes will also be called for HEAD requests but will have the response body removed. Make sure to add explicit HEAD routes afterwards.

Chain an additional service that will only accept HEAD requests.

See MethodRouter::get_service for an example.

Chain an additional service that will only accept OPTIONS requests.

See MethodRouter::get_service for an example.

Chain an additional service that will only accept PATCH requests.

See MethodRouter::get_service for an example.

Chain an additional service that will only accept POST requests.

See MethodRouter::get_service for an example.

Chain an additional service that will only accept PUT requests.

See MethodRouter::get_service for an example.

Chain an additional service that will only accept TRACE requests.

See MethodRouter::get_service for an example.

Add a fallback service to the router.

This service will be called if no routes matches the incoming request.

use axum::{
    Router,
    routing::get,
    handler::Handler,
    response::IntoResponse,
    http::{StatusCode, Method, Uri},
};

let handler = get(|| async {}).fallback(fallback.into_service());

let app = Router::new().route("/", handler);

async fn fallback(method: Method, uri: Uri) -> impl IntoResponse {
    (StatusCode::NOT_FOUND, format!("`{}` not allowed for {}", method, uri))
}
When used with MethodRouter::merge

Two routers that both have a fallback cannot be merged. Doing so results in a panic:

ⓘ
use axum::{
    routing::{get, post},
    handler::Handler,
    response::IntoResponse,
    http::{StatusCode, Uri},
};

let one = get(|| async {})
    .fallback(fallback_one.into_service());

let two = post(|| async {})
    .fallback(fallback_two.into_service());

let method_route = one.merge(two);

async fn fallback_one() -> impl IntoResponse {}
async fn fallback_two() -> impl IntoResponse {}

Apply a tower::Layer to the router.

All requests to the router will be processed by the layer’s corresponding middleware.

This can be used to add additional processing to a request for a group of routes.

Works similarly to Router::layer. See that method for more details.

Example
use axum::{routing::get, Router};
use tower::limit::ConcurrencyLimitLayer;

async fn hander() {}

let app = Router::new().route(
    "/",
    // All requests to `GET /` will be sent through `ConcurrencyLimitLayer`
    get(hander).layer(ConcurrencyLimitLayer::new(64)),
);

Apply a tower::Layer to the router that will only run if the request matches a route.

This works similarly to MethodRouter::layer except the middleware will only run if the request matches a route. This is useful for middleware that return early (such as authorization) which might otherwise convert a 405 Method Not Allowed into a 401 Unauthorized.

Example
use axum::{
    routing::get,
    Router,
};
use tower_http::auth::RequireAuthorizationLayer;

let app = Router::new().route(
    "/foo",
    get(|| async {})
        .route_layer(RequireAuthorizationLayer::bearer("password"))
);

// `GET /foo` with a valid token will receive `200 OK`
// `GET /foo` with a invalid token will receive `401 Unauthorized`
// `POST /FOO` with a invalid token will receive `405 Method Not Allowed`

Merge two routers into one.

This is useful for breaking routers into smaller pieces and combining them into one.

use axum::{
    routing::{get, post},
    Router,
};

let get = get(|| async {});
let post = post(|| async {});

let merged = get.merge(post);

let app = Router::new().route("/", merged);

// Our app now accepts
// - GET /
// - POST /

Apply a HandleErrorLayer.

This is a convenience method for doing self.layer(HandleErrorLayer::new(f)).

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Returns the “default value” for a type. Read more

Responses given by the service.

Errors produced by the service.

The future response value.

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

Process the request and return the response asynchronously. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Converts self into T using Into<T>. Read more

Converts self into a target type. Read more

Causes self to use its Binary implementation when Debug-formatted.

Causes self to use its Display implementation when Debug-formatted. Read more

Causes self to use its LowerExp implementation when Debug-formatted. Read more

Causes self to use its LowerHex implementation when Debug-formatted. Read more

Causes self to use its Octal implementation when Debug-formatted.

Causes self to use its Pointer implementation when Debug-formatted. Read more

Causes self to use its UpperExp implementation when Debug-formatted. Read more

Causes self to use its UpperHex implementation when Debug-formatted. Read more

Performs the conversion.

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Performs the conversion.

Pipes by value. This is generally the method you want to use. Read more

Borrows self and passes that borrow into the pipe function. Read more

Mutably borrows self and passes that borrow into the pipe function. Read more

Borrows self, then passes self.borrow() into the pipe function. Read more

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

Borrows self, then passes self.as_ref() into the pipe function.

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

Borrows self, then passes self.deref() into the pipe function.

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more

Should always be Self

Yields a mutable reference to the service when it is ready to accept a request.

👎 Deprecated since 0.4.6:

please use the ServiceExt::ready method instead

Yields a mutable reference to the service when it is ready to accept a request.

Yields the service when it is ready to accept a request.

Consume this Service, calling with the providing request once it is ready.

Process all requests from the given Stream, and produce a Stream of their responses. Read more

Executes a new future after this service’s future resolves. This does not alter the behaviour of the poll_ready method. Read more

Maps this service’s response value to a different value. This does not alter the behaviour of the poll_ready method. Read more

Maps this service’s error value to a different value. This does not alter the behaviour of the poll_ready method. Read more

Maps this service’s result type (Result<Self::Response, Self::Error>) to a different value, regardless of whether the future succeeds or fails. Read more

Composes a function in front of the service. Read more

Composes this service with a Filter that conditionally accepts or rejects requests based on a predicate. Read more

Composes this service with an AsyncFilter that conditionally accepts or rejects requests based on an [async predicate]. Read more

Composes an asynchronous function after this service. Read more

Composes a function that transforms futures produced by the service. Read more

Convert the service into a Service + Send trait object. Read more

Convert the service into a Service + Clone + Send trait object. Read more

Immutable access to a value. Read more

Mutable access to a value. Read more

Immutable access to the Borrow<B> of a value. Read more

Mutable access to the BorrowMut<B> of a value. Read more

Immutable access to the AsRef<R> view of a value. Read more

Mutable access to the AsMut<R> view of a value. Read more

Immutable access to the Deref::Target of a value. Read more

Mutable access to the Deref::Target of a value. Read more

Calls .tap() only in debug builds, and is erased in release builds.

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

Provides immutable access for inspection. Read more

Calls tap in debug builds, and does nothing in release builds.

Provides mutable access for modification. Read more

Calls tap_mut in debug builds, and does nothing in release builds.

Provides immutable access to the reference for inspection.

Calls tap_ref in debug builds, and does nothing in release builds.

Provides mutable access to the reference for modification.

Calls tap_ref_mut in debug builds, and does nothing in release builds.

Provides immutable access to the borrow for inspection. Read more

Calls tap_borrow in debug builds, and does nothing in release builds.

Provides mutable access to the borrow for modification.

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

Immutably dereferences self for inspection.

Calls tap_deref in debug builds, and does nothing in release builds.

Mutably dereferences self for modification.

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

Attempts to convert self into T using TryInto<T>. Read more

Attempts to convert self into a target type. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more