Struct Execution 

pub struct Execution {

    pub id: ExecutionId,
    pub capability: String,
    pub title: String,
    pub state: ExecutionState,
    pub created_at: String,
    pub started_at: Option<String>,
    pub finished_at: Option<String>,
    pub duration_ms: Option<u64>,
    pub input: Value,
    pub output: Option<Value>,
    pub error: Option<ExecutionError>,
    pub progress: Option<ProgressView>,
    pub steps: Vec<StepView>,
    pub diagnostics: Vec<ExecutionDiagnostic>,
    pub last_sequence: u64,
    pub event_count: u64,
    pub events_truncated: bool,
    pub cancellable: bool,
    pub actor: Actor,
    pub repository: RepositoryRef,
    pub correlation_id: String,
}

One execution, as every transport answers it.

This is the whole of what a client may know. It is produced under the store’s lock, so a reader never sees a state and an output that disagree: an execution that says succeeded carries its output in the same snapshot, and one that says failed carries its error.

Fields

id: ExecutionId

The identity.

capability: String

The capability that ran, by its canonical id.

title: String

That capability’s title, so a list needs no second lookup.

state: ExecutionState

Where it is.

created_at: String

When it was accepted, RFC 3339 in UTC.

started_at: Option<String>

When the handler was entered.

finished_at: Option<String>

When it reached a final state.

duration_ms: Option<u64>

How long it ran, in milliseconds, once it has finished.

input: Value

The input it was given, with every value the input schema marks sensitive replaced.

output: Option<Value>

What the handler returned, for a succeeded execution and never before.

error: Option<ExecutionError>

Why it failed, for a failed execution and never before.

progress: Option<ProgressView>

The last progress the handler reported.

steps: Vec<StepView>

The steps it entered, in order.

diagnostics: Vec<ExecutionDiagnostic>

The findings it reported.

last_sequence: u64

The sequence number of the last event: the cursor a client subscribes from.

event_count: u64

How many events it has produced, including the ones no longer retained.

events_truncated: bool

Whether the retained event history has lost its oldest entries to the bound.

cancellable: bool

Whether asking to cancel this execution will do anything: the capability’s policy.

actor: Actor

Who asked for it.

repository: RepositoryRef

Which repository it ran against.

correlation_id: String

The id used in this process’s logs and tracing spans for this execution; the execution id itself, carried under the name a reader of a log expects.

Implementations

impl Execution

pub fn percent(&self) -> Option<u64>

The percentage a progress bar shows, when the handler said enough to compute one.

Trait Implementations

impl Clone for Execution

fn clone(&self) -> Execution

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Execution

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Execution

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Execution

impl JsonSchema for Execution

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 Execution

fn eq(&self, other: &Execution) -> 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 Execution

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 Execution