Enum RecoveryAction 

#[non_exhaustive]
pub enum RecoveryAction {
    Nothing {
        phase: TurnPhase,
    },
    RestartInterpretation,
    ResumeCommands {
        entries: Vec<CommandJournalEntry>,
    },
    RegenerateResponse {
        events: Vec<StoredEvent>,
        answer_tasks: Vec<AnswerTask>,
    },
    ReconcileExternal {
        attempts: Vec<AttemptId>,
        entries: Vec<CommandJournalEntry>,
    },
}

What recovery decided to do with a turn (spec §23.1).

“Unfinished” is not quite the right word for what this covers, and the difference matters: a turn can be TurnPhase::Delivered — the user has a truthful answer, saying the request is being verified — while an external effect it started is still unsettled. Recovery therefore looks at the journal before it looks at the phase.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Nothing

The turn is finished; there is nothing to do.

Fields

phase: TurnPhase

The phase it finished in.

RestartInterpretation

No command was ever admitted, so nothing can have happened and the turn may be interpreted again from the start.

ResumeCommands

Commands were admitted and not settled. They are resumed by idempotency key: handing the executor these entries lets it recognise what already ran instead of running it twice (I14).

Fields

entries: Vec<CommandJournalEntry>

The entries to resume, in admission order.

RegenerateResponse

Everything that was going to commit has committed. The response is rebuilt from the ledger and the stored plan, and nothing is executed.

Fields

events: Vec<StoredEvent>

The events the turn committed, in append order.

answer_tasks: Vec<AnswerTask>

The questions the turn planned, as answer tasks.

ReconcileExternal

An external effect may or may not have happened. It is settled against the remote system by attempt identifier, never repeated blindly (I15).

Fields

attempts: Vec<AttemptId>

The attempts to settle, in the order they were made.

entries: Vec<CommandJournalEntry>

The journal entries that carry them.

Implementations

impl RecoveryAction

pub const fn may_cause_effects(&self) -> bool

Returns true when acting on this decision may cause a domain effect.

Only Self::ResumeCommands can, and even then only through the idempotency key.

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

Stable snake-case label, for metrics and logs.

Trait Implementations

impl Clone for RecoveryAction

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RecoveryAction

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

Formats the value using the given formatter.

impl PartialEq for RecoveryAction

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RecoveryAction