rama

Trait Service

pub trait Service<S, Request>:
    Sized
    + Send
    + Sync
    + 'static {
    type Response: Send + 'static;
    type Error: Send + Sync + 'static;

    // Required method
    fn serve(
        &self,
        ctx: Context<S>,
        req: Request,
    ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send;

    // Provided method
    fn boxed(self) -> BoxService<S, Request, Self::Response, Self::Error> { ... }
}
Expand description

A Service that produces rama services, to serve requests with, be it transport layer requests or application layer requests.

Required Associated Types§

type Response: Send + 'static

The type of response returned by the service.

type Error: Send + Sync + 'static

The type of error returned by the service.

Required Methods§

fn serve( &self, ctx: Context<S>, req: Request, ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send

Serve a response or error for the given request, using the given context.

Provided Methods§

fn boxed(self) -> BoxService<S, Request, Self::Response, Self::Error>

Box this service to allow for dynamic dispatch.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

§

impl<S, Request> Service<S, Request> for ()
where S: Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = Request

§

type Error = Infallible

§

async fn serve( &self, _ctx: Context<S>, req: Request, ) -> Result<<() as Service<S, Request>>::Response, <() as Service<S, Request>>::Error>

§

impl<S, State, Request> Service<State, Request> for &'static S
where S: Service<State, Request>,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = <S as Service<State, Request>>::Error

§

fn serve( &self, ctx: Context<State>, req: Request, ) -> impl Future<Output = Result<<&'static S as Service<State, Request>>::Response, <&'static S as Service<State, Request>>::Error>> + Send

§

impl<S, State, Request> Service<State, Request> for Box<S>
where S: Service<State, Request>,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = <S as Service<State, Request>>::Error

§

fn serve( &self, ctx: Context<State>, req: Request, ) -> impl Future<Output = Result<<Box<S> as Service<State, Request>>::Response, <Box<S> as Service<State, Request>>::Error>> + Send

§

impl<S, State, Request> Service<State, Request> for Arc<S>
where S: Service<State, Request>,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = <S as Service<State, Request>>::Error

§

fn serve( &self, ctx: Context<State>, req: Request, ) -> impl Future<Output = Result<<Arc<S> as Service<State, Request>>::Response, <Arc<S> as Service<State, Request>>::Error>> + Send

§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, M_T10, T10, M_T11, T11, M_T12, T12, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), (M_T10, T10), (M_T11, T11), (M_T12, T12), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, M_T8: Matcher<State, Request>, T8: Service<State, Request, Response = Response, Error = Error>, M_T9: Matcher<State, Request>, T9: Service<State, Request, Response = Response, Error = Error>, M_T10: Matcher<State, Request>, T10: Service<State, Request, Response = Response, Error = Error>, M_T11: Matcher<State, Request>, T11: Service<State, Request, Response = Response, Error = Error>, M_T12: Matcher<State, Request>, T12: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, M_T10, T10, M_T11, T11, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), (M_T10, T10), (M_T11, T11), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, M_T8: Matcher<State, Request>, T8: Service<State, Request, Response = Response, Error = Error>, M_T9: Matcher<State, Request>, T9: Service<State, Request, Response = Response, Error = Error>, M_T10: Matcher<State, Request>, T10: Service<State, Request, Response = Response, Error = Error>, M_T11: Matcher<State, Request>, T11: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, M_T10, T10, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), (M_T10, T10), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, M_T8: Matcher<State, Request>, T8: Service<State, Request, Response = Response, Error = Error>, M_T9: Matcher<State, Request>, T9: Service<State, Request, Response = Response, Error = Error>, M_T10: Matcher<State, Request>, T10: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, M_T9, T9, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, M_T8: Matcher<State, Request>, T8: Service<State, Request, Response = Response, Error = Error>, M_T9: Matcher<State, Request>, T9: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), (M_T9, T9), S) as Service<State, Request>>::Error>

§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, M_T8, T8, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, M_T8: Matcher<State, Request>, T8: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), (M_T8, T8), S) as Service<State, Request>>::Error>

§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, M_T7: Matcher<State, Request>, T7: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), (M_T7, T7), S) as Service<State, Request>>::Error>

§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, M_T6: Matcher<State, Request>, T6: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), S) as Service<State, Request>>::Error>

§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, M_T5: Matcher<State, Request>, T5: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), S) as Service<State, Request>>::Error>

§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, M_T4: Matcher<State, Request>, T4: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), S) as Service<State, Request>>::Error>

§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, M_T3: Matcher<State, Request>, T3: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), (M_T3, T3), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), (M_T3, T3), S) as Service<State, Request>>::Error>

§

impl<State, M_T1, T1, M_T2, T2, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), (M_T2, T2), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, M_T2: Matcher<State, Request>, T2: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), (M_T2, T2), S) as Service<State, Request>>::Response, <((M_T1, T1), (M_T2, T2), S) as Service<State, Request>>::Error>

§

impl<State, M_T1, T1, S, Request, Response, Error> Service<State, Request> for ((M_T1, T1), S)
where State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, M_T1: Matcher<State, Request>, T1: Service<State, Request, Response = Response, Error = Error>, S: Service<State, Request, Response = Response, Error = Error>, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<((M_T1, T1), S) as Service<State, Request>>::Response, <((M_T1, T1), S) as Service<State, Request>>::Error>

Implementors§

Source§

impl Service<(), Request<Body>> for rama::cli::service::echo::EchoService

Source§

impl Service<(), Request<Body>> for HttpEchoService

§

impl<A, B, C, D, E, F, G, H, I, State, Request, Response> Service<State, Request> for Either9<A, B, C, D, E, F, G, H, I>
where A: Service<State, Request, Response = Response>, <A as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<State, Request, Response = Response>, <B as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<State, Request, Response = Response>, <C as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<State, Request, Response = Response>, <D as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<State, Request, Response = Response>, <E as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<State, Request, Response = Response>, <F as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, G: Service<State, Request, Response = Response>, <G as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, H: Service<State, Request, Response = Response>, <H as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, I: Service<State, Request, Response = Response>, <I as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, Request: Send + 'static, State: Clone + Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<A, B, C, D, E, F, G, H, State, Request, Response> Service<State, Request> for Either8<A, B, C, D, E, F, G, H>
where A: Service<State, Request, Response = Response>, <A as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<State, Request, Response = Response>, <B as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<State, Request, Response = Response>, <C as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<State, Request, Response = Response>, <D as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<State, Request, Response = Response>, <E as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<State, Request, Response = Response>, <F as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, G: Service<State, Request, Response = Response>, <G as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, H: Service<State, Request, Response = Response>, <H as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, Request: Send + 'static, State: Clone + Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<A, B, C, D, E, F, G, State, Request, Response> Service<State, Request> for Either7<A, B, C, D, E, F, G>
where A: Service<State, Request, Response = Response>, <A as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<State, Request, Response = Response>, <B as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<State, Request, Response = Response>, <C as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<State, Request, Response = Response>, <D as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<State, Request, Response = Response>, <E as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<State, Request, Response = Response>, <F as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, G: Service<State, Request, Response = Response>, <G as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, Request: Send + 'static, State: Clone + Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<A, B, C, D, E, F, State, Request, Response> Service<State, Request> for Either6<A, B, C, D, E, F>
where A: Service<State, Request, Response = Response>, <A as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<State, Request, Response = Response>, <B as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<State, Request, Response = Response>, <C as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<State, Request, Response = Response>, <D as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<State, Request, Response = Response>, <E as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<State, Request, Response = Response>, <F as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, Request: Send + 'static, State: Clone + Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<A, B, C, D, E, State, Request, Response> Service<State, Request> for Either5<A, B, C, D, E>
where A: Service<State, Request, Response = Response>, <A as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<State, Request, Response = Response>, <B as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<State, Request, Response = Response>, <C as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<State, Request, Response = Response>, <D as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, E: Service<State, Request, Response = Response>, <E as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, Request: Send + 'static, State: Clone + Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<A, B, C, D, State, Request, Response> Service<State, Request> for Either4<A, B, C, D>
where A: Service<State, Request, Response = Response>, <A as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<State, Request, Response = Response>, <B as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<State, Request, Response = Response>, <C as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, D: Service<State, Request, Response = Response>, <D as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, Request: Send + 'static, State: Clone + Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<A, B, C, State, Request, Response> Service<State, Request> for Either3<A, B, C>
where A: Service<State, Request, Response = Response>, <A as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<State, Request, Response = Response>, <B as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<State, Request, Response = Response>, <C as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, Request: Send + 'static, State: Clone + Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<A, B, State, Request, Response> Service<State, Request> for Either<A, B>
where A: Service<State, Request, Response = Response>, <A as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<State, Request, Response = Response>, <B as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, Request: Send + 'static, State: Clone + Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<A, C, L, S, State, ReqBody, ResBody> Service<State, Request<ReqBody>> for ProxyAuthService<A, C, S, L>
where A: Authority<C, L>, C: Credentials + Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, L: 'static, ReqBody: Send + 'static, ResBody: Default + Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<B, State, S, Response, IO> Service<State, IO> for HttpService<B, S>
where B: HttpCoreConnServer, State: Clone + Send + Sync + 'static, S: Service<State, Request<Body>, Response = Response, Error = Infallible>, Response: IntoResponse + Send + 'static, IO: Stream,

§

type Response = ()

§

type Error = Box<dyn Error + Send + Sync>

§

impl<F, S, State, ReqBody, ResBody, NewReqBody> Service<State, Request<ReqBody>> for MapRequestBody<S, F>
where S: Service<State, Request<NewReqBody>, Response = Response<ResBody>>, State: Clone + Send + Sync + 'static, ReqBody: Send + 'static, NewReqBody: Send + 'static, ResBody: Send + Sync + 'static, F: Fn(ReqBody) -> NewReqBody + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<NewReqBody>>>::Response

§

type Error = <S as Service<State, Request<NewReqBody>>>::Error

§

impl<F, S, State, ReqBody, ResBody, NewResBody> Service<State, Request<ReqBody>> for MapResponseBody<S, F>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, State: Clone + Send + Sync + 'static, ReqBody: Send + 'static, ResBody: Send + Sync + 'static, NewResBody: Send + Sync + 'static, F: Fn(ResBody) -> NewResBody + Clone + Send + Sync + 'static,

§

type Response = Response<NewResBody>

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<H, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, H>
where H: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

Source§

impl<Input> Service<(), Input> for TcpEchoService
where Input: Stream + Unpin,

§

impl<P, S, State, Body> Service<State, Request<Body>> for Retry<P, S>
where P: Policy<State, <S as Service<State, Request<RetryBody>>>::Response, <S as Service<State, Request<RetryBody>>>::Error>, S: Service<State, Request<RetryBody>>, <S as Service<State, Request<RetryBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, Body: Body + Send + 'static, <Body as Body>::Data: Send + 'static, <Body as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

§

impl<ReqBody, ResBody, S, P, State> Service<State, Request<ReqBody>> for Compression<S, P>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Send + 'static, P: Predicate + Send + Sync + 'static, ReqBody: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = Response<CompressionBody<ResBody>>

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<ReqBody, ResBody, S, State> Service<State, Request<ReqBody>> for PropagateHeader<S>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, State: Clone + Send + Sync + 'static, ReqBody: Send + 'static, ResBody: Send + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<ReqBody, ResBody, S, State, Auth> Service<State, Request<ReqBody>> for AsyncRequireAuthorization<S, Auth>
where Auth: AsyncAuthorizeRequest<State, ReqBody, ResponseBody = ResBody> + Send + Sync + 'static, S: Service<State, Request<<Auth as AsyncAuthorizeRequest<State, ReqBody>>::RequestBody>, Response = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = Response<ResBody>

§

type Error = <S as Service<State, Request<<Auth as AsyncAuthorizeRequest<State, ReqBody>>::RequestBody>>>::Error

§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for RemoveRequestHeader<S>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for RemoveResponseHeader<S>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for AddRequiredRequestHeaders<S>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, <S as Service<State, Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for AddRequiredResponseHeaders<S>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for SetSensitiveRequestHeaders<S>
where State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for SetSensitiveResponseHeaders<S>
where State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<ReqBody, ResBody, State, S, M> Service<State, Request<ReqBody>> for SetRequestHeader<S, M>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, M: MakeHeaderValue<State, ReqBody>,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<ReqBody, ResBody, State, S, M> Service<State, Request<ReqBody>> for SetResponseHeader<S, M>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, M: MakeHeaderValueFactory<State, ReqBody, ResBody>,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<ReqBody, ResBody, State, S, V> Service<State, Request<ReqBody>> for ValidateRequestHeader<S, V>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: Clone + Send + Sync + 'static, V: ValidateRequest<State, ReqBody, ResponseBody = ResBody>, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>,

§

type Response = Response<ResBody>

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<S, D, P, F, State, Request> Service<State, Request> for ProxyDBService<S, D, P, F>
where S: Service<State, Request>, <S as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, D: ProxyDB, <D as ProxyDB>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, P: ProxyQueryPredicate, F: UsernameFormatter<State>, State: Clone + Send + Sync + 'static, Request: TryRefIntoTransportContext<State> + Send + 'static, <Request as TryRefIntoTransportContext<State>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, F, R, State, Body> Service<State, Request<Body>> for ErrorHandler<S, F>
where S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Response: IntoResponse, F: Fn(<S as Service<State, Request<Body>>>::Error) -> R + Clone + Send + Sync + 'static, R: IntoResponse + 'static, State: Clone + Send + Sync + 'static, Body: Send + 'static,

§

impl<S, F, State, Body> Service<State, Request<Body>> for RequestMetricsService<S, F>
where S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Response: IntoResponse, F: AttributesFactory<State>, State: Clone + Send + Sync + 'static, Body: Send + 'static,

§

type Response = Response<Body>

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<S, F, State, R1, R2> Service<State, R1> for MapRequest<S, F>
where S: Service<State, R2>, F: FnOnce(R1) -> R2 + Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, R2>>::Response

§

type Error = <S as Service<State, R2>>::Error

§

impl<S, F, State, Request> Service<State, Request> for ConsumeErr<S, F>
where S: Service<State, Request>, <S as Service<State, Request>>::Response: Default, F: FnOnce(<S as Service<State, Request>>::Error) + Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = Infallible

§

impl<S, F, State, Request, Error> Service<State, Request> for MapErr<S, F>
where S: Service<State, Request>, F: FnOnce(<S as Service<State, Request>>::Error) -> Error + Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static, Error: Send + Sync + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = Error

§

impl<S, F, State, Request, R> Service<State, Request> for ConsumeErr<S, F, StaticResponse<R>>
where S: Service<State, Request>, F: FnOnce(<S as Service<State, Request>>::Error) + Clone + Send + Sync + 'static, R: Into<<S as Service<State, Request>>::Response> + Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = Infallible

§

impl<S, F, State, Request, Response> Service<State, Request> for MapResponse<S, F>
where S: Service<State, Request>, F: FnOnce(<S as Service<State, Request>>::Response) -> Response + Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static,

§

type Response = Response

§

type Error = <S as Service<State, Request>>::Error

§

impl<S, F, State, Request, Response, Error> Service<State, Request> for MapResult<S, F>
where S: Service<State, Request>, F: FnOnce(Result<<S as Service<State, Request>>::Response, <S as Service<State, Request>>::Error>) -> Result<Response, Error> + Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

impl<S, F, State, Stream> Service<State, Stream> for NetworkMetricsService<S, F>
where S: Service<State, Stream>, F: AttributesFactory<State>, State: Clone + Send + Sync + 'static, Stream: Stream,

§

type Response = <S as Service<State, Stream>>::Response

§

type Error = <S as Service<State, Stream>>::Error

§

impl<S, F, W, State, Request> Service<State, Request> for MapState<S, F>
where S: Service<W, Request>, State: Clone + Send + Sync + 'static, W: Send + Sync + 'static, F: FnOnce(State) -> W + Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = <S as Service<W, Request>>::Response

§

type Error = <S as Service<W, Request>>::Error

§

impl<S, H, M, State, Request> Service<State, Request> for HijackService<S, H, M>
where S: Service<State, Request>, H: Service<State, Request>, <H as Service<State, Request>>::Response: Into<<S as Service<State, Request>>::Response>, <H as Service<State, Request>>::Error: Into<<S as Service<State, Request>>::Error>, M: Matcher<State, Request>, State: Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = <S as Service<State, Request>>::Error

§

impl<S, H, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, H>
where S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, H: ForwardHeader + Send + Sync + 'static, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, P, State, Request> Service<State, Request> for rama::proxy::haproxy::client::HaProxyService<S, P, One>
where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, P: Send + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = EstablishedClientConnection<<S as ConnectorService<State, Request>>::Connection, State, Request>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, P, State, Request, T> Service<State, Request> for rama::proxy::haproxy::client::HaProxyService<S, P>
where S: Service<State, Request, Response = EstablishedClientConnection<T, State, Request>>, <S as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, P: Protocol + Send + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static, T: Stream + Unpin,

§

type Response = EstablishedClientConnection<T, State, Request>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, Request, Response, Error> Service<S, Request> for BoxService<S, Request, Response, Error>
where S: 'static, Request: 'static, Response: Send + 'static, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

§

impl<S, State, Body> Service<State, Request<Body>> for SetProxyAuthHttpHeaderService<S>
where S: Service<State, Request<Body>>, State: Clone + Send + Sync + 'static, Body: Send + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<S, State, Body> Service<State, Request<Body>> for HttpConnector<S>
where S: ConnectorService<State, Request<Body>>, <S as ConnectorService<State, Request<Body>>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, Body: Body + Unpin + Send + 'static, <Body as Body>::Data: Send + 'static, <Body as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

§

impl<S, State, Body> Service<State, Request<Body>> for ErrorHandler<S>
where S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Response: IntoResponse, <S as Service<State, Request<Body>>>::Error: IntoResponse, State: Clone + Send + Sync + 'static, Body: Send + 'static,

§

impl<S, State, Body> Service<State, Request<Body>> for UserAgentClassifier<S>
where S: Service<State, Request<Body>>, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<S, State, IO> Service<State, IO> for rama::net::stream::layer::http::BodyLimitService<S>
where S: Service<State, IO>, State: Clone + Send + Sync + 'static, IO: Stream,

§

type Response = <S as Service<State, IO>>::Response

§

type Error = <S as Service<State, IO>>::Error

§

impl<S, State, O, E> Service<State, Request<Body>> for UpgradeService<S, State, O>
where State: Clone + Send + Sync + 'static, S: Service<State, Request<Body>, Response = O, Error = E>, O: Send + Sync + 'static, E: Send + Sync + 'static,

§

type Response = O

§

type Error = E

§

impl<S, State, ReqBody> Service<State, Request<ReqBody>> for rama::http::layer::body_limit::BodyLimitService<S>
where S: Service<State, Request<Body>>, State: Clone + Send + Sync + 'static, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<S, State, ReqBody, ResBody> Service<State, Request<ReqBody>> for AddAuthorization<S>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<S, State, ReqBody, ResBody> Service<State, Request<ReqBody>> for CollectBody<S>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, <S as Service<State, Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, ReqBody: Send + 'static, ResBody: Body + Send + Sync + 'static, <ResBody as Body>::Data: Send, <ResBody as Body>::Error: Error + Send + Sync + 'static,

§

type Response = Response<Body>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, State, ReqBody, ResBody> Service<State, Request<ReqBody>> for Cors<S>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Default + Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<S, State, ReqBody, ResBody> Service<State, Request<ReqBody>> for Decompression<S>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, State: Clone + Send + Sync + 'static, ReqBody: Send + 'static, ResBody: Body + Send + 'static, <ResBody as Body>::Data: Send + 'static, <ResBody as Body>::Error: Send + 'static,

§

type Response = Response<DecompressionBody<ResBody>>

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<S, State, ReqBody, ResBody> Service<State, Request<ReqBody>> for NormalizePath<S>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, State: Clone + Send + Sync + 'static, ReqBody: Send + 'static, ResBody: Send + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<S, State, ReqBody, ResBody> Service<State, Request<ReqBody>> for rama::http::layer::timeout::Timeout<S>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Default + Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<S, State, ReqBody, ResBody, D> Service<State, Request<ReqBody>> for RequestDecompression<S>
where S: Service<State, Request<DecompressionBody<ReqBody>>, Response = Response<ResBody>>, <S as Service<State, Request<DecompressionBody<ReqBody>>>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, ReqBody: Body + Send + 'static, ResBody: Body<Data = D> + Send + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, D: Buf + 'static,

§

type Response = Response<UnsyncBoxBody<D, Box<dyn Error + Send + Sync>>>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, State, ReqBody, ResBody, M, OnRequestT, OnResponseT, OnFailureT, OnBodyChunkT, OnEosT, MakeSpanT> Service<State, Request<ReqBody>> for Trace<S, M, MakeSpanT, OnRequestT, OnResponseT, OnBodyChunkT, OnEosT, OnFailureT>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, <S as Service<State, Request<ReqBody>>>::Error: Display, State: Clone + Send + Sync + 'static, ReqBody: Body + Send + 'static, ResBody: Body + Send + Sync + 'static, <ResBody as Body>::Error: Display, M: MakeClassifier, <M as MakeClassifier>::Classifier: Clone, MakeSpanT: MakeSpan<ReqBody>, OnRequestT: OnRequest<ReqBody>, OnResponseT: OnResponse<ResBody> + Clone, OnBodyChunkT: OnBodyChunk<<ResBody as Body>::Data> + Clone, OnEosT: OnEos + Clone, OnFailureT: OnFailure<<M as MakeClassifier>::FailureClass> + Clone,

§

type Response = Response<ResponseBody<ResBody, <M as MakeClassifier>::ClassifyEos, OnBodyChunkT, OnEosT, OnFailureT>>

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<S, State, Request> Service<State, Request> for HttpProxyAddressService<S>
where S: Service<State, Request>, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = <S as Service<State, Request>>::Error

§

impl<S, State, Request> Service<State, Request> for HttpProxyConnector<S>
where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, Request: TryRefIntoTransportContext<State> + Send + 'static, <Request as TryRefIntoTransportContext<State>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

§

type Response = EstablishedClientConnection<Either<<S as ConnectorService<State, Request>>::Connection, Upgraded>, State, Request>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, State, Request> Service<State, Request> for ConsumeErr<S, Trace>
where S: Service<State, Request>, <S as Service<State, Request>>::Response: Default, <S as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = Infallible

§

impl<S, State, Request> Service<State, Request> for TraceErr<S>
where Request: Send + 'static, S: Service<State, Request>, <S as Service<State, Request>>::Error: Display + Send + Sync + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = <S as Service<State, Request>>::Error

§

impl<S, State, Request> Service<State, Request> for OutgoingBytesTrackerService<S>
where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Send + Sync + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = EstablishedClientConnection<BytesRWTracker<<S as ConnectorService<State, Request>>::Connection>, State, Request>

§

type Error = <S as ConnectorService<State, Request>>::Error

§

impl<S, State, Request> Service<State, Request> for rama::tls::boring::client::TlsConnector<S>
where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, Request: TryRefIntoTransportContext<State> + Send + 'static, <Request as TryRefIntoTransportContext<State>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

§

type Response = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, State, Request> Service<State, Request> for rama::tls::boring::client::TlsConnector<S, ConnectorKindSecure>
where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, Request: TryRefIntoTransportContext<State> + Send + 'static, <Request as TryRefIntoTransportContext<State>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

§

type Response = EstablishedClientConnection<SslStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, State, Request> Service<State, Request> for rama::tls::boring::client::TlsConnector<S, ConnectorKindTunnel>
where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, State, Request> Service<State, Request> for rama::tls::rustls::client::TlsConnector<S>
where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, Request: TryRefIntoTransportContext<State> + Send + 'static, <Request as TryRefIntoTransportContext<State>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

§

type Response = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, State, Request> Service<State, Request> for rama::tls::rustls::client::TlsConnector<S, ConnectorKindSecure>
where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, Request: TryRefIntoTransportContext<State> + Send + 'static, <Request as TryRefIntoTransportContext<State>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

§

type Response = EstablishedClientConnection<TlsStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, State, Request> Service<State, Request> for rama::tls::rustls::client::TlsConnector<S, ConnectorKindTunnel>
where S: ConnectorService<State, Request>, <S as ConnectorService<State, Request>>::Connection: Stream + Unpin, <S as ConnectorService<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, State: Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = EstablishedClientConnection<AutoTlsStream<<S as ConnectorService<State, Request>>::Connection>, State, Request>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, State, Request, R> Service<State, Request> for ConsumeErr<S, Trace, StaticResponse<R>>
where S: Service<State, Request>, <S as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, R: Into<<S as Service<State, Request>>::Response> + Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = Infallible

§

impl<S, T1, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1,)>
where T1: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, T3, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, T3, T4, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, T3, T4, T5, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, T3, T4, T5, T6, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, T3, T4, T5, T6, T7, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, State, Body> Service<State, Request<Body>> for SetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, T12: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<S, T, C, L> Service<S, T> for Forwarder<C, L>
where S: Clone + Send + Sync + 'static, T: Stream + Unpin, C: ConnectorService<S, Request>, <C as ConnectorService<S, Request>>::Connection: Stream + Unpin, <C as ConnectorService<S, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, L: Layer<ForwarderService<<C as ConnectorService<S, Request>>::Connection>> + Send + Sync + 'static, <L as Layer<ForwarderService<<C as ConnectorService<S, Request>>::Connection>>>::Service: Service<S, T, Response = ()>, <<L as Layer<ForwarderService<<C as ConnectorService<S, Request>>::Connection>>>::Service as Service<S, T>>::Error: Into<Box<dyn Error + Send + Sync>>,

§

type Response = ()

§

type Error = Box<dyn Error + Send + Sync>

§

impl<State> Service<State, Request<Body>> for WebService<State>
where State: Clone + Send + Sync + 'static,

§

impl<State, Body> Service<State, Request<Body>> for HttpClient
where State: Clone + Send + Sync + 'static, Body: Body + Unpin + Send + 'static, <Body as Body>::Data: Send + 'static, <Body as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

§

impl<State, Body> Service<State, Request<Body>> for HttpClientService<Body>
where State: Clone + Send + Sync + 'static, Body: Body + Unpin + Send + 'static, <Body as Body>::Data: Send + 'static, <Body as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

§

type Response = Response<Body>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<State, Body, ResBody> Service<State, Request<Body>> for Redirect<ResBody>
where State: Clone + Send + Sync + 'static, Body: Send + 'static, ResBody: Default + Send + 'static,

§

type Response = Response<ResBody>

§

type Error = Infallible

§

impl<State, Body, S> Service<State, Request<Body>> for DnsResolveModeService<S>
where State: Clone + Send + Sync + 'static, Body: Send + Sync + 'static, S: Service<State, Request<Body>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = OpaqueError

§

impl<State, ReqBody> Service<State, Request<ReqBody>> for DefaultServeDirFallback
where State: Clone + Send + Sync + 'static, ReqBody: Send + 'static,

§

impl<State, ReqBody> Service<State, Request<ReqBody>> for ServeFile
where ReqBody: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Error = <ServeDir as Service<State, Request<ReqBody>>>::Error

§

type Response = <ServeDir as Service<State, Request<ReqBody>>>::Response

§

impl<State, ReqBody, F, FResBody> Service<State, Request<ReqBody>> for ServeDir<F>
where State: Clone + Send + Sync + 'static, ReqBody: Send + 'static, F: Service<State, Request<ReqBody>, Response = Response<FResBody>, Error = Infallible> + Clone, FResBody: Body<Data = Bytes> + Send + Sync + 'static, <FResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

§

impl<State, ReqBody, ResBody, S, P> Service<State, Request<ReqBody>> for FollowRedirect<S, P>
where State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ReqBody: Body + Default + Send + 'static, ResBody: Send + 'static, P: Policy<State, ReqBody, <S as Service<State, Request<ReqBody>>>::Error> + Clone,

§

type Response = Response<ResBody>

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<State, Request, Dns, ConnectorFactory> Service<State, Request> for TcpConnector<Dns, ConnectorFactory>
where State: Clone + Send + Sync + 'static, Request: TryRefIntoTransportContext<State> + Send + 'static, <Request as TryRefIntoTransportContext<State>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static, Dns: DnsResolver + Clone, <Dns as DnsResolver>::Error: Into<Box<dyn Error + Send + Sync>>, ConnectorFactory: TcpStreamConnectorFactory<State> + Clone, <ConnectorFactory as TcpStreamConnectorFactory<State>>::Connector: TcpStreamConnector, <<ConnectorFactory as TcpStreamConnectorFactory<State>>::Connector as TcpStreamConnector>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static, <ConnectorFactory as TcpStreamConnectorFactory<State>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static,

§

type Response = EstablishedClientConnection<TcpStream, State, Request>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<State, Request, F, T, R, O, E> Service<State, Request> for ServiceFn<F, T, R, O, E>
where F: Factory<T, R, O, E>, R: Future<Output = Result<O, E>> + Send + 'static, T: FromContextRequest<State, Request>, O: Send + 'static, E: Send + Sync + 'static,

§

type Response = O

§

type Error = E

§

impl<State, Request, S, T> Service<State, Request> for AddExtension<S, T>
where State: Clone + Send + Sync + 'static, Request: Send + 'static, S: Service<State, Request>, T: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = <S as Service<State, Request>>::Error

§

impl<State, Request, S, T, Fut, F> Service<State, Request> for GetExtension<S, T, Fut, F>
where State: Clone + Send + Sync + 'static, Request: Send + 'static, S: Service<State, Request>, T: Clone + Send + Sync + 'static, F: FnOnce(T) -> Fut + Clone + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

§

type Response = <S as Service<State, Request>>::Response

§

type Error = <S as Service<State, Request>>::Error

§

impl<State, S, IO> Service<State, IO> for IncomingBytesTrackerService<S>
where State: Clone + Send + Sync + 'static, S: Service<State, BytesRWTracker<IO>>, IO: Stream,

§

type Response = <S as Service<State, BytesRWTracker<IO>>>::Response

§

type Error = <S as Service<State, BytesRWTracker<IO>>>::Error

§

impl<State, S, IO> Service<State, IO> for rama::proxy::haproxy::server::HaProxyService<S>
where State: Clone + Send + Sync + 'static, S: Service<State, Join<ChainReader<HeapReader, ReadHalf<IO>>, WriteHalf<IO>>>, <S as Service<State, Join<ChainReader<HeapReader, ReadHalf<IO>>, WriteHalf<IO>>>>::Error: Into<Box<dyn Error + Send + Sync>>, IO: Stream + Unpin,

§

type Response = <S as Service<State, Join<ChainReader<HeapReader, ReadHalf<IO>>, WriteHalf<IO>>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<State, S, M, ReqBody, ResBody> Service<State, Request<ReqBody>> for SetRequestId<S, M>
where State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, M: MakeRequestId, ReqBody: Send + 'static, ResBody: Send + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<State, S, ReqBody, ResBody> Service<State, Request<ReqBody>> for PropagateRequestId<S>
where State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<State, S, ReqBody, ResBody> Service<State, Request<ReqBody>> for SetStatus<S>
where State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static,

§

type Response = <S as Service<State, Request<ReqBody>>>::Response

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<State, S, T, ReqBody, ResBody> Service<State, Request<ReqBody>> for CatchPanic<S, T>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, ResBody: Into<Body> + Send + 'static, T: ResponseForPanic + Clone + Send + Sync + 'static, ReqBody: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = Response<Body>

§

type Error = <S as Service<State, Request<ReqBody>>>::Error

§

impl<State, S, W, ReqBody, ResBody> Service<State, Request<ReqBody>> for RequestWriterService<S, W>
where State: Clone + Send + Sync + 'static, S: Service<State, Request<Body>, Response = Response<ResBody>>, <S as Service<State, Request<Body>>>::Error: Into<Box<dyn Error + Send + Sync>>, W: RequestWriter, ReqBody: Body<Data = Bytes> + Send + Sync + 'static, <ReqBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>, ResBody: Send + 'static,

§

type Response = Response<ResBody>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<State, S, W, ReqBody, ResBody> Service<State, Request<ReqBody>> for ResponseWriterService<S, W>
where State: Clone + Send + Sync + 'static, S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, <S as Service<State, Request<ReqBody>>>::Error: Into<Box<dyn Error + Send + Sync>>, W: ResponseWriter, ReqBody: Send + 'static, ResBody: Body<Data = Bytes> + Send + Sync + 'static, <ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,

§

type Response = Response<Body>

§

type Error = Box<dyn Error + Send + Sync>

§

impl<T1, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1,)>
where T1: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, T3, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, T3, T4, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, T3, T4, T5, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, T3, T4, T5, T6, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, T3, T4, T5, T6, T7, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, T3, T4, T5, T6, T7, T8, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, S, State, Body> Service<State, Request<Body>> for GetForwardedHeadersService<S, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>
where T1: ForwardHeader + Send + Sync + 'static, T2: ForwardHeader + Send + Sync + 'static, T3: ForwardHeader + Send + Sync + 'static, T4: ForwardHeader + Send + Sync + 'static, T5: ForwardHeader + Send + Sync + 'static, T6: ForwardHeader + Send + Sync + 'static, T7: ForwardHeader + Send + Sync + 'static, T8: ForwardHeader + Send + Sync + 'static, T9: ForwardHeader + Send + Sync + 'static, T10: ForwardHeader + Send + Sync + 'static, T11: ForwardHeader + Send + Sync + 'static, T12: ForwardHeader + Send + Sync + 'static, S: Service<State, Request<Body>>, Body: Send + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = <S as Service<State, Request<Body>>>::Error

§

impl<T, F, S, Request, E> Service<S, Request> for rama::layer::Timeout<T, F>
where Request: Send + 'static, S: Clone + Send + Sync + 'static, F: MakeLayerError<Error = E>, E: Into<<T as Service<S, Request>>::Error> + Send + 'static, T: Service<S, Request>,

§

type Response = <T as Service<S, Request>>::Response

§

type Error = <T as Service<S, Request>>::Error

§

impl<T, P, F, State, Request, FnResponse, FnError> Service<State, Request> for Limit<T, P, ErrorIntoResponseFn<F>>
where T: Service<State, Request>, P: Policy<State, Request>, F: Fn(<P as Policy<State, Request>>::Error) -> Result<FnResponse, FnError> + Send + Sync + 'static, FnResponse: Into<<T as Service<State, Request>>::Response> + Send + 'static, FnError: Into<<T as Service<State, Request>>::Error> + Send + Sync + 'static, Request: Send + Sync + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <T as Service<State, Request>>::Response

§

type Error = <T as Service<State, Request>>::Error

§

impl<T, P, State, Request> Service<State, Request> for Limit<T, P>
where T: Service<State, Request>, <T as Service<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, P: Policy<State, Request>, <P as Policy<State, Request>>::Error: Into<Box<dyn Error + Send + Sync>>, Request: Send + Sync + 'static, State: Clone + Send + Sync + 'static,

§

type Response = <T as Service<State, Request>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<T, S> Service<T, S> for rama::net::stream::service::EchoService
where T: Send + Sync + 'static, S: Stream + 'static,

§

type Response = u64

§

type Error = Box<dyn Error + Send + Sync>

§

impl<T, S, IO> Service<T, IO> for rama::tls::boring::server::TlsAcceptorService<S>
where T: Send + Sync + 'static, IO: Stream + Unpin + 'static, S: Service<T, SslStream<IO>>, <S as Service<T, SslStream<IO>>>::Error: Into<Box<dyn Error + Send + Sync>>,

§

type Response = <S as Service<T, SslStream<IO>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<T, S, IO> Service<T, IO> for rama::tls::rustls::server::TlsAcceptorService<S>
where T: Send + Sync + 'static, IO: Stream + Unpin + 'static, S: Service<T, TlsStream<IO>>, <S as Service<T, TlsStream<IO>>>::Error: Into<Box<dyn Error + Send + Sync>>,

§

type Response = <S as Service<T, TlsStream<IO>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<T, S, State, Body, E> Service<State, Request<Body>> for HeaderConfigService<T, S>
where S: Service<State, Request<Body>, Error = E>, T: DeserializeOwned + Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Body: Send + Sync + 'static, E: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>

§

impl<T, S, State, Body, E> Service<State, Request<Body>> for HeaderOptionValueService<T, S>
where S: Service<State, Request<Body>, Error = E>, T: Default + Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Body: Send + Sync + 'static, E: Into<Box<dyn Error + Send + Sync>> + Send + Sync + 'static,

§

type Response = <S as Service<State, Request<Body>>>::Response

§

type Error = Box<dyn Error + Send + Sync>