Struct ServiceChain 

pub struct ServiceChain<S, St, Req> { /* private fields */ }

Chain builder - chain allows to compose multiple service into one service.

Implementations

impl<S: Service<St, Req>, St, Req> ServiceChain<S, St, Req>

pub fn and_then<Next, F>( self, service: F, ) -> ServiceChain<AndThen<S, Next>, St, Req>

where Self: Sized, F: IntoService<Next, St, S::Res>, Next: Service<St, S::Res>,

Call another service after call to this one has resolved successfully.

This function can be used to chain two services together and ensure that the second service isn’t called until call to the fist service have finished. Result of the call to the first service is used as an input parameter for the second service’s call.

Note that this function consumes the receiving service and returns a wrapped version of it.

pub fn then<Next, F>(self, service: F) -> ServiceChain<Then<S, Next>, St, Req>

where Self: Sized, F: IntoService<Next, St, Result<S::Res, S::Error>>, Next: Service<St, Result<S::Res, S::Error>>,

Chain on a computation for when a call to the service finished, passing the result of the call to the next service U.

pub fn map<F, Res>(self, f: F) -> ServiceChain<Map<F, S, Res>, St, Req>

where Self: Sized, F: Fn(S::Res) -> Res,

Map this service’s output to a different type, returning a new service of the resulting type.

This function is similar to the Option::map or Iterator::map where it will change the type of the underlying service.

pub fn map_err<F, Err>(self, f: F) -> ServiceChain<MapErr<F, S, Err>, St, Req>

where Self: Sized, F: Fn(S::Error) -> Err,

Map this service’s error to a different error, returning a new service.

This function is similar to the Result::map_err where it will change the error type of the underlying service. This is useful for example to ensure that services have the same error type.

pub fn readiness<F>( self, ready: F, ) -> ServiceChain<AndThen<S, FnReadiness<F, S::Error>>, St, Req>

where Self: Sized, F: AsyncFn(&St) -> Result<(), S::Error>,

Add custom readiness check to the service chain.

pub fn shutdown<F>( self, sh: F, ) -> ServiceChain<AndThen<S, FnShutdown<F, S::Error>>, St, Req>

where Self: Sized, F: AsyncFnOnce(&St),

Add custom readiness check to the service chain.

pub fn apply_fn<F, In, Out, Err>( self, f: F, ) -> ServiceChain<Apply<S, St, Req, F, In, Out, Err>, St, In>

where F: AsyncFn(In, &ApplyCtx<'_, S, St, Req>) -> Result<Out, Err>, Err: From<S::Error>,

Use function as middleware for current service.

Short version of apply_fn(service(...), fn)

Trait Implementations

impl<S, St, Req> Clone for ServiceChain<S, St, Req>

where S: Clone + Service<St, Req>,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, St, Req> Debug for ServiceChain<S, St, Req>

where S: Debug + Service<St, Req>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Service<St, Req>, St, Req> Service<St, Req> for ServiceChain<S, St, Req>

type Res = <S as Service<St, Req>>::Res

Responses that the service could provide.

type Error = <S as Service<St, Req>>::Error

Errors produced by the service while checking readiness or executing a call.

async fn call( &self, req: Req, ctx: Ctx<'_, Self, St>, ) -> Result<Self::Res, Self::Error>

Processes a request and asynchronously returns the response.

async fn ready(&self, ctx: Ctx<'_, Self, St>) -> Result<(), Self::Error>

Returns when the service is ready to process requests.

async fn shutdown(&self, ctx: Ctx<'_, Self, St>)

Shuts down the service.

fn map<F, Res>(self, f: F) -> ServiceChain<Map<F, Self, Res>, St, Req>

where Self: Sized, F: Fn(Self::Res) -> Res,

Maps this service’s output to a different type, returning a new service.

fn map_err<F, E>(self, f: F) -> ServiceChain<MapErr<F, Self, E>, St, Req>

where Self: Sized, F: Fn(Self::Error) -> E,

Maps this service’s error to a different type, returning a new service.

fn and_then<Next, F>(self, f: F) -> ServiceChain<AndThen<Self, Next>, St, Req>

where Self: Sized, Next: Service<St, Self::Res, Error = Self::Error>, F: IntoService<Next, St, Self::Res>,

Call another service after call to this one has resolved successfully.

fn pipeline(self, st: St) -> Pipeline<Req, Self::Res, Self::Error>

where Self: Sized + 'static, St: 'static, Req: 'static,

Wraps it in a container.