Struct AutoEject 

pub struct AutoEject { /* private fields */ }

Failure tracker that decides whether a target is currently auto-ejected.

The struct is purely synchronous: it never schedules timers and never holds locks. The tokio-driven dispatch layer queries it before issuing every outbound request and feeds back the result through AutoEject::record_success or AutoEject::record_failure.

Implementations

impl AutoEject

pub fn new(enabled: bool, failure_limit: u32, retry_after: Duration) -> Self

Construct a fresh tracker. enabled mirrors the auto_eject_hosts knob from the YAML config. failure_limit mirrors server_failure_limit. retry_after mirrors server_retry_timeout_ms rendered as a Duration.

Examples

use dynomite::net::auto_eject::AutoEject;
use std::time::Duration;

let ae = AutoEject::new(true, 3, Duration::from_secs(1));
assert!(ae.is_enabled());
assert_eq!(ae.failure_limit(), 3);

pub fn is_enabled(&self) -> bool

True when auto-eject is enabled.

Examples

use dynomite::net::auto_eject::AutoEject;
use std::time::Duration;
assert!(!AutoEject::new(false, 1, Duration::from_secs(1)).is_enabled());

pub fn failure_limit(&self) -> u32

Configured failure limit before ejecting.

Examples

use dynomite::net::auto_eject::AutoEject;
use std::time::Duration;
assert_eq!(AutoEject::new(true, 5, Duration::from_secs(1)).failure_limit(), 5);

pub fn retry_after(&self) -> Duration

Eject window length.

pub fn failure_count(&self) -> u32

Current consecutive-failure count.

pub fn next_retry(&self) -> Option<Instant>

Instant after which the target should be retried, when an eject is currently active.

pub fn record_attempt(&mut self, now: Instant) -> AutoEjectState

Test whether the caller should proceed (Reachable) or skip (Ejected) at the given instant.

The caller passes now so the function stays deterministic in tests.

Examples

use dynomite::net::auto_eject::{AutoEject, AutoEjectState};
use std::time::{Duration, Instant};
let mut ae = AutoEject::new(true, 1, Duration::from_millis(10));
let now = Instant::now();
ae.record_failure(now);
assert_eq!(ae.record_attempt(now), AutoEjectState::Ejected);

pub fn record_success(&mut self, _now: Instant)

Record a successful operation.

Resets the consecutive-failure counter and clears any active eject window. After a success, the next failure starts a fresh streak from one (so the host has to fail failure_limit more times before being re-ejected).

_now is currently unused but accepted for parity with record_attempt so callers can supply a deterministic clock in tests; future revisions may use it to record time-to-recovery metrics.

pub fn record_failure(&mut self, now: Instant) -> AutoEjectState

Record a failed operation. Returns the new state of the tracker.

When the consecutive-failure count reaches failure_limit, the function arms the eject window starting at now + retry_after.

Examples

use dynomite::net::auto_eject::{AutoEject, AutoEjectState};
use std::time::{Duration, Instant};
let mut ae = AutoEject::new(true, 2, Duration::from_secs(1));
let now = Instant::now();
assert_eq!(ae.record_failure(now), AutoEjectState::Reachable);
assert_eq!(ae.record_failure(now), AutoEjectState::Ejected);

pub fn reset(&mut self)

Reset the tracker to its post-construction state.

Examples

use dynomite::net::auto_eject::AutoEject;
use std::time::{Duration, Instant};
let mut ae = AutoEject::new(true, 1, Duration::from_millis(10));
ae.record_failure(Instant::now());
ae.reset();
assert_eq!(ae.failure_count(), 0);

Trait Implementations

impl Clone for AutoEject

fn clone(&self) -> AutoEject

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AutoEject

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

Formats the value using the given formatter.