Enum AuditEventKind 

pub enum AuditEventKind {
    ApprovalGranted,
    ApprovalConsumed,
    ApprovalRevoked,
    StatusQueued,
    StatusRunning,
    StatusSucceeded,
    StatusFailed,
    StatusCanceled,
    StatusRolledBack,
    StatusNeedsReboot,
}

A lifecycle event on an approval receipt.

The transactions chain commits to the authorisation decision at preview time. It says nothing about whether a human ever approved, whether that approval was spent, or whether it was retracted — those live in transaction_approvals, a plain mutable table. Deleting a row from it used to leave sysknife audit verify reporting Intact, so the record that an approval happened was the one part of the trail an attacker could erase without leaving a mark. These events are chained so that erasure breaks a signature.

Variants

ApprovalGranted

A receipt was minted for a queued transaction.

ApprovalConsumed

A receipt was spent to move a transaction into Running.

ApprovalRevoked

An undelivered receipt was retracted before it could be spent.

StatusQueued

A transaction reached the state named by this variant.

The outcome lives in the kind, so it is covered by the event signature. transactions.status is an ordinary mutable column: anyone who can UPDATE that table could rewrite a job that ran to completion as canceled, and the chain had nothing to disagree with. One variant per state rather than a free-text field keeps as_str returning a stable &'static str, which is what every already-written signature commits to.

StatusRunning

StatusSucceeded

StatusFailed

StatusCanceled

StatusRolledBack

StatusNeedsReboot

Implementations

impl AuditEventKind

pub const ALL: &'static [AuditEventKind]

Every variant, in the order they were introduced.

parse_event_kind reads this list, so a variant missing from it is not a compile error: it verifies as a broken chain at runtime, on a row the daemon itself wrote. The previous version of that function carried the comment “exhaustive by construction: the match below fails to compile if a variant is added without a spelling here” over an array literal, where adding a variant compiles perfectly well. Adding the status kinds is what showed the claim was false, and every_variant_is_in_all below is the exhaustive match that makes it true.

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

Stored and signed spelling. Stable on the wire — changing one of these strings invalidates every event signature already written.

Trait Implementations

impl Clone for AuditEventKind

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 AuditEventKind

impl Debug for AuditEventKind

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

Formats the value using the given formatter.

impl Eq for AuditEventKind

impl From<JobState> for AuditEventKind

fn from(state: JobState) -> Self

Converts to this type from the input type.

impl PartialEq for AuditEventKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AuditEventKind