Enum Finding 

pub enum Finding {
    Chain {
        run: RunId,
        detail: String,
    },
    NotInLog {
        run: RunId,
    },
    BadInclusion {
        run: RunId,
    },
    LeafMismatch {
        run: RunId,
    },
    SealClaim {
        run: RunId,
    },
    GroupUnsettled {
        run: RunId,
        group: String,
    },
    EffectUndecided {
        run: RunId,
        step: StepId,
        effect: EffectKey,
        doubt: &'static str,
    },
    NotAppendOnly {
        old_size: u64,
        obtained_from: String,
    },
    WrongLog {
        theirs: String,
        ours: String,
        obtained_from: String,
    },
    Shrunk {
        old_size: u64,
        now: u64,
        obtained_from: String,
    },
    StaleWitness {
        key_id: KeyId,
        obtained_from: String,
        timestamp: u64,
        age_secs: u64,
    },
    WitnessTimeAhead {
        key_id: KeyId,
        obtained_from: String,
        timestamp: u64,
        ahead_secs: u64,
    },
}

One thing wrong with a plane’s history.

Variants

Chain

Fields

run: RunId

detail: String

NotInLog

Fields

run: RunId

BadInclusion

Fields

run: RunId

LeafMismatch

The chain the store served is not the chain the log committed to.

The one that catches a truncated-but-internally-consistent record set: a prefix of a chain verifies on its own, and the leaf the log holds is the terminal hash of the whole run — so an audit that verified the records and then checked the store-supplied leaf against the tree, without ever holding the two to each other, was verifying two halves of two different claims.

Fields

run: RunId

SealClaim

The sealing record’s own claim disagrees with the chain it sits in.

RunSealed.chain_head is the head the conclusion was drawn over — by construction, the record’s own prev_hash. A mismatch means the conclusion was composed against a different history than the one it was appended to, which no honest writer produces.

Fields

run: RunId

GroupUnsettled

A sealed conclusion over an undecided transactional unit.

GroupOpened/GroupSettled bracket several effects that take together or not at all, and the settlement is the most consequential thing a group does. A run still open with a group unsettled is the ordinary crash shape — the resume re-walks the members and settles, and the run itself sits in a findable backlog until it does. A sealed run is the state no honest writer produces: nothing may resume it, so nothing will ever settle the group, and whether its members were taken or taken back is permanently unanswerable from a history that claims to be complete.

Fields

run: RunId

group: String

EffectUndecided

A sealed conclusion over an effect whose outcome was never established.

The finding that outlives the run. A quarantine is a status, and a status is something a later action overwrites: abandoning the run takes it off the quarantine backlog, which is the only listing that carried it. What the run left in the world does not go away with the listing, so the record of it is derived from the journal instead — where nothing an operator does can take it off.

Under a sealing conclusion only, and for the reason GroupUnsettled is: an open run with an undecided effect is the ordinary crash shape, healed by a resume or answered by a person, and flagging it would teach the reader this finding is weather.

Mutating effects only. A read that never came back is safe to repeat and changed nothing, so there is nothing here for an auditor to act on.

Fields

run: RunId

step: StepId

effect: EffectKey

doubt: &'static str

Whether the runtime never heard back, or heard back and was told nothing — two different places for an investigator to start.

NotAppendOnly

The one that needs an outside artifact.

Names which anchor it failed against, because an audit is held to every checkpoint an auditor brought rather than to one: a fork is visible from whichever observer saw the history it diverged from, and that observer is the first thing an investigator has to go and ask.

Fields

old_size: u64

obtained_from: String

WrongLog

Fields

theirs: String

ours: String

obtained_from: String

Shrunk

Fields

old_size: u64

now: u64

obtained_from: String

StaleWitness

A witness key has not seen the log for longer than the auditor allows. Not attributed: plane silence, a failed submission and a witness outage look the same from outside.

Fields

key_id: KeyId

obtained_from: String

timestamp: u64

age_secs: u64

WitnessTimeAhead

A witness key’s signed time is ahead of the auditor’s clock by more than the maximum age, so it cannot be read as fresh.

Fields

key_id: KeyId

obtained_from: String

timestamp: u64

ahead_secs: u64

Trait Implementations

impl Clone for Finding

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 Finding

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

Formats the value using the given formatter.

impl Display for Finding

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

Formats the value using the given formatter.

impl Eq for Finding

impl Error for Finding

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl PartialEq for Finding

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Finding