Struct ConnectivityState 

pub struct ConnectivityState {
    pub is_offline: bool,
    pub check_pending: bool,
    pub poll_pending: bool,
    pub consecutive_failures: u32,
    pub consecutive_successes: u32,
    pub required_failures_to_go_offline: u32,
    pub required_successes_to_go_online: u32,
    pub offline_poll_interval_ms: u64,
}

Tracks network connectivity status for offline detection.

This state is used to implement the freeze-and-resume workflow feature:

• When network connectivity is lost, the pipeline enters offline mode
• While offline, all budget-consuming operations are suspended
• When connectivity returns, the pipeline resumes from the frozen checkpoint

State Transitions

[Online] --(probe failed)--> [Probe Failing] --(threshold reached)--> [Offline]
[Offline] --(probe succeeded)--> [Back Online] --(orchestrator resumes)--> [Online]

Debouncing

To prevent rapid offline/online thrashing on unstable connections:

• Must fail N consecutive probes before entering offline mode (default: 2)
• Must succeed 1 probe before exiting offline mode (default: 1)

Fields

is_offline: bool

True when we have confirmed the pipeline is in offline mode (poll loop active).

check_pending: bool

True when an InvocationFailed{Network} event was received and we need to verify connectivity before consuming retry budget.

poll_pending: bool

True when offline is confirmed and we are in the poll-for-reconnect loop.

consecutive_failures: u32

Consecutive failed probes (used for debounce threshold before entering offline mode).

consecutive_successes: u32

Consecutive successful probes (used for debounce before exiting offline mode).

required_failures_to_go_offline: u32

How many consecutive failures before entering offline mode (default: 2).

required_successes_to_go_online: u32

How many consecutive successes before exiting offline mode (default: 1).

offline_poll_interval_ms: u64

Milliseconds to wait between polls while offline (default: 5000).

Implementations

impl ConnectivityState

pub fn new() -> Self

Create a new empty connectivity state (fully online, no pending checks).

pub fn trigger_check(self) -> Self

Mark that a connectivity check is needed (triggered by Network error).

pub fn clear_check_pending(self) -> Self

Clear the check_pending flag.

pub fn on_probe_failed(self) -> Self

Record a failed connectivity probe.

Returns a new state with updated counters. If the failure threshold is reached, transitions to offline mode.

pub fn on_probe_succeeded(self) -> Self

Record a successful connectivity probe.

Returns a new state with updated counters. If the success threshold is reached while offline, transitions back to online mode.

pub fn reset_debounce(self) -> Self

Reset debounce counters without changing offline/online status.

Use when a transient state change should reset the debounce counters.

pub const fn is_offline_mode(&self) -> bool

Returns true if we have entered offline mode (debounce threshold was met).

pub const fn is_check_pending(&self) -> bool

Returns true if a connectivity check is pending.

pub const fn is_poll_pending(&self) -> bool

Returns true if we are actively polling for connectivity (offline mode).

Trait Implementations

impl Clone for ConnectivityState

fn clone(&self) -> ConnectivityState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConnectivityState

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

Formats the value using the given formatter.

impl Default for ConnectivityState

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ConnectivityState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ConnectivityState

fn eq(&self, other: &ConnectivityState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ConnectivityState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ConnectivityState