Struct ClusterStabilityState 

pub struct ClusterStabilityState {
    stable_since: Option<EpochMillis>,
    last_status_change: Option<DateTime<Utc>>,
    last_restart_counts: Option<BTreeMap<(ReplicaId, ProcessId), u64>>,
}

Per-cluster state for the stability gate, retained across caught-up checks.

The gate requires a cluster to stay caught-up and fully healthy for a configurable period before we report it ready. A point-in-time check isn’t enough: a crash-looping replica can momentarily look hydrated and healthy, so we’d cut over right into a crash. We therefore track health over time here.

Fields

stable_since: Option<EpochMillis>

Wall-clock time (environmentd’s now()) at which the current uninterrupted caught-up-and-healthy streak began. None while the cluster isn’t currently in such a streak.

We anchor the window with environmentd’s clock so the configured period means real wall-clock seconds, independent of orchestrator event times.

last_status_change: Option<DateTime<Utc>>

Max replica-process status-change time observed on the previous tick.

Used to detect status transitions that happened and resolved between two ticks (a fast flap we’d otherwise miss by only sampling the current status). This is an orchestrator-supplied timestamp (process.time), not a locally measured one, which is why it’s a DateTime and not an Instant. We only ever compare these orchestrator times against each other, so orchestrator/environmentd clock skew doesn’t matter.

last_restart_counts: Option<BTreeMap<(ReplicaId, ProcessId), u64>>

Restart count per replica process observed on the previous tick.

Any difference from this tick resets the streak: an increased count means a restart, a decreased one means the process was recreated, and an added or removed key means replica/process churn. Restart counts survive gaps in the orchestrator watch, so they catch restarts the status stream can drop. We track them per process rather than as a cluster-wide sum so that offsetting changes across processes can’t cancel out and hide a restart.

Implementations

impl ClusterStabilityState

fn observe( &mut self, snapshot: &ClusterHealthSnapshot, now: EpochMillis, period_ms: u64, ) -> StabilityObservation

Folds in the latest health snapshot and returns an observation: whether the cluster has now been continuously caught-up and healthy for at least period_ms, how long the current streak has lasted, and (when not ready) what is holding it back.

A cluster is “good” on a tick only if all its replicas are currently healthy and nothing changed since the previous tick (no status flap, no restart). Any disruption resets the streak, so a crash-looping replica can never accumulate the required stable time.

Trait Implementations

impl Clone for ClusterStabilityState

fn clone(&self) -> ClusterStabilityState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClusterStabilityState

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

Formats the value using the given formatter.

impl Default for ClusterStabilityState

fn default() -> ClusterStabilityState

Returns the “default value” for a type.