service.rs

//! Service trait — the user-supplied request handler.
//!
//! This mirrors `hyper::service::Service` but is tailored to our
//! [`Request`] / [`Response`] types (which carry fds inline). Notably
//! `call` takes `&self` rather than `&mut self` so a single service
//! value can be shared across requests on a connection without
//! interior mutability boilerplate; clones are cheap when the service
//! is wrapped in an `Arc`.

use std::error::Error as StdError;
use std::future::Future;

use crate::message::{Request, Response};

/// An async handler from [`Request`] to [`Response`].
pub trait Service {
    /// Errors produced by the handler. Non-`Service`-fatal errors should
    /// generally be turned into 4xx/5xx responses instead of returned
    /// here; returning an `Err` aborts the connection.
    type Error: Into<Box<dyn StdError + Send + Sync>>;

    /// The future returned by `call`.
    type Future: Future<Output = Result<Response, Self::Error>>;

    fn call(&self, req: Request) -> Self::Future;
}

// Blanket impls for common smart-pointer wrappers, mirroring hyper.
impl<S: Service + ?Sized> Service for &S {
    type Error = S::Error;
    type Future = S::Future;
    fn call(&self, req: Request) -> Self::Future {
        (**self).call(req)
    }
}

impl<S: Service + ?Sized> Service for Box<S> {
    type Error = S::Error;
    type Future = S::Future;
    fn call(&self, req: Request) -> Self::Future {
        (**self).call(req)
    }
}

impl<S: Service + ?Sized> Service for std::sync::Arc<S> {
    type Error = S::Error;
    type Future = S::Future;
    fn call(&self, req: Request) -> Self::Future {
        (**self).call(req)
    }
}

impl<S: Service + ?Sized> Service for std::rc::Rc<S> {
    type Error = S::Error;
    type Future = S::Future;
    fn call(&self, req: Request) -> Self::Future {
        (**self).call(req)
    }
}

/// Adapter turning a closure `Fn(Request) -> Future<Output = Result<Response, E>>`
/// into a [`Service`]. Useful for tests and one-off handlers.
pub fn service_fn<F, Fut, E>(f: F) -> ServiceFn<F>
where
    F: Fn(Request) -> Fut,
    Fut: Future<Output = Result<Response, E>>,
    E: Into<Box<dyn StdError + Send + Sync>>,
{
    ServiceFn { f }
}

#[derive(Clone, Copy, Debug)]
pub struct ServiceFn<F> {
    f: F,
}

impl<F, Fut, E> Service for ServiceFn<F>
where
    F: Fn(Request) -> Fut,
    Fut: Future<Output = Result<Response, E>>,
    E: Into<Box<dyn StdError + Send + Sync>>,
{
    type Error = E;
    type Future = Fut;
    fn call(&self, req: Request) -> Self::Future {
        (self.f)(req)
    }
}