src/lib.rs

use self::{
    body::Body,
    routing::{AlwaysNotFound, RouteAt},
};
use body::BoxBody;
use bytes::Bytes;
use futures_util::ready;
use http::{Request, Response};
use pin_project::pin_project;
use response::IntoResponse;
use std::{
    convert::Infallible,
    fmt,
    future::Future,
    pin::Pin,
    task::{Context, Poll},
};
use tower::{BoxError, Service};

pub mod body;
pub mod extract;
pub mod handler;
pub mod response;
pub mod routing;

pub use async_trait::async_trait;
pub use tower_http::add_extension::{AddExtension, AddExtensionLayer};

#[cfg(test)]
mod tests;

pub fn app() -> App<AlwaysNotFound> {
    App {
        service_tree: AlwaysNotFound(()),
    }
}

#[derive(Debug, Clone)]
pub struct App<R> {
    service_tree: R,
}

impl<R> App<R> {
    fn new(service_tree: R) -> Self {
        Self { service_tree }
    }

    pub fn at(self, route_spec: &str) -> RouteAt<R> {
        self.at_bytes(Bytes::copy_from_slice(route_spec.as_bytes()))
    }

    fn at_bytes(self, route_spec: Bytes) -> RouteAt<R> {
        RouteAt {
            app: self,
            route_spec,
        }
    }
}

#[derive(Clone)]
pub struct IntoService<R> {
    service_tree: R
}

impl<R, B, T> Service<T> for IntoService<R>
where
    R: Service<T, Response = Response<B>, Error = Infallible>,
    B: Default,
{
    type Response = Response<B>;
    type Error = Infallible;
    type Future = R::Future;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        match ready!(self.service_tree.poll_ready(cx)) {
            Ok(_) => Poll::Ready(Ok(())),
            Err(err) => match err {},
        }
    }

    fn call(&mut self, req: T) -> Self::Future {
        self.service_tree.call(req)
    }
}

pub(crate) trait ResultExt<T> {
    fn unwrap_infallible(self) -> T;
}

impl<T> ResultExt<T> for Result<T, Infallible> {
    fn unwrap_infallible(self) -> T {
        match self {
            Ok(value) => value,
            Err(err) => match err {},
        }
    }
}

// work around for `BoxError` not implementing `std::error::Error`
//
// This is currently required since tower-http's Compression middleware's body type's
// error only implements error when the inner error type does:
// https://github.com/tower-rs/tower-http/blob/master/tower-http/src/lib.rs#L310
//
// Fixing that is a breaking change to tower-http so we should wait a bit, but should
// totally fix it at some point.
#[derive(Debug, thiserror::Error)]
#[error("{0}")]
pub struct BoxStdError(#[source] pub(crate) tower::BoxError);

pub trait ServiceExt<B>: Service<Request<Body>, Response = Response<B>> {
    fn handle_error<F, Res>(self, f: F) -> HandleError<Self, F, Self::Error>
    where
        Self: Sized,
        F: FnOnce(Self::Error) -> Res,
        Res: IntoResponse<Body>,
        B: http_body::Body<Data = Bytes> + Send + Sync + 'static,
        B::Error: Into<BoxError> + Send + Sync + 'static,
    {
        HandleError::new(self, f)
    }
}

impl<S, B> ServiceExt<B> for S where S: Service<Request<Body>, Response = Response<B>> {}

pub struct HandleError<S, F, E> {
    inner: S,
    f: F,
    poll_ready_error: Option<E>,
}

impl<S, F, E> HandleError<S, F, E> {
    pub(crate) fn new(inner: S, f: F) -> Self {
        Self {
            inner,
            f,
            poll_ready_error: None,
        }
    }
}

impl<S, F, E> fmt::Debug for HandleError<S, F, E>
where
    S: fmt::Debug,
    E: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("HandleError")
            .field("inner", &self.inner)
            .field("f", &format_args!("{}", std::any::type_name::<F>()))
            .field("poll_ready_error", &self.poll_ready_error)
            .finish()
    }
}

impl<S, F, E> Clone for HandleError<S, F, E>
where
    S: Clone,
    F: Clone,
{
    fn clone(&self) -> Self {
        Self {
            inner: self.inner.clone(),
            f: self.f.clone(),
            poll_ready_error: None,
        }
    }
}

impl<S, F, B, Res> Service<Request<Body>> for HandleError<S, F, S::Error>
where
    S: Service<Request<Body>, Response = Response<B>>,
    F: FnOnce(S::Error) -> Res + Clone,
    Res: IntoResponse<Body>,
    B: http_body::Body<Data = Bytes> + Send + Sync + 'static,
    B::Error: Into<BoxError> + Send + Sync + 'static,
{
    type Response = Response<BoxBody>;
    type Error = Infallible;
    type Future = HandleErrorFuture<S::Future, F, S::Error>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        match ready!(self.inner.poll_ready(cx)) {
            Ok(_) => Poll::Ready(Ok(())),
            Err(err) => {
                self.poll_ready_error = Some(err);
                Poll::Ready(Ok(()))
            }
        }
    }

    fn call(&mut self, req: Request<Body>) -> Self::Future {
        if let Some(err) = self.poll_ready_error.take() {
            return HandleErrorFuture {
                f: Some(self.f.clone()),
                kind: Kind::Error(Some(err)),
            };
        }

        HandleErrorFuture {
            f: Some(self.f.clone()),
            kind: Kind::Future(self.inner.call(req)),
        }
    }
}

#[pin_project]
pub struct HandleErrorFuture<Fut, F, E> {
    #[pin]
    kind: Kind<Fut, E>,
    f: Option<F>,
}

#[pin_project(project = KindProj)]
enum Kind<Fut, E> {
    Future(#[pin] Fut),
    Error(Option<E>),
}

impl<Fut, F, E, B, Res> Future for HandleErrorFuture<Fut, F, E>
where
    Fut: Future<Output = Result<Response<B>, E>>,
    F: FnOnce(E) -> Res,
    Res: IntoResponse<Body>,
    B: http_body::Body<Data = Bytes> + Send + Sync + 'static,
    B::Error: Into<BoxError> + Send + Sync + 'static,
{
    type Output = Result<Response<BoxBody>, Infallible>;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let this = self.project();

        match this.kind.project() {
            KindProj::Future(future) => match ready!(future.poll(cx)) {
                Ok(res) => Ok(res.map(BoxBody::new)).into(),
                Err(err) => {
                    let f = this.f.take().unwrap();
                    let res = f(err).into_response();
                    Ok(res.map(BoxBody::new)).into()
                }
            },
            KindProj::Error(err) => {
                let f = this.f.take().unwrap();
                let res = f(err.take().unwrap()).into_response();
                Ok(res.map(BoxBody::new)).into()
            }
        }
    }
}
Break things into modules 2021-05-30 13:24:03 +02:00			`use self::{`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`body::Body,`
More work 2021-05-31 16:28:26 +02:00			`routing::{AlwaysNotFound, RouteAt},`
Break things into modules 2021-05-30 13:24:03 +02:00			`};`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`use body::BoxBody;`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`use bytes::Bytes;`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`use futures_util::ready;`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`use http::{Request, Response};`
better readiness handling and less boxing 2021-05-30 01:11:18 +02:00			`use pin_project::pin_project;`
More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`use response::IntoResponse;`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`use std::{`
More error handling 2021-06-01 00:34:09 +02:00			`convert::Infallible,`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`fmt,`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`future::Future,`
better readiness handling and less boxing 2021-05-30 01:11:18 +02:00			`pin::Pin,`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`task::{Context, Poll},`
			`};`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`use tower::{BoxError, Service};`
Initial pile of hacks 2021-05-29 21:13:06 +02:00
Break things into modules 2021-05-30 13:24:03 +02:00			`pub mod body;`
			`pub mod extract;`
			`pub mod handler;`
			`pub mod response;`
			`pub mod routing;`

Quality of life improvements 2021-06-01 14:52:18 +02:00			`pub use async_trait::async_trait;`
More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`pub use tower_http::add_extension::{AddExtension, AddExtensionLayer};`
Quality of life improvements 2021-06-01 14:52:18 +02:00
Start writing more tests 2021-05-31 12:22:16 +02:00			`#[cfg(test)]`
			`mod tests;`

More work 2021-05-31 16:28:26 +02:00			`pub fn app() -> App<AlwaysNotFound> {`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`App {`
More work 2021-05-31 16:28:26 +02:00			`service_tree: AlwaysNotFound(()),`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`}`
			`}`

A bit of clean up 2021-05-30 00:52:04 +02:00			`#[derive(Debug, Clone)]`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`pub struct App<R> {`
More work 2021-05-31 16:28:26 +02:00			`service_tree: R,`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`}`

			`impl<R> App<R> {`
Adding layers to the whole thing 2021-06-01 21:15:48 +02:00			`fn new(service_tree: R) -> Self {`
			`Self { service_tree }`
			`}`

A bit of clean up 2021-05-30 00:52:04 +02:00			`pub fn at(self, route_spec: &str) -> RouteAt<R> {`
			`self.at_bytes(Bytes::copy_from_slice(route_spec.as_bytes()))`
			`}`

			`fn at_bytes(self, route_spec: Bytes) -> RouteAt<R> {`
			`RouteAt {`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`app: self,`
A bit of clean up 2021-05-30 00:52:04 +02:00			`route_spec,`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`}`
			`}`
			`}`

Adding layers to the whole thing 2021-06-01 21:15:48 +02:00			`#[derive(Clone)]`
Fix layer support 2021-05-30 04:28:24 +02:00			`pub struct IntoService<R> {`
Adding layers to the whole thing 2021-06-01 21:15:48 +02:00			`service_tree: R`
Fix layer support 2021-05-30 04:28:24 +02:00			`}`

			`impl<R, B, T> Service<T> for IntoService<R>`
			`where`
More error handling 2021-06-01 00:34:09 +02:00			`R: Service<T, Response = Response<B>, Error = Infallible>,`
Fix layer support 2021-05-30 04:28:24 +02:00			`B: Default,`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`{`
Fix layer support 2021-05-30 04:28:24 +02:00			`type Response = Response<B>;`
More error handling 2021-06-01 00:34:09 +02:00			`type Error = Infallible;`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`type Future = R::Future;`
Initial pile of hacks 2021-05-29 21:13:06 +02:00
			`fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {`
Adding layers to the whole thing 2021-06-01 21:15:48 +02:00			`match ready!(self.service_tree.poll_ready(cx)) {`
More error handling 2021-06-01 00:34:09 +02:00			`Ok(_) => Poll::Ready(Ok(())),`
			`Err(err) => match err {},`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
Initial pile of hacks 2021-05-29 21:13:06 +02:00			`}`

A bit of clean up 2021-05-30 00:52:04 +02:00			`fn call(&mut self, req: T) -> Self::Future {`
Adding layers to the whole thing 2021-06-01 21:15:48 +02:00			`self.service_tree.call(req)`
More error handling 2021-06-01 00:34:09 +02:00			`}`
			`}`

			`pub(crate) trait ResultExt<T> {`
			`fn unwrap_infallible(self) -> T;`
			`}`

			`impl<T> ResultExt<T> for Result<T, Infallible> {`
			`fn unwrap_infallible(self) -> T {`
			`match self {`
			`Ok(value) => value,`
			`Err(err) => match err {},`
Fix layer support 2021-05-30 04:28:24 +02:00			`}`
A bit of clean up 2021-05-30 00:52:04 +02:00			`}`
Fix layer support 2021-05-30 04:28:24 +02:00			`}`
More error handling 2021-06-01 00:34:09 +02:00
			// work around for `BoxError` not implementing `std::error::Error`
			`//`
			`// This is currently required since tower-http's Compression middleware's body type's`
			`// error only implements error when the inner error type does:`
			`// https://github.com/tower-rs/tower-http/blob/master/tower-http/src/lib.rs#L310`
			`//`
			`// Fixing that is a breaking change to tower-http so we should wait a bit, but should`
			`// totally fix it at some point.`
			`#[derive(Debug, thiserror::Error)]`
			`#[error("{0}")]`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`pub struct BoxStdError(#[source] pub(crate) tower::BoxError);`

			`pub trait ServiceExt<B>: Service<Request<Body>, Response = Response<B>> {`
More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`fn handle_error<F, Res>(self, f: F) -> HandleError<Self, F, Self::Error>`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`where`
			`Self: Sized,`
More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`F: FnOnce(Self::Error) -> Res,`
			`Res: IntoResponse<Body>,`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`B: http_body::Body<Data = Bytes> + Send + Sync + 'static,`
			`B::Error: Into<BoxError> + Send + Sync + 'static,`
			`{`
More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`HandleError::new(self, f)`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`}`
			`}`

			`impl<S, B> ServiceExt<B> for S where S: Service<Request<Body>, Response = Response<B>> {}`

			`pub struct HandleError<S, F, E> {`
			`inner: S,`
			`f: F,`
			`poll_ready_error: Option<E>,`
			`}`

More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`impl<S, F, E> HandleError<S, F, E> {`
			`pub(crate) fn new(inner: S, f: F) -> Self {`
			`Self {`
			`inner,`
			`f,`
			`poll_ready_error: None,`
			`}`
			`}`
			`}`

Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`impl<S, F, E> fmt::Debug for HandleError<S, F, E>`
			`where`
			`S: fmt::Debug,`
			`E: fmt::Debug,`
			`{`
			`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
			`f.debug_struct("HandleError")`
			`.field("inner", &self.inner)`
			`.field("f", &format_args!("{}", std::any::type_name::<F>()))`
			`.field("poll_ready_error", &self.poll_ready_error)`
			`.finish()`
			`}`
			`}`

			`impl<S, F, E> Clone for HandleError<S, F, E>`
			`where`
			`S: Clone,`
			`F: Clone,`
			`{`
			`fn clone(&self) -> Self {`
			`Self {`
			`inner: self.inner.clone(),`
			`f: self.f.clone(),`
			`poll_ready_error: None,`
			`}`
			`}`
			`}`

More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`impl<S, F, B, Res> Service<Request<Body>> for HandleError<S, F, S::Error>`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`where`
			`S: Service<Request<Body>, Response = Response<B>>,`
More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`F: FnOnce(S::Error) -> Res + Clone,`
			`Res: IntoResponse<Body>,`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`B: http_body::Body<Data = Bytes> + Send + Sync + 'static,`
			`B::Error: Into<BoxError> + Send + Sync + 'static,`
			`{`
			`type Response = Response<BoxBody>;`
			`type Error = Infallible;`
			`type Future = HandleErrorFuture<S::Future, F, S::Error>;`

			`fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {`
			`match ready!(self.inner.poll_ready(cx)) {`
			`Ok(_) => Poll::Ready(Ok(())),`
			`Err(err) => {`
			`self.poll_ready_error = Some(err);`
			`Poll::Ready(Ok(()))`
			`}`
			`}`
			`}`

			`fn call(&mut self, req: Request<Body>) -> Self::Future {`
			`if let Some(err) = self.poll_ready_error.take() {`
			`return HandleErrorFuture {`
			`f: Some(self.f.clone()),`
			`kind: Kind::Error(Some(err)),`
			`};`
			`}`

			`HandleErrorFuture {`
			`f: Some(self.f.clone()),`
			`kind: Kind::Future(self.inner.call(req)),`
			`}`
			`}`
			`}`

			`#[pin_project]`
			`pub struct HandleErrorFuture<Fut, F, E> {`
			`#[pin]`
			`kind: Kind<Fut, E>,`
			`f: Option<F>,`
			`}`

			`#[pin_project(project = KindProj)]`
			`enum Kind<Fut, E> {`
			`Future(#[pin] Fut),`
			`Error(Option<E>),`
			`}`

More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`impl<Fut, F, E, B, Res> Future for HandleErrorFuture<Fut, F, E>`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`where`
			`Fut: Future<Output = Result<Response<B>, E>>,`
More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`F: FnOnce(E) -> Res,`
			`Res: IntoResponse<Body>,`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`B: http_body::Body<Data = Bytes> + Send + Sync + 'static,`
			`B::Error: Into<BoxError> + Send + Sync + 'static,`
			`{`
			`type Output = Result<Response<BoxBody>, Infallible>;`

			`fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {`
			`let this = self.project();`

			`match this.kind.project() {`
			`KindProj::Future(future) => match ready!(future.poll(cx)) {`
			`Ok(res) => Ok(res.map(BoxBody::new)).into(),`
			`Err(err) => {`
			`let f = this.f.take().unwrap();`
More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`let res = f(err).into_response();`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`Ok(res.map(BoxBody::new)).into()`
			`}`
			`},`
			`KindProj::Error(err) => {`
			`let f = this.f.take().unwrap();`
More error handling of layered handlers 2021-06-01 17:17:10 +02:00			`let res = f(err.take().unwrap()).into_response();`
Support nesting services with error handling 2021-06-01 11:23:56 +02:00			`Ok(res.map(BoxBody::new)).into()`
			`}`
			`}`
			`}`
			`}`