Enum UpstreamSignal 

pub enum UpstreamSignal {
    Ack {
        event_id: EventId,
    },
    Backpressure {
        until: i64,
    },
    Cancel {
        correlation_id: EventId,
        reason: String,
    },
    CompensationComplete {
        event_id: EventId,
    },
    ErrorPropagation {
        source_event_id: EventId,
        error_code: String,
        message: String,
    },
    ConflictDetected {
        branch_a: EventId,
        branch_b: EventId,
    },
}

Signals that can be sent upstream in the DAG (“tram car tracks”).

These signals flow in the opposite direction to events, allowing downstream processors to communicate back to upstream producers.

Variants

Ack

Acknowledge receipt/processing of an event

Fields

event_id: EventId

Backpressure

Request backpressure (slow down event production)

Fields

until: i64

Resume timestamp in microseconds

Cancel

Cancel a correlation chain

Fields

correlation_id: EventId

reason: String

CompensationComplete

Signal that compensation is complete

Fields

event_id: EventId

ErrorPropagation

Propagate an error upstream

Fields

source_event_id: EventId

error_code: String

message: String

ConflictDetected

Conflict detected between two concurrent branches in the DAG. This is a coordination signal, not a failure — the handler decides resolution.

Fields

branch_a: EventId

branch_b: EventId

Trait Implementations

impl Clone for UpstreamSignal

fn clone(&self) -> UpstreamSignal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComposeSchema for UpstreamSignal

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl Debug for UpstreamSignal

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for UpstreamSignal

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for UpstreamSignal

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSchema for UpstreamSignal

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

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference [utoipa::openapi::schema::Schema]s for this type.

impl Eq for UpstreamSignal

impl StructuralPartialEq for UpstreamSignal