Enum Transition 

pub enum Transition {
    Open,
    Resume,
    Checkpoint,
    Detach,
    Close,
    Recover,
}

What moved an episode. The vocabulary the ADR 0052 audit needs: open, resume, checkpoint, detach, close, recover.

One of them does not change the state, and it is a transition anyway. A checkpoint leaves an open episode open — but it is one of the two events whose absence is what the audit was looking for, and an event that is modelled as “nothing happened” cannot be counted. The six days of silence were six days in which session.started and session.closed kept arriving and the two events that produce the records a worker resumes from did not. A vocabulary in which those two are not events is a vocabulary in which that outage is invisible.

use majordomus_cli::session::{EpisodeState, Transition};

// a checkpoint is a transition that does not move the state, and says so
let c = Transition::Checkpoint;
assert_eq!(c.from_to(), (EpisodeState::Open, EpisodeState::Open));
assert!(!c.moves_state());

// a resume is canonically the return to a detached episode; a provider's start event
// arriving at one that is already open is the same transition seen from `Open`, which
// the machine allows without a move
assert_eq!(Transition::Resume.from_to(), (EpisodeState::Detached, EpisodeState::Open));
assert!(EpisodeState::Open.may_move_to(EpisodeState::Open));

// and every transition's own move is one the machine allows
for t in Transition::ALL {
    let (from, to) = t.from_to();
    assert!(from.may_move_to(to), "{} is not a legal move", t.as_str());
}

Variants

Open

The episode begins: an id is minted and the open record is written.

Resume

The worker came back to a detached episode. A provider’s start event also fires again on a resume and on a compaction against an episode that is still open; that is the same transition observed from Open, and the honest answer to “your episode is already open” is to keep it rather than to open a second one.

Checkpoint

A progress note was recorded against the episode. An artefact of the episode and not of a task (ADR 0052): a checkpoint outside a task records task: none and is a normal record, not a refusal.

Detach

The connection went away without an end event.

Close

The worker ended the episode and the immutable record was published.

Recover

Nobody ended it and its last sign of life is older than the stranded threshold, so maintenance closed it. The record says so: an episode closed this way is interrupted, because a reader resuming from it needs to know it may be incomplete.

Implementations

impl Transition

pub const ALL: [Transition; 6]

Every transition, in lifecycle order.

pub fn from_to(self) -> (EpisodeState, EpisodeState)

The states this transition runs between: where an episode must be for it to apply, and where it is afterwards.

use majordomus_cli::session::{EpisodeState, Transition};
assert_eq!(Transition::Close.from_to(), (EpisodeState::Open, EpisodeState::Closed));
assert_eq!(Transition::Detach.from_to(), (EpisodeState::Open, EpisodeState::Detached));

pub fn moves_state(self) -> bool

Does this transition change the state, or is it an event inside one? A checkpoint is the second kind, and it is a transition anyway: an event modelled as “nothing happened” cannot be counted, and counting it is how a stopped writer becomes visible.

use majordomus_cli::session::Transition;
assert!(!Transition::Checkpoint.moves_state());
assert!(Transition::Close.moves_state());

pub fn as_str(self) -> &'static str

The word as serialised, which is what a projection of the machine carries and what a ledger event’s name is read against.

use majordomus_cli::session::Transition;
assert_eq!(Transition::Recover.as_str(), "recover");
assert_eq!(Transition::Checkpoint.as_str(), "checkpoint");

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 Copy for Transition

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 Eq for Transition

impl Hash for Transition

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl JsonSchema for Transition

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Ord for Transition

fn cmp(&self, other: &Transition) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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 PartialOrd for Transition

fn partial_cmp(&self, other: &Transition) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

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 StructuralPartialEq for Transition