Struct CircuitBreaker 

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

Available on crate feature circuit-breaker only.

Tower Service implementing the circuit-breaker pattern.

The open/probe/close criteria are driven by a CircuitPolicy, making the triggering logic independently customisable. The built-in policy is ConsecutiveFailures; supply any type implementing CircuitPolicy via CircuitBreaker::new or CircuitBreakerLayer::with_policy for custom strategies.

Thread safety

CircuitBreaker<S, P> is Send when both S and P are Send. This is enforced structurally: the policy is held behind Arc<Mutex<P>>, so Arc<Mutex<P>>: Send requires P: Send. No explicit bound is placed on P in the Service impl, so !Send policies can still be used in single-threaded contexts without a compile error. P: Sync is never required.

See CircuitPolicy for more detail.

See the module documentation for a full example.

Implementations

impl<S, P: CircuitPolicy> CircuitBreaker<S, P>

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

Wrap inner with the given CircuitPolicy.

pub fn status(&self) -> CircuitStatus

Return the current CircuitStatus.

pub fn reset(&self)

Manually close the circuit (e.g. after operator confirmation that the backend is healthy).

Calls CircuitPolicy::on_half_open to reset any per-window counters in the policy, then sets the status to Closed.

Trait Implementations

impl<S: Clone, P: Clone> Clone for CircuitBreaker<S, P>

fn clone(&self) -> CircuitBreaker<S, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where S: Service<Request>, P: CircuitPolicy,

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

Responses given by the service.

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

Errors produced by the service.

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

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.