OpenSource/axum
OpenSource/axum
1
0
Fork 0
mirror of https://github.com/tokio-rs/axum.git synced 2025-03-13 19:27:53 +01:00
Code Issues Projects Releases Packages Wiki Activity

Remove unused file (#526)

Browse source 
This should have been removed as part of #521 but guess I missed it.
This commit is contained in:
David Pedersen 2021-11-16 21:27:21 +01:00 • committed by GitHub
parent c4081ec40e
commit 1dc49ae039
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 0 additions and 464 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

464
axum/src/routing/handler_method_routing.rs
View file

@ -1,464 +0,0 @@
//! Routing for handlers based on HTTP methods.
use crate::{
body::{box_body, BoxBody},
handler::Handler,
routing::{MethodFilter, MethodNotAllowed},
util::{Either, EitherProj},
};
use futures_util::{future::BoxFuture, ready};
use http::{Method, Request, Response};
use http_body::Empty;
use pin_project_lite::pin_project;
use std::{
convert::Infallible,
fmt,
future::Future,
marker::PhantomData,
pin::Pin,
task::{Context, Poll},
};
use tower::{util::Oneshot, ServiceExt};
use tower_service::Service;
/// Route requests with any standard HTTP method to the given handler.
///
/// # Example
///
/// ```rust
/// use axum::{
/// routing::any,
/// Router,
/// };
///
/// async fn handler() {}
///
/// let app = Router::new().route("/", any(handler));
/// # async {
/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
/// # };
/// ```
///
/// Note that this only accepts the standard HTTP methods. If you need to
/// support non-standard methods use [`Handler::into_service`]:
///
/// ```rust
/// use axum::{
/// handler::Handler,
/// Router,
/// };
///
/// async fn handler() {}
///
/// let app = Router::new().route("/", handler.into_service());
/// # async {
/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
/// # };
/// ```
pub fn any<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
where
H: Handler<B, T>,
{
on(MethodFilter::all(), handler)
}
/// Route `DELETE` requests to the given handler.
///
/// See [`get`] for an example.
pub fn delete<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
where
H: Handler<B, T>,
{
on(MethodFilter::DELETE, handler)
}
/// Route `GET` requests to the given handler.
///
/// # Example
///
/// ```rust
/// use axum::{
/// routing::get,
/// Router,
/// };
///
/// async fn handler() {}
///
/// // Requests to `GET /` will go to `handler`.
/// let app = Router::new().route("/", get(handler));
/// # async {
/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
/// # };
/// ```
///
/// 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.
pub fn get<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
where
H: Handler<B, T>,
{
on(MethodFilter::GET | MethodFilter::HEAD, handler)
}
/// Route `HEAD` requests to the given handler.
///
/// See [`get`] for an example.
pub fn head<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
where
H: Handler<B, T>,
{
on(MethodFilter::HEAD, handler)
}
/// Route `OPTIONS` requests to the given handler.
///
/// See [`get`] for an example.
pub fn options<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
where
H: Handler<B, T>,
{
on(MethodFilter::OPTIONS, handler)
}
/// Route `PATCH` requests to the given handler.
///
/// See [`get`] for an example.
pub fn patch<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
where
H: Handler<B, T>,
{
on(MethodFilter::PATCH, handler)
}
/// Route `POST` requests to the given handler.
///
/// See [`get`] for an example.
pub fn post<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
where
H: Handler<B, T>,
{
on(MethodFilter::POST, handler)
}
/// Route `PUT` requests to the given handler.
///
/// See [`get`] for an example.
pub fn put<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
where
H: Handler<B, T>,
{
on(MethodFilter::PUT, handler)
}
/// Route `TRACE` requests to the given handler.
///
/// See [`get`] for an example.
pub fn trace<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
where
H: Handler<B, T>,
{
on(MethodFilter::TRACE, handler)
}
/// Route requests with the given method to the handler.
///
/// # Example
///
/// ```rust
/// use axum::{
/// routing::on,
/// Router,
/// routing::MethodFilter,
/// };
///
/// async fn handler() {}
///
/// // Requests to `POST /` will go to `handler`.
/// let app = Router::new().route("/", on(MethodFilter::POST, handler));
/// # async {
/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
/// # };
/// ```
pub fn on<H, B, T>(method: MethodFilter, handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
where
H: Handler<B, T>,
{
MethodRouter {
method,
handler,
fallback: MethodNotAllowed::new(),
_marker: PhantomData,
}
}
/// A handler [`Service`] that accepts requests based on a [`MethodFilter`] and
/// allows chaining additional handlers.
pub struct MethodRouter<H, B, T, F> {
pub(crate) method: MethodFilter,
pub(crate) handler: H,
pub(crate) fallback: F,
pub(crate) _marker: PhantomData<fn() -> (B, T)>,
}
impl<H, B, T, F> fmt::Debug for MethodRouter<H, B, T, F>
where
T: fmt::Debug,
F: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MethodRouter")
.field("method", &self.method)
.field("handler", &format_args!("{}", std::any::type_name::<H>()))
.field("fallback", &self.fallback)
.finish()
}
}
impl<H, B, T, F> Clone for MethodRouter<H, B, T, F>
where
H: Clone,
F: Clone,
{
fn clone(&self) -> Self {
Self {
method: self.method,
handler: self.handler.clone(),
fallback: self.fallback.clone(),
_marker: PhantomData,
}
}
}
impl<H, B, T, F> Copy for MethodRouter<H, B, T, F>
where
H: Copy,
F: Copy,
{
}
impl<H, B, T, F> MethodRouter<H, B, T, F> {
/// Chain an additional handler that will accept all requests regardless of
/// its HTTP method.
///
/// See [`MethodRouter::get`] for an example.
pub fn any<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
where
H2: Handler<B, T2>,
{
self.on(MethodFilter::all(), handler)
}
/// Chain an additional handler that will only accept `DELETE` requests.
///
/// See [`MethodRouter::get`] for an example.
pub fn delete<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
where
H2: Handler<B, T2>,
{
self.on(MethodFilter::DELETE, handler)
}
/// Chain an additional handler that will only accept `GET` requests.
///
/// # Example
///
/// ```rust
/// 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));
/// # async {
/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
/// # };
/// ```
///
/// 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.
pub fn get<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
where
H2: Handler<B, T2>,
{
self.on(MethodFilter::GET | MethodFilter::HEAD, handler)
}
/// Chain an additional handler that will only accept `HEAD` requests.
///
/// See [`MethodRouter::get`] for an example.
pub fn head<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
where
H2: Handler<B, T2>,
{
self.on(MethodFilter::HEAD, handler)
}
/// Chain an additional handler that will only accept `OPTIONS` requests.
///
/// See [`MethodRouter::get`] for an example.
pub fn options<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
where
H2: Handler<B, T2>,
{
self.on(MethodFilter::OPTIONS, handler)
}
/// Chain an additional handler that will only accept `PATCH` requests.
///
/// See [`MethodRouter::get`] for an example.
pub fn patch<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
where
H2: Handler<B, T2>,
{
self.on(MethodFilter::PATCH, handler)
}
/// Chain an additional handler that will only accept `POST` requests.
///
/// See [`MethodRouter::get`] for an example.
pub fn post<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
where
H2: Handler<B, T2>,
{
self.on(MethodFilter::POST, handler)
}
/// Chain an additional handler that will only accept `PUT` requests.
///
/// See [`MethodRouter::get`] for an example.
pub fn put<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
where
H2: Handler<B, T2>,
{
self.on(MethodFilter::PUT, handler)
}
/// Chain an additional handler that will only accept `TRACE` requests.
///
/// See [`MethodRouter::get`] for an example.
pub fn trace<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
where
H2: Handler<B, T2>,
{
self.on(MethodFilter::TRACE, handler)
}
/// Chain an additional handler that will accept requests matching the given
/// `MethodFilter`.
///
/// # Example
///
/// ```rust
/// 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));
/// # async {
/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
/// # };
/// ```
pub fn on<H2, T2>(self, method: MethodFilter, handler: H2) -> MethodRouter<H2, B, T2, Self>
where
H2: Handler<B, T2>,
{
MethodRouter {
method,
handler,
fallback: self,
_marker: PhantomData,
}
}
}
impl<H, B, T, F> Service<Request<B>> for MethodRouter<H, B, T, F>
where
H: Handler<B, T>,
F: Service<Request<B>, Response = Response<BoxBody>, Error = Infallible> + Clone,
B: Send + 'static,
{
type Response = Response<BoxBody>;
type Error = Infallible;
type Future = MethodRouterFuture<F, B>;
#[inline]
fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, req: Request<B>) -> Self::Future {
let req_method = req.method().clone();
let fut = if self.method.matches(req.method()) {
let fut = Handler::call(self.handler.clone(), req);
Either::A { inner: fut }
} else {
let fut = self.fallback.clone().oneshot(req);
Either::B { inner: fut }
};
MethodRouterFuture {
inner: fut,
req_method,
}
}
}
pin_project! {
/// The response future for [`MethodRouter`].
pub struct MethodRouterFuture<F, B>
where
F: Service<Request<B>>
{
#[pin]
pub(super) inner: Either<
BoxFuture<'static, Response<BoxBody>>,
Oneshot<F, Request<B>>,
>,
pub(super) req_method: Method,
}
}
impl<F, B> Future for MethodRouterFuture<F, B>
where
F: Service<Request<B>, Response = Response<BoxBody>>,
{
type Output = Result<Response<BoxBody>, F::Error>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
let response = match this.inner.project() {
EitherProj::A { inner } => ready!(inner.poll(cx)),
EitherProj::B { inner } => ready!(inner.poll(cx))?,
};
if this.req_method == &Method::HEAD {
let response = response.map(|_| box_body(Empty::new()));
Poll::Ready(Ok(response))
} else {
Poll::Ready(Ok(response))
}
}
}
impl<F, B> fmt::Debug for MethodRouterFuture<F, B>
where
F: Service<Request<B>>,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MethodRouterFuture").finish()
}
}