Struct RetryCircuitBreaker 

pub struct RetryCircuitBreaker<S, P> { /* private fields */ }

Wraps a service in a circuit breaker and signals when a request must be retried at a later time.

This circuit breaker implementation is specific to retrying requests. In many cases, a request can fail in two ways: unrecoverable errors, which should not be retried, and recoverable errors, which should be retried after a some period of time. When a request can be retried, it may not be advantageous to wait for the given request to be retried successfully, as the request should perhaps be stored in a queue and retried at a later time, potentially to avoid applying backpressure to the client.

RetryCircuitBreaker provides this capability by separating the logic of determining whether or not a request should be retried from actually performing the retry itself. When a request leads to an unrecoverable error, that error is immediately passed back to the caller without affecting the circuit breaker state. However, when a recoverable error is encountered, the circuit breaker will signal to the caller that the request should be retried, and update its internal state to open the circuit breaker for a configurable period of time. Further requests to the circuit breaker will be rejected with an error (indicating the open state) until that period of time has passed.

Implementations

impl<S, P> RetryCircuitBreaker<S, P>

pub fn new(inner: S, policy: P) -> Self

Creates a new RetryCircuitBreaker.

Trait Implementations

impl<S: Debug, P: Debug> Debug for RetryCircuitBreaker<S, P>

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

Formats the value using the given formatter.

impl<S, P, Request> Service<Request> for RetryCircuitBreaker<S, P>

where S: Service<Request>, P: Policy<Request, S::Response, S::Error>, P::Future: Send + 'static,

type Response = <S as Service<Request>>::Response

Responses given by the service.

type Error = Error<<S as Service<Request>>::Error, Request>

Errors produced by the service.

type Future = ResponseFuture<P, <S as Service<Request>>::Future, Request>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request) -> Self::Future

Process the request and return the response asynchronously.