Struct SystemState 

pub struct SystemState {
    pub generation: GenerationId,
    pub known_good: GenerationId,
    pub live_tested: Option<GenerationId>,
    pub accepted_baseline: Option<GenerationId>,
    pub security_floor: Option<GenerationId>,
    pub units: BTreeMap<UnitId, (Observed, Vec<Evidence>)>,
    pub overrides: Vec<Override>,
    pub conditions: BTreeSet<Condition>,
    pub resources: Resources,
    pub core_hash: Hash,
    pub holds: BTreeSet<UnitId>,
    pub observed_at: Timestamp,
}

Fields

generation: GenerationId

known_good: GenerationId

Boot-confirmed.

live_tested: Option<GenerationId>

Passed probes live, not yet rebooted.

accepted_baseline: Option<GenerationId>

Set by mark-good --accept-unconfirmed; never replaces known_good in the boot menu (§16, G3).

security_floor: Option<GenerationId>

§12e: derived when a generation commits, never set by a proposal.

units: BTreeMap<UnitId, (Observed, Vec<Evidence>)>

overrides: Vec<Override>

conditions: BTreeSet<Condition>

Atomic conditions that currently hold.

resources: Resources

Excluded from the digest.

core_hash: Hash

holds: BTreeSet<UnitId>

§12d: the units whose traffic is held now: the journal’s holds and the host’s (/run/planarian/hold), their union (fail closed). In the digest: a hold changes what a transition does.

observed_at: Timestamp

The reference time for staleness. Excluded from the digest.

Implementations

impl SystemState

pub fn override_of(&self, id: &UnitId) -> Option<&Override>

The override holding id right now, if any.

pub fn overridden(&self, id: &UnitId) -> bool

pub fn expected(&self, id: &UnitId, defs: &UnitDefs) -> bool

Whether the unit is expected to be in its desired status right now: it is defined, its desired condition holds, and no override holds it.

pub fn failing_readiness(&self, id: &UnitId, defs: &UnitDefs) -> Vec<ProbeId>

Readiness probes of id whose fresh evidence is a failure. For a device this is what status leaves out: §8 derives a bound device’s status from Observed alone, so one bound to a driver that cannot drive it still reads Bound.

pub fn passing_readiness(&self, id: &UnitId, defs: &UnitDefs) -> Vec<ProbeId>

The applicable Readiness probes whose latest evidence is a fresh pass (§9: what a change may not take away, whatever the unit’s status).

pub fn status(&self, id: &UnitId, defs: &UnitDefs) -> UnitStatus

Status derivation, in the order §8 gives: Overridden; not expected; definite Failed; Unknown on stale or timed-out Readiness evidence; Running / Degraded from Active; otherwise from Observed. Diagnostic probes never affect the result.

pub fn digest(&self) -> Hash

Hash of everything that describes the system’s state, excluding resources and all observation timestamps (observed_at, Evidence::at, Unknown::since, Transitioning::since). Two observations of an unchanged system therefore have the same digest. Override deadlines (Until::At) are desired-state data and are included.

Trait Implementations

impl Clone for SystemState

fn clone(&self) -> SystemState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SystemState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SystemState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SystemState

fn eq(&self, other: &SystemState) -> 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 SystemState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SystemState

impl StructuralPartialEq for SystemState