Enum ProcessEventKind 

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

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, and that one is gone — the swap is over

ReloadAbandoned

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

The instance named is the one the abandonment left holding the slot, and whether that one is serving depends on which abandonment it was. Where the reload gave up on replacing an instance, that instance is named and is still the app’s live one. Where it gave up because the replacement went down instead, the replacement is named. As with every event here, info is that instance as it stood when the event was raised, so read info.status rather than assuming a live one.

Stop

Stopped by request

Delete

Deregistered

Errored

Restart budget exhausted

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