Enum paxakos::event::Event

#[non_exhaustive]
pub enum Event<I: Invocation> {
    Init {
        status: NodeStatus,
        round: RoundNumOf<I>,
        state: Option<Arc<FrozenStateOf<I>>>,
    },
    StatusChange {
        old_status: NodeStatus,
        new_status: NodeStatus,
    },
    Activate(RoundNumOf<I>),
    Install {
        round: RoundNumOf<I>,
        state: Option<Arc<FrozenStateOf<I>>>,
    },
    Commit {
        round: RoundNumOf<I>,
        log_entry: Arc<LogEntryOf<I>>,
    },
    Apply {
        round: RoundNumOf<I>,
        log_entry: Arc<LogEntryOf<I>>,
        effect: EffectOf<I>,
        new_concurrency: NonZeroUsize,
    },
    Gaps(Vec<Gap<RoundNumOf<I>>>),
    Directive {
        kind: DirectiveKind,
        leader: NodeOf<I>,
        round_num: RoundNumOf<I>,
        coord_num: CoordNumOf<I>,
        timestamp: Instant,
    },
    Eject {
        reason: EjectionOf<I>,
        state: StateOf<I>,
    },
}

Emitted by Node’s poll_events method.

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.

Init

Fields

status: NodeStatus

Initial status of the node.

round: RoundNumOf<I>

Round the node is in.

state: Option<Arc<FrozenStateOf<I>>>

Initial state or None when no snapshot was given.

First event that is fired immediately after construction.

StatusChange

Fields

old_status: NodeStatus

Old status.

new_status: NodeStatus

New status.

Node’s status changed.

Activate(RoundNumOf<I>)

The node is transitioning to partially active participation.

Install

Fields

round: RoundNumOf<I>

Round node is in after a snapshot was installed.

state: Option<Arc<FrozenStateOf<I>>>

State the node is in after a snapshot was installed.

A snapshot was installed.

Commit

Fields

round: RoundNumOf<I>

The round for which log_entry was committed.

log_entry: Arc<LogEntryOf<I>>

The log entry which was committed.

An entry has been committed to the log.

The event does not imply that the entry was applied to the shared state.

Apply

Fields

round: RoundNumOf<I>

Round the log entry was applied in.

log_entry: Arc<LogEntryOf<I>>

Log entry that was applied.

effect: EffectOf<I>

The event data that the application.

new_concurrency: NonZeroUsize

Concurrency after this apply.

The next log entry was applied to the state.

Gaps(Vec<Gap<RoundNumOf<I>>>)

A log entry was queued, preceeding entries are still missing.

Note: This event is emitted even when the queued entry is within the concurrency bound or if this node created the gap itself. The second case can arise when the leader tries to concurrently append multiple entries and abandons some of the earlier appends.

Directive

Fields

kind: DirectiveKind

Kind of directive, either Prepare, Accept or Commit.

leader: NodeOf<I>

Leader that issued the directive.

round_num: RoundNumOf<I>

Round for which the directive was issued.

coord_num: CoordNumOf<I>

Coordination number with which the directive was issued.

timestamp: Instant

Time the directive was (locally) registered.

This node received a (potentially indirect) directive for the given round and from the given node. The node used the mandate obtained with the given coordination number to issue the directive.

This event is not emitted when this node is disoriented or lagging.

Eject

Fields

reason: EjectionOf<I>

The reason for the ejection.

state: StateOf<I>

The ejected state.

The node ejected its state.

Trait Implementations

impl<I: Invocation> Debug for Event<I>

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

Formats the value using the given formatter.

impl<I: Invocation> From<Event<I>> for ShutdownEvent<I>

fn from(e: Event<I>) -> Self

Converts to this type from the input type.