Enum FailurePoint 

#[non_exhaustive]
pub enum FailurePoint {
    AfterInteractionPersistence,
    BeforeJournalInsert,
    AfterJournalInsertBeforeCommit,
    AfterCommitBeforeEventReadback,
    BeforeOutboxDispatch,
    AfterOutboxDispatch,
    BeforeResponsePersistence,
}

A boundary at which the in-memory store can be made to fail (spec §27.7).

The names describe the moment in a turn, not the method: one point may be reached from more than one method, and the variant documentation names them.

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.

AfterInteractionPersistence

The card was written and the caller is told it was not.

Fires in InteractionWriter::insert and insert_replacing_blocking after the insert: the interaction (and any invalidation the insert performed) stays visible. Spec §15.5 requires interaction persistence to succeed before the response mentions the card, so the truthful reaction is to omit the card, not to claim it.

Inside a commit bundle it fires after stage 5 (interaction inserts) and aborts the bundle.

BeforeJournalInsert

The command was never admitted.

Fires in CommandJournalWriter::begin before anything is written, so the key stays free and the command may be admitted again from scratch.

AfterJournalInsertBeforeCommit

The command was admitted and then the process died before the domain commit.

Fires in CommandJournalWriter::begin after the entry is persisted: the entry survives in Pending, which is exactly the state pending_for_turn exists to find, and recovery must resume it by idempotency key rather than admitting a second command (spec §23.1).

Inside a commit bundle it fires after stage 1 (journal completions) and aborts the bundle.

AfterCommitBeforeEventReadback

The events were appended and the caller could not read them back.

Fires in EventJournalWriter::append after the batch is appended: the events are in the ledger, so a recovery that re-reads by command finds them and must not append them a second time.

Inside a commit bundle it fires after stage 2 (event batches) and aborts the bundle.

BeforeOutboxDispatch

The dispatcher never got the work.

Fires in OutboxWriter::claim_due before anything is claimed: no row moves to Dispatching and the next sweep picks the same rows up.

AfterOutboxDispatch

The external call was made and its result could not be recorded.

Fires in mark_completed, mark_failed and mark_outcome_unknown before the write: the row stays Dispatching with its claim, which is the state release_expired_claims exists to reap. It is the worst case of spec §16.5 — an effect may exist and nothing local says so — so a retry is only safe when the remote guarantees idempotency.

BeforeResponsePersistence

The answer was composed and never stored.

Fires in append_assistant_turn before the write. The turn keeps its user side and its phase marker, so recovery regenerates the response from committed events and stored answer tasks instead of re-executing anything (spec §23.1).

Implementations

impl FailurePoint

pub const ALL: [Self; 7]

Every point, in declaration order.

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

The boundary’s stable name, matching the crash boundaries the specification enumerates.

Stable across releases: test kits and fixtures address a boundary by this string, so renaming one is a breaking change.

pub fn parse(name: &str) -> Result<Self, UnknownFailurePoint>

Parses a boundary from the name as_str renders.

Errors

Returns the unknown name when it matches no boundary.

pub fn leaves_write_visible(self) -> bool

Returns true when the write that precedes the boundary stays visible after the injected failure (outside a commit bundle, which is always all-or-nothing).

Trait Implementations

impl Clone for FailurePoint

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FailurePoint

impl Debug for FailurePoint

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

Formats the value using the given formatter.

impl Display for FailurePoint

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

Formats the value using the given formatter.

impl Eq for FailurePoint

impl Hash for FailurePoint

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 Ord for FailurePoint

fn cmp(&self, other: &Self) -> 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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for FailurePoint

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for FailurePoint

fn partial_cmp(&self, other: &Self) -> 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 StructuralPartialEq for FailurePoint