Enum ProcessEventKind 

#[non_exhaustive]
pub enum ProcessEventKind {
    Start,
    Online,
    Exit,
    Restart,
    Reload,
    Reloaded,
    ReloadAbandoned,
    Stop,
    Delete,
    Errored,
    Unrecognized,
}

What happened to a sheep

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.

Start

Spawn initiated

Online

Became ready/online

Exit

Process exited

Restart

Restart initiated

Reload

A reload is replacing this instance: its replacement has been spawned into the same instance slot, and this one will be asked to go once that replacement is serving

Reloaded

This instance has replaced the one it was spawned to drain; that one is gone.

ReloadAbandoned

A reload gave up, so the instances it had not reached are left alone

The instance named is whichever one the abandonment left holding the slot: still the app’s live instance if the reload gave up before replacing it, or the replacement if that one went down instead. info reflects that instance’s state at event time; read info.status rather than assume it is live.

Stop

Stopped by request

Delete

Deregistered

Errored

Restart budget exhausted

Unrecognized

An event kind this build has not been taught.

Only ever produced by decoding: an unrecognized string falls through to this variant via #[serde(other)] instead of failing the whole frame. Nothing constructs one to send, and bark’s is_known_kind refuses the spelling before a rule can name it. That is a call-site invariant rather than a type-level one: #[serde(other)] governs decoding only, so serializing this would emit "unrecognized".

Trait Implementations

impl Clone for ProcessEventKind

fn clone(&self) -> ProcessEventKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ProcessEventKind

impl Debug for ProcessEventKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProcessEventKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ProcessEventKind

impl PartialEq for ProcessEventKind

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ProcessEventKind

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 ProcessEventKind