Trait rama::service::Service

source ·
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§

source

type Response: Send + 'static

The type of response returned by the service.

source

type Error: Send + Sync + 'static

The type of error returned by the service.

Required Methods§

source

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§

source

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

Box this service to allow for dynamic dispatch.

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

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

source§

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

source§

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

source§

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

source§

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, Error> Service<State, Request<Body>> 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: Send + Sync + '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,

§

type Response = Response<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

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, Error> Service<State, Request<Body>> 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: Send + Sync + '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,

§

type Response = Response<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

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, Error> Service<State, Request<Body>> 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: Send + Sync + '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,

§

type Response = Response<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

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, Error> Service<State, Request<Body>> 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: Send + Sync + '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<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

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, Error> Service<State, Request<Body>> 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: Send + Sync + '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<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, M_T7, T7, S, Error> Service<State, Request<Body>> 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: Send + Sync + '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<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, M_T6, T6, S, Error> Service<State, Request<Body>> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), (M_T6, T6), S)
where State: Send + Sync + '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<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, M_T5, T5, S, Error> Service<State, Request<Body>> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), (M_T5, T5), S)
where State: Send + Sync + '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<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, M_T4, T4, S, Error> Service<State, Request<Body>> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), (M_T4, T4), S)
where State: Send + Sync + '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<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

impl<State, M_T1, T1, M_T2, T2, M_T3, T3, S, Error> Service<State, Request<Body>> for ((M_T1, T1), (M_T2, T2), (M_T3, T3), S)
where State: Send + Sync + '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<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

impl<State, M_T1, T1, M_T2, T2, S, Error> Service<State, Request<Body>> for ((M_T1, T1), (M_T2, T2), S)
where State: Send + Sync + '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<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

source§

impl<State, M_T1, T1, S, Error> Service<State, Request<Body>> for ((M_T1, T1), S)
where State: Send + Sync + '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<Body>

§

type Error = Error

source§

async fn serve( &self, ctx: Context<State>, req: Request ) -> Result<Self::Response, Self::Error>

Implementors§

source§

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::Error: Into<BoxError>, B: Service<State, Request, Response = Response>, B::Error: Into<BoxError>, C: Service<State, Request, Response = Response>, C::Error: Into<BoxError>, D: Service<State, Request, Response = Response>, D::Error: Into<BoxError>, E: Service<State, Request, Response = Response>, E::Error: Into<BoxError>, F: Service<State, Request, Response = Response>, F::Error: Into<BoxError>, G: Service<State, Request, Response = Response>, G::Error: Into<BoxError>, H: Service<State, Request, Response = Response>, H::Error: Into<BoxError>, I: Service<State, Request, Response = Response>, I::Error: Into<BoxError>, Request: Send + 'static, State: Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

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

source§

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::Error: Into<BoxError>, B: Service<State, Request, Response = Response>, B::Error: Into<BoxError>, C: Service<State, Request, Response = Response>, C::Error: Into<BoxError>, D: Service<State, Request, Response = Response>, D::Error: Into<BoxError>, E: Service<State, Request, Response = Response>, E::Error: Into<BoxError>, F: Service<State, Request, Response = Response>, F::Error: Into<BoxError>, G: Service<State, Request, Response = Response>, G::Error: Into<BoxError>, H: Service<State, Request, Response = Response>, H::Error: Into<BoxError>, Request: Send + 'static, State: Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

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

source§

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::Error: Into<BoxError>, B: Service<State, Request, Response = Response>, B::Error: Into<BoxError>, C: Service<State, Request, Response = Response>, C::Error: Into<BoxError>, D: Service<State, Request, Response = Response>, D::Error: Into<BoxError>, E: Service<State, Request, Response = Response>, E::Error: Into<BoxError>, F: Service<State, Request, Response = Response>, F::Error: Into<BoxError>, G: Service<State, Request, Response = Response>, G::Error: Into<BoxError>, Request: Send + 'static, State: Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

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

source§

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::Error: Into<BoxError>, B: Service<State, Request, Response = Response>, B::Error: Into<BoxError>, C: Service<State, Request, Response = Response>, C::Error: Into<BoxError>, D: Service<State, Request, Response = Response>, D::Error: Into<BoxError>, E: Service<State, Request, Response = Response>, E::Error: Into<BoxError>, F: Service<State, Request, Response = Response>, F::Error: Into<BoxError>, Request: Send + 'static, State: Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

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

source§

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::Error: Into<BoxError>, B: Service<State, Request, Response = Response>, B::Error: Into<BoxError>, C: Service<State, Request, Response = Response>, C::Error: Into<BoxError>, D: Service<State, Request, Response = Response>, D::Error: Into<BoxError>, E: Service<State, Request, Response = Response>, E::Error: Into<BoxError>, Request: Send + 'static, State: Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

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

source§

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::Error: Into<BoxError>, B: Service<State, Request, Response = Response>, B::Error: Into<BoxError>, C: Service<State, Request, Response = Response>, C::Error: Into<BoxError>, D: Service<State, Request, Response = Response>, D::Error: Into<BoxError>, Request: Send + 'static, State: Send + Sync + 'static, Response: Send + 'static,

§

type Response = Response

§

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

source§

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

§

type Response = Response

§

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

source§

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

§

type Response = Response

§

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

source§

impl<A, C, L, S, State, ReqBody, ResBody> Service<State, Request<ReqBody>> for ProxyAuthService<A, C, S, L>
where A: ProxyAuthority<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: Send + Sync + 'static,

§

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

§

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

source§

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

§

type Response = ()

§

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

source§

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: 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

source§

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: 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

source§

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

source§

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, P: Predicate + Send + Sync + 'static, ReqBody: Send + 'static, ResBody::Data: Send + 'static, ResBody::Error: Send + 'static, State: Send + Sync + 'static,

§

type Response = Response<CompressionBody<ResBody>>

§

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

source§

impl<ReqBody, ResBody, S, State> Service<State, Request<ReqBody>> for PropagateHeader<S>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, State: 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

source§

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::RequestBody>, Response = Response<ResBody>>, ReqBody: Send + 'static, ResBody: Send + 'static, State: Send + Sync + 'static,

§

type Response = Response<ResBody>

§

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

source§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for RemoveRequestHeader<S>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: 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

source§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for RemoveResponseHeader<S>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: 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

source§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for AddRequiredRequestHeaders<S>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: 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

source§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for AddRequiredResponseHeaders<S>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: 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

source§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for SetSensitiveRequestHeaders<S>
where State: 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

source§

impl<ReqBody, ResBody, State, S> Service<State, Request<ReqBody>> for SetSensitiveResponseHeaders<S>
where State: 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

source§

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

§

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

§

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

source§

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

§

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

§

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

source§

impl<ReqBody, ResBody, State, S, V> Service<State, Request<ReqBody>> for ValidateRequestHeader<S, V>
where ReqBody: Send + 'static, ResBody: Send + 'static, State: 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

source§

impl<S, D, P, State, Body> Service<State, Request<Body>> for ProxyDBService<S, D, P>
where S: Service<State, Request<Body>>, S::Error: Send + Sync + 'static, D: ProxyDB, D::Error: Send + Sync + 'static, P: Fn(&Proxy) -> bool + Clone + Send + Sync + 'static, State: Send + Sync + 'static, Body: Send + 'static,

§

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

§

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

source§

impl<S, D, State, Body> Service<State, Request<Body>> for ProxyDBService<S, D>
where S: Service<State, Request<Body>>, S::Error: Send + Sync + 'static, D: ProxyDB, D::Error: Send + Sync + 'static, State: Send + Sync + 'static, Body: Send + 'static,

§

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

§

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

source§

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

source§

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

source§

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

§

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

§

type Error = Infallible

source§

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

§

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

§

type Error = Error

source§

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

§

type Response = Output

§

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

source§

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

§

type Response = Response

§

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

source§

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

§

type Response = Response

§

type Error = Error

source§

impl<S, F, State, Request, Response, Error, Fut> Service<State, Request> for Then<S, F>
where S: Service<State, Request>, S::Error: Into<Error>, F: FnOnce(Result<S::Response, S::Error>) -> Fut + Clone + Send + Sync + 'static, Fut: Future<Output = Result<Response, Error>> + Send + 'static, State: Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, Error: Send + Sync + 'static,

§

type Response = Response

§

type Error = Error

source§

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

§

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

§

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

source§

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::Response>, <H as Service<State, Request>>::Error: Into<S::Error>, M: Matcher<State, Request>, State: Send + Sync + 'static, Request: Send + 'static,

§

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

§

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

source§

impl<S, Request> Service<S, Request> for IdentityService
where S: Send + Sync + 'static, Request: Send + 'static,

§

type Response = Request

§

type Error = Infallible

source§

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

source§

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

source§

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

§

type Response = Response<Body>

§

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

source§

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

§

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

§

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

source§

impl<S, State, Body, T> Service<State, Request<Body>> for HttpsConnector<S, ConnectorKindAuto>
where S: Service<State, Request<Body>, Response = EstablishedClientConnection<T, Body, State>>, T: Stream + Unpin, S::Error: Into<BoxError>, State: Send + Sync + 'static, Body: Send + 'static,

source§

impl<S, State, Body, T> Service<State, Request<Body>> for HttpsConnector<S, ConnectorKindSecure>
where S: Service<State, Request<Body>, Response = EstablishedClientConnection<T, Body, State>>, T: Stream + Unpin, S::Error: Into<BoxError>, State: Send + Sync + 'static, Body: Send + 'static,

§

type Response = EstablishedClientConnection<TlsStream<T>, Body, State>

§

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

source§

impl<S, State, Body, T> Service<State, Request<Body>> for HttpsConnector<S, ConnectorKindTunnel>
where S: Service<State, Request<Body>, Response = EstablishedClientConnection<T, Body, State>>, T: Stream + Unpin, S::Error: Into<BoxError>, State: Send + Sync + 'static, Body: Send + 'static,

source§

impl<S, State, Body, T, P> Service<State, Request<Body>> for HttpProxyConnectorService<S, P>
where S: Service<State, Request<Body>, Response = EstablishedClientConnection<T, Body, State>>, T: Stream + Unpin, P: HttpProxyProvider<State>, P::Error: Into<BoxError>, S::Error: Into<BoxError>, State: Send + Sync + 'static, Body: Send + 'static,

§

type Response = EstablishedClientConnection<T, Body, State>

§

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

source§

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

§

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

§

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

source§

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

§

type Response = O

§

type Error = E

source§

impl<S, State, ReqBody> Service<State, Request<ReqBody>> for rama::http::layer::body_limit::BodyLimitService<S>
where S: Service<State, Request<Limited<ReqBody>>>, State: Send + Sync + 'static, ReqBody: Send + 'static,

§

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

§

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

source§

impl<S, State, ReqBody> Service<State, Request<ReqBody>> for rama::service::layer::http::BodyLimitService<S>
where S: Service<State, Request>, S::Response: IntoResponse, State: Send + Sync + 'static, ReqBody: HttpBody<Data = Bytes> + Send + Sync + 'static, ReqBody::Error: Into<BoxError>,

§

type Response = Response<Body>

§

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

source§

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: Send + Sync + 'static,

§

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

§

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

source§

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: Send + Sync + 'static,

§

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

§

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

source§

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

§

type Response = Response<DecompressionBody<ResBody>>

§

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

source§

impl<S, State, ReqBody, ResBody> Service<State, Request<ReqBody>> for NormalizePath<S>
where S: Service<State, Request<ReqBody>, Response = Response<ResBody>>, State: 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

source§

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: Send + Sync + 'static,

§

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

§

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

source§

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

§

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

§

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

source§

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>>, State: Send + Sync + 'static, ReqBody: HttpBody + Send + 'static, ResBody: HttpBody + Send + Sync + 'static, ResBody::Error: Display, S::Error: Display, M: MakeClassifier, M::Classifier: Clone, MakeSpanT: MakeSpan<ReqBody>, OnRequestT: OnRequest<ReqBody>, OnResponseT: OnResponse<ResBody> + Clone, OnBodyChunkT: OnBodyChunk<ResBody::Data> + Clone, OnEosT: OnEos + Clone, OnFailureT: OnFailure<M::FailureClass> + Clone,

§

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

§

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

source§

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

§

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

§

type Error = Infallible

source§

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

§

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

§

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

source§

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

§

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

§

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

source§

impl<S, T> Service<S, T> for Forwarder
where S: Send + Sync + 'static, T: Stream + Unpin,

§

type Response = ()

§

type Error = Error

source§

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

source§

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

source§

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

§

type Response = EstablishedClientConnection<TcpStream, Body, State>

§

type Error = Error

source§

impl<State, Body, C, S> Service<State, Request<Body>> for HttpClient<C, S>
where State: Send + Sync + 'static, Body: Body + Unpin + Send + 'static, Body::Data: Send + 'static, Body::Error: Into<Box<dyn Error + Send + Sync>>, C: Service<State, Request<Body>, Response = EstablishedClientConnection<S, Body, State>>, C::Error: Into<BoxError>, S: Stream + Unpin,

source§

impl<State, Body, E, S, R> Service<State, Request<Body>> for DnsService<S, R>
where State: Send + Sync + 'static, Body: Send + Sync + 'static, E: Into<BoxError> + Send + Sync + 'static, S: Service<State, Request<Body>, Error = E>, R: DynamicDnsResolver,

§

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

§

type Error = DnsError<E>

source§

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

§

type Response = Response<ResBody>

§

type Error = Infallible

source§

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

source§

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

§

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

§

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

source§

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

source§

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

§

type Response = Response<ResBody>

§

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

source§

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

source§

impl<State, Request, S, T> Service<State, Request> for AddExtension<S, T>
where State: 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

source§

impl<State, S, IO> Service<State, IO> for BytesTrackerService<S>
where State: 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

source§

impl<State, S, IO> Service<State, IO> for HaProxyService<S>
where State: Send + Sync + 'static, S: Service<State, Join<ChainReader<HeapReader, ReadHalf<IO>>, WriteHalf<IO>>>, S::Error: Into<BoxError>, IO: Stream + Unpin,

§

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

§

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

source§

impl<State, S, M, ReqBody, ResBody> Service<State, Request<ReqBody>> for SetRequestId<S, M>
where State: 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

source§

impl<State, S, ReqBody, ResBody> Service<State, Request<ReqBody>> for PropagateRequestId<S>
where State: 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

source§

impl<State, S, ReqBody, ResBody> Service<State, Request<ReqBody>> for SetStatus<S>
where State: 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

source§

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: Send + Sync + 'static,

§

type Response = Response<Body>

§

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

source§

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

§

type Response = Response<ResBody>

§

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

source§

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

§

type Response = Response<Body>

§

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

source§

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

§

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

§

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

source§

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

§

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

§

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

source§

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

§

type Response = u64

§

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

source§

impl<T, S, IO> Service<T, IO> for TlsAcceptorService<S, ()>
where T: Send + Sync + 'static, IO: Stream + Unpin + 'static, S: Service<T, TlsStream<IO>>,

§

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

§

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

source§

impl<T, S, IO> Service<T, IO> for TlsAcceptorService<S, TlsClientConfigHandler<()>>
where T: Send + Sync + 'static, IO: Stream + Unpin + 'static, S: Service<T, TlsStream<IO>>,

§

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

§

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

source§

impl<T, S, IO, F> Service<T, IO> for TlsAcceptorService<S, TlsClientConfigHandler<F>>
where T: Send + Sync + 'static, IO: Stream + Unpin + 'static, S: Service<T, TlsStream<IO>>, F: ServerConfigProvider,

§

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

§

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

source§

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: Send + Sync + 'static, Body: Send + Sync + 'static, E: Into<BoxError> + Send + Sync + 'static,

§

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

§

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