Enum SlotOutcome 

pub enum SlotOutcome {
    NotDue {
        last_maintained: String,
    },
    InUse {
        session: SessionToken,
    },
    Unavailable {
        holder: String,
    },
    Broken {
        reason: String,
    },
    Ran {
        outcome: MaintenanceOutcome,
        duration_ms: u64,
        log: Option<ArtifactId>,
        disk: Option<SlotDisk>,
    },
}

What became of one slot.

Externally tagged in kebab case, the way IdentityOutcome is.

Variants

NotDue

Maintained inside the caller’s older_than, so not run.

Fields

last_maintained: String

When it was last maintained, RFC3339.

InUse

An open session record names it, so not run.

Fields

session: SessionToken

The session working in it.

Unavailable

Something else has it right now: a live claim this run did not write, an occupancy it could not take, or a process working inside it.

A healthy slot that is busy, and a later run finds it clear — which is what separates it from SlotOutcome::Broken, so a consumer reads breakage off the variant rather than off a reason it has to parse.

Fields

holder: String

What holds it: the claim, the occupancy, or the processes inside it.

Broken

It could not be claimed because its clone, worktree or record is not usable — nothing waiting clears.

Fields

reason: String

What is wrong with it.

Ran

The command ran in it, and how that ended.

Fields

outcome: MaintenanceOutcome

How the command ended.

duration_ms: u64

How long it ran, in milliseconds.

log: Option<ArtifactId>

Everything it wrote, stored as one artifact — None where storing it failed, which is warned about on stderr.

disk: Option<SlotDisk>

Allocated worktree bytes before and after the command.

Trait Implementations

impl Clone for SlotOutcome

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 SlotOutcome

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SlotOutcome

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SlotOutcome

impl PartialEq for SlotOutcome

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for SlotOutcome

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SlotOutcome