Trait Service

Source

pub trait Service<S, Request>:
    Sized
    + Send
    + Sync
    + 'static {
    type Response: Send + 'static;
    type Error: Send + '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.

This trait is not dyn compatible.

Source §

Source §

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

Source §

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

Source §

Trait ServiceCopy item path

Required Associated Types§

type Response: Send + 'static

type Error: Send + 'static

Required Methods§

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

Provided Methods§

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

Dyn Compatibility§

Implementations on Foreign Types§

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<I1, I2, StateIn, RequestIn> Service<StateIn, RequestIn> for (I1, I2)where I1: RequestInspector<StateIn, RequestIn, Error: Into<BoxError>>, I2: RequestInspector<I1::StateOut, I1::RequestOut, Error: Into<BoxError>>, StateIn: Clone + Send + Sync + 'static, RequestIn: Send + 'static,

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

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

impl<I1, StateIn, RequestIn> Service<StateIn, RequestIn> for (I1,)where I1: RequestInspector<StateIn, RequestIn, Error: Into<BoxError>>, StateIn: Clone + Send + Sync + 'static, RequestIn: Send + 'static,

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

type Response = (Context<<I1 as RequestInspector<StateIn, RequestIn>>::StateOut>, <I1 as RequestInspector<StateIn, RequestIn>>::RequestOut)

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

type Error = <I as Service<StateIn, RequestIn>>::Error

type Response = <I as Service<StateIn, RequestIn>>::Response

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

impl<S, State, Request> Service<State, Request> for &'static Swhere 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<Self::Response, Self::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<Self::Response, Self::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<Self::Response, Self::Error>> + Send + '_

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

type Error = Infallible

type Response = (Context<State>, Request)

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

Implementors§

type Response = Response

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

type Response = Response

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

type Response = Response

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

type Response = Response

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

type Response = Response

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

type Response = Response

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

type Response = Response

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

type Response = Response

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

impl<I, S, StateIn, RequestIn> Service<StateIn, RequestIn> for RequestInspectorLayerService<I, S>where I: RequestInspector<StateIn, RequestIn>, S: Service<I::StateOut, I::RequestOut, Error: Into<I::Error>>, StateIn: Clone + Send + Sync + 'static, RequestIn: Send + 'static,

type Response = <S as Service<<I as RequestInspector<StateIn, RequestIn>>::StateOut, <I as RequestInspector<StateIn, RequestIn>>::RequestOut>>::Response

type Error = <I as RequestInspector<StateIn, RequestIn>>::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, DefaulResponse>where S: Service<State, Request, Response: Default>, F: FnOnce(S::Error) + Clone + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static,

Trait Service

impl<I1, I2, StateIn, RequestIn> Service<StateIn, RequestIn> for (I1, I2)
where I1: RequestInspector<StateIn, RequestIn, Error: Into<BoxError>>, I2: RequestInspector<I1::StateOut, I1::RequestOut, Error: Into<BoxError>>, StateIn: Clone + Send + Sync + 'static, RequestIn: Send + 'static,

impl<I1, StateIn, RequestIn> Service<StateIn, RequestIn> for (I1,)
where I1: RequestInspector<StateIn, RequestIn, Error: Into<BoxError>>, StateIn: Clone + Send + Sync + 'static, RequestIn: Send + 'static,

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

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

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

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

impl<I, S, StateIn, RequestIn> Service<StateIn, RequestIn> for RequestInspectorLayerService<I, S>
where I: RequestInspector<StateIn, RequestIn>, S: Service<I::StateOut, I::RequestOut, Error: Into<I::Error>>, StateIn: Clone + Send + Sync + 'static, RequestIn: Send + 'static,

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,

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

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

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

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

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,

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

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

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

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

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