Struct ServiceChain 

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

A builder for composing services and combinators 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>,

Calls another service after this service completes successfully.

The current service’s response becomes the next service’s request. If the current service returns an error, the next service is not called.

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

Calls another service after this service completes.

The next service receives the current service’s complete Result, so it can handle either a response or an error.

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

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

Maps this service’s response to a different type.

This is analogous to Option::map or Result::map.

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

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

Maps this service’s error to a different type.

This is analogous to Result::map_err and is useful for normalizing error types across composed services.

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

Adds a 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),

Adds a callback that runs once when the service shuts down.

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

Applies an asynchronous function as middleware to this service.

This is shorthand for calling crate::apply_fn on the chained service.

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

Response produced by the service.

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

Error produced while checking readiness or processing a request.

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>

Waits until the service is ready to process a request.

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

Calls another service after this service completes successfully.

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

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

Wraps this service and its state in a Pipeline.