Struct OneRequestService 

pub struct OneRequestService<S> { /* private fields */ }

Service wrapper that allows only one call to run at a time.

This type is intentionally not cloneable. Cloning its readiness state would create another independent gate and allow calls to overlap.

Acquiring or releasing the call slot invalidates this service’s readiness. The wrapped service has an independent readiness cache and must notify when its readiness changes.

Implementations

impl<S> OneRequestService<S>

pub fn new<St, Req>(service: S) -> Self

where S: Service<St, Req>,

Wraps a service so that concurrent callers wait for the active call.

Trait Implementations

impl<S: Debug> Debug for OneRequestService<S>

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 OneRequestService<S>

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.

fn bind(&self, ctx: BindCtx<'_>)

Initializes the service within a Pipeline.

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

Waits until the service is ready to process a request.

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

Processes a request and asynchronously returns the response.

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.