pub mod queued;
pub mod source;
pub mod stream;
use astrs_wire::messages::control::types::ParamScope;
use astrs_wire::metadata::Parameter;
use astrs_wire::{
DataId, ExtensionKey, Metadata, NodeExitCause, NodeId, OperatorId, ParamKey, PortRef,
RouteCloseReason, StopCause,
};
use crate::payload::Payload;
pub use queued::QueuedEvent;
pub use source::EventSource;
pub use stream::{EventStream, Stream};
#[derive(Debug)]
#[non_exhaustive]
pub enum Event {
Input {
id: DataId,
meta: Metadata,
data: Payload,
},
InputClosed {
id: DataId,
source: PortRef,
reason: RouteCloseReason,
},
InputRecovered {
id: DataId,
source: PortRef,
generation: u64,
},
Stop(StopCause),
Reload {
operator: Option<OperatorId>,
path: Option<String>,
},
AllInputsClosed,
ParamUpdate {
scope: ParamScope,
key: ParamKey,
value: Parameter,
},
ParamDeleted {
scope: ParamScope,
key: ParamKey,
},
NodeFailed {
peer: NodeId,
cause: NodeExitCause,
},
Restarted {
peer: NodeId,
generation: u64,
},
ExtDropped {
key: ExtensionKey,
reason: String,
},
Error(String),
}
impl Event {
#[must_use]
pub const fn input(&self) -> Option<&DataId> {
match self {
Self::Input { id, .. }
| Self::InputClosed { id, .. }
| Self::InputRecovered { id, .. } => Some(id),
_ => None,
}
}
#[must_use]
pub const fn is_input(&self) -> bool {
matches!(self, Self::Input { .. })
}
#[must_use]
pub const fn is_stop(&self) -> bool {
matches!(self, Self::Stop(_))
}
#[must_use]
pub const fn is_control(&self) -> bool {
!matches!(
self,
Self::Input { .. } | Self::InputClosed { .. } | Self::InputRecovered { .. }
)
}
#[must_use]
pub fn is_fault(&self) -> bool {
match self {
Self::NodeFailed { .. } | Self::Error(_) => true,
Self::InputClosed { reason, .. } => !reason.is_expected(),
_ => false,
}
}
#[must_use]
pub const fn metadata(&self) -> Option<&Metadata> {
match self {
Self::Input { meta, .. } => Some(meta),
_ => None,
}
}
#[must_use]
pub const fn payload(&self) -> Option<&Payload> {
match self {
Self::Input { data, .. } => Some(data),
_ => None,
}
}
#[must_use]
pub fn into_input(self) -> Option<(DataId, Metadata, Payload)> {
match self {
Self::Input { id, meta, data } => Some((id, meta, data)),
_ => None,
}
}
#[must_use]
pub const fn kind_name(&self) -> &'static str {
match self {
Self::Input { .. } => "input",
Self::InputClosed { .. } => "input_closed",
Self::InputRecovered { .. } => "input_recovered",
Self::Stop(_) => "stop",
Self::Reload { .. } => "reload",
Self::AllInputsClosed => "all_inputs_closed",
Self::ParamUpdate { .. } => "param_update",
Self::ParamDeleted { .. } => "param_deleted",
Self::NodeFailed { .. } => "node_failed",
Self::Restarted { .. } => "restarted",
Self::ExtDropped { .. } => "ext_dropped",
Self::Error(_) => "error",
}
}
}
impl core::fmt::Display for Event {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Input { id, data, .. } => write!(f, "input {id} ({data})"),
Self::InputClosed { id, reason, .. } => write!(f, "input {id} closed: {reason}"),
Self::InputRecovered { id, generation, .. } => {
write!(f, "input {id} recovered at generation {generation}")
}
Self::Stop(cause) => write!(f, "stop: {cause}"),
Self::Reload { operator, .. } => match operator {
Some(operator) => write!(f, "reload operator {operator}"),
None => f.write_str("reload node"),
},
Self::AllInputsClosed => f.write_str("all inputs closed"),
Self::ParamUpdate { scope, key, value } => write!(f, "{scope}: {key} = {value}"),
Self::ParamDeleted { scope, key } => write!(f, "{scope}: {key} deleted"),
Self::NodeFailed { peer, cause } => write!(f, "peer {peer} failed: {cause}"),
Self::Restarted { peer, generation } => {
write!(f, "peer {peer} restarted as generation {generation}")
}
Self::ExtDropped { key, reason } => write!(f, "extension {key} dropped: {reason}"),
Self::Error(message) => write!(f, "error: {message}"),
}
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use astrs_time::HlcTimestamp;
fn input() -> Event {
Event::Input {
id: DataId::new("frames").unwrap(),
meta: Metadata::new(HlcTimestamp::new(1, 0)),
data: Payload::inline(vec![1, 2, 3]),
}
}
fn every_variant() -> Vec<Event> {
vec![
input(),
Event::InputClosed {
id: DataId::new("frames").unwrap(),
source: PortRef::from_parts("camera", "image").unwrap(),
reason: RouteCloseReason::ProducerFinished,
},
Event::InputRecovered {
id: DataId::new("frames").unwrap(),
source: PortRef::from_parts("camera", "image").unwrap(),
generation: 2,
},
Event::Stop(StopCause::Requested),
Event::Reload {
operator: None,
path: None,
},
Event::AllInputsClosed,
Event::ParamUpdate {
scope: ParamScope::Global,
key: ParamKey::new("gain").unwrap(),
value: Parameter::from(2.0),
},
Event::ParamDeleted {
scope: ParamScope::Global,
key: ParamKey::new("gain").unwrap(),
},
Event::NodeFailed {
peer: NodeId::new("camera").unwrap(),
cause: NodeExitCause::Success,
},
Event::Restarted {
peer: NodeId::new("camera").unwrap(),
generation: 1,
},
Event::ExtDropped {
key: ExtensionKey::user("calibration").unwrap(),
reason: "ttl".to_owned(),
},
Event::Error("queue overflow".to_owned()),
]
}
#[test]
fn every_variant_renders_and_classifies() {
for event in every_variant() {
assert!(!event.to_string().is_empty(), "{event:?}");
assert!(!event.kind_name().is_empty());
}
}
#[test]
fn kind_names_are_unique() {
let mut names: Vec<&str> = every_variant().iter().map(Event::kind_name).collect();
let total = names.len();
names.sort_unstable();
names.dedup();
assert_eq!(names.len(), total);
}
#[test]
fn the_control_lane_is_everything_that_is_not_an_input() {
for event in every_variant() {
let data_lane = matches!(
event,
Event::Input { .. } | Event::InputClosed { .. } | Event::InputRecovered { .. }
);
assert_eq!(event.is_control(), !data_lane, "{event}");
}
}
#[test]
fn inputs_expose_their_parts() {
let event = input();
assert!(event.is_input());
assert!(!event.is_stop());
assert_eq!(event.input().map(DataId::as_str), Some("frames"));
assert!(event.metadata().is_some());
assert_eq!(event.payload().map(Payload::len), Some(3));
let (id, meta, data) = input().into_input().unwrap();
assert_eq!(id.as_str(), "frames");
assert_eq!(meta.timestamp, HlcTimestamp::new(1, 0));
assert_eq!(data.len(), 3);
assert!(Event::AllInputsClosed.into_input().is_none());
}
#[test]
fn stop_is_the_only_fusing_event() {
for event in every_variant() {
assert_eq!(event.is_stop(), matches!(event, Event::Stop(_)));
}
}
#[test]
fn faults_are_reported_as_faults() {
assert!(Event::Error(String::new()).is_fault());
assert!(
Event::NodeFailed {
peer: NodeId::new("x").unwrap(),
cause: NodeExitCause::Success
}
.is_fault()
);
assert!(!input().is_fault());
assert!(
!Event::InputClosed {
id: DataId::new("a").unwrap(),
source: PortRef::from_parts("b", "c").unwrap(),
reason: RouteCloseReason::ProducerFinished,
}
.is_fault(),
"a producer finishing is not a fault"
);
}
}