Enum EventPayload 

pub enum EventPayload {
    Created {
        capability: String,
        title: String,
        input: Value,
    },
    Queued {
        ahead: usize,
    },
    Started,
    Progress(ProgressView),
    StepStarted {
        name: String,
        title: String,
    },
    StepCompleted {
        name: String,
        ok: bool,
        detail: Option<String>,
    },
    Log {
        stream: LogStream,
        message: String,
    },
    Diagnostic(ExecutionDiagnostic),
    Cancelling {
        by: String,
    },
    Cancelled,
    Completed {
        output: Value,
    },
    Failed {
        error: ExecutionError,
    },
}

What happened, as a closed set.

The tag is type and the body is data, so every event on the wire has the same two members whatever it says, and a client switches on one string.

Variants

Created

The execution was accepted and exists. Carries what it will run and with what, redacted, so a client that joins at the first event needs nothing else to render a heading.

Fields

capability: String

The capability’s canonical id.

title: String

Its title.

input: Value

The input, with sensitive values already replaced.

Queued

It is waiting for a worker.

Fields

ahead: usize

How many executions are ahead of it.

Started

A worker picked it up and is about to enter the handler.

Progress(ProgressView)

How far along it is.

StepStarted

A named phase was entered.

Fields

name: String

The step’s stable name.

title: String

One line for a reader.

StepCompleted

A named phase finished.

Fields

name: String

The step’s stable name.

ok: bool

Whether what it was asked to do happened.

detail: Option<String>

What it said, when it said anything.

Log

A line of output.

Fields

stream: LogStream

Which stream it came from.

message: String

The text, with control characters and terminal escapes already removed.

Diagnostic(ExecutionDiagnostic)

A structured finding, distinct from the outcome.

Cancelling

Cancellation was asked for; the handler has not stopped yet.

Fields

by: String

Who asked, in one word.

Cancelled

It stopped because it was asked to.

Completed

It finished, and the handler returned an output.

The output is on this event and not on one of its own, because a client must never be able to read “succeeded” and find no result: the state and the value it produced are one fact and travel together.

Fields

output: Value

What the handler returned.

Failed

It finished, and it did not.

Fields

error: ExecutionError

Why.

Implementations

impl EventPayload

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

The discriminator on the wire.

use majordomus_cli::execution::EventPayload;
assert_eq!(EventPayload::Started.type_name(), "execution.started");
assert_eq!(EventPayload::Cancelled.type_name(), "execution.cancelled");

pub fn is_terminal(&self) -> bool

Is this the last event of its execution? A subscriber that has read one may stop.

use majordomus_cli::execution::EventPayload;
assert!(EventPayload::Cancelled.is_terminal());
assert!(!EventPayload::Started.is_terminal());

pub fn implies_state(&self) -> Option<ExecutionState>

The state this event puts the execution into, when it decides one.

Trait Implementations

impl Clone for EventPayload

fn clone(&self) -> EventPayload

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventPayload

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventPayload

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for EventPayload

impl JsonSchema for EventPayload

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for EventPayload

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EventPayload

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 EventPayload