Struct BufferService 

pub struct BufferService<St, Req, Res, Err> { /* private fields */ }

A service that buffers requests while its wrapped service is not ready.

The service is ready while the buffer has room; it does not depend on the readiness of the wrapped service. Requests that arrive while the wrapped service is not ready, or while earlier requests are still waiting, are buffered and released in order. Each released request waits for the wrapped service’s readiness, then releases the next one before calling the wrapped service. The wrapped service must notify synchronously when a call consumes its capacity, as required by readiness caching.

The buffer size is a soft limit: callers that call without a readiness check, or after an outdated one, are still buffered. Queue capacity changes invalidate cached readiness for every pipeline sharing this service, including when a queued request is canceled.

Errors of the wrapped service’s readiness are returned to the waiting request. Shutdown waits until all buffered requests have completed their calls, unless cancel_on_shutdown is set, and shuts down the wrapped service afterwards.

The default buffer capacity is 16 requests. A capacity of 0 is treated as 1.

Implementations

impl<St, Req, Res, Err> BufferService<St, Req, Res, Err>

where St: Clone + 'static,

pub fn new(size: usize, service: PipelineState<St, Req, Res, Err>) -> Self

Creates a buffering service with the specified capacity.

pub fn cancel_on_shutdown(self) -> Self

Cancels pending buffered requests instead of releasing them on shutdown.

Trait Implementations

impl<St, Req, Res, Err> Debug for BufferService<St, Req, Res, Err>

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

Formats the value using the given formatter.

impl<St, Req, Res, Err> Service<St, Req> for BufferService<St, Req, Res, Err>

where St: Clone + 'static, Req: 'static, Res: 'static, Err: 'static,

type Res = Res

Response produced by the service.

type Error = BufferServiceError<Err>

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<'_, 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.

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

Processes a request and asynchronously returns the response.

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.