Enum Transition 

pub enum Transition {
    RestartUnit(UnitId),
    StopUnit(UnitId),
    BindDriver {
        device: UnitId,
        driver: DriverRef,
    },
    ApplyChange {
        change: ChangeId,
        args: BTreeMap<String, Value>,
    },
    SwitchGeneration(GenerationId),
    Revert {
        to: GenerationId,
    },
    Rollback,
    LoadModel(ModelId),
    RestoreSnapshot(SnapshotId),
    CollectGarbage {
        emergency: bool,
    },
    SetRuntimeOption {
        path: String,
        value: Value,
    },
    SetOverride(Override),
    LiftOverride(UnitId),
    StopAndSuppress {
        unit: UnitId,
        until: Until,
        reason: String,
    },
    Resolve {
        txn: TxnId,
        resolution: Resolution,
    },
}

Variants

RestartUnit(UnitId)

StopUnit(UnitId)

BindDriver

Fields

device: UnitId

driver: DriverRef

ApplyChange

Cataloged (§9); the executor computes the diff.

Fields

change: ChangeId

args: BTreeMap<String, Value>

SwitchGeneration(GenerationId)

Revert

Fields

to: GenerationId

Rollback

To known_good (or accepted_baseline).

LoadModel(ModelId)

Phase B.

RestoreSnapshot(SnapshotId)

Phase C.

CollectGarbage

Fields

emergency: bool

SetRuntimeOption

Fields

path: String

value: Value

SetOverride(Override)

Leave-alone only; does not stop anything.

LiftOverride(UnitId)

StopAndSuppress

The user’s “stop X”: suppression journaled, then stop.

Fields

unit: UnitId

until: Until

reason: String

Resolve

planarian resolve <txn>: the only way to clear the recovery interlock (§12c). Administrator-only; not in §8’s list but §12c calls it a transition.

Fields

txn: TxnId

resolution: Resolution

Implementations

impl Transition

pub fn handler(&self) -> Handler

pub fn recovery(&self) -> RecoveryStrategy

pub fn changes_generation(&self) -> bool

Trait Implementations

impl Clone for Transition

fn clone(&self) -> Transition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Transition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Transition

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

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 Transition

impl StructuralPartialEq for Transition