use core::marker::PhantomData;
use astrs_data::{ArrayRef, AstrsMessage, RecordBatch};
use astrs_wire::{DataId, Metadata, PortRef};
use crate::error::Result;
use crate::output::{OutputSample, RawOutput};
use crate::session::routes::RoutePlane;
#[derive(Debug)]
pub struct Output<T> {
raw: RawOutput,
marker: PhantomData<fn(T)>,
}
impl<T> Output<T> {
#[must_use]
pub const fn new(raw: RawOutput) -> Self {
Self {
raw,
marker: PhantomData,
}
}
#[must_use]
pub const fn id(&self) -> &DataId {
self.raw.id()
}
#[must_use]
pub fn plane(&self) -> RoutePlane {
self.raw.plane()
}
#[must_use]
pub fn consumers(&self) -> &[PortRef] {
self.raw.consumers()
}
#[must_use]
pub fn metadata(&self) -> Metadata {
self.raw.metadata()
}
#[must_use]
pub const fn raw(&self) -> &RawOutput {
&self.raw
}
pub const fn raw_mut(&mut self) -> &mut RawOutput {
&mut self.raw
}
#[must_use]
pub fn into_raw(self) -> RawOutput {
self.raw
}
pub fn send_bytes(&mut self, bytes: impl AsRef<[u8]>, metadata: Metadata) -> Result<()> {
self.raw.send_bytes(bytes, metadata)
}
pub fn send_batch(&mut self, batch: &RecordBatch, metadata: Metadata) -> Result<()> {
self.raw.send_batch(batch, metadata)
}
pub fn send_array(&mut self, array: ArrayRef, metadata: Metadata) -> Result<()> {
self.raw.send_array(array, metadata)
}
pub fn allocate(&mut self, len: usize) -> Result<OutputSample<'_>> {
self.raw.allocate(len)
}
pub fn close(&mut self) -> Result<()> {
self.raw.close()
}
}
impl<T: AstrsMessage> Output<T> {
#[must_use]
pub const fn type_urn(&self) -> &'static str {
T::URN
}
pub fn send(&mut self, value: impl Into<T>, metadata: Metadata) -> Result<()> {
let batch = value.into().to_record_batch()?;
self.raw.send_batch(&batch, metadata)
}
pub fn publish(&mut self, value: impl Into<T>) -> Result<()> {
let metadata = self.metadata();
self.send(value, metadata)
}
pub fn send_following(&mut self, value: impl Into<T>, cause: &Metadata) -> Result<()> {
self.send(value, cause.follow())
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use crate::events::EventSource;
use crate::message::{Scalar, Vector3};
use crate::runtime::NodeRuntime;
use crate::session::{OUTGOING_CAPACITY, Outgoing, SessionShared};
use astrs_wire::{
DataflowId, FrameLimits, NodeId, NodeRequest, NodeSource, NodeSpawnSpec, SessionId,
};
use std::sync::Arc;
use tokio::sync::mpsc;
fn handle<T>() -> (Output<T>, Arc<SessionShared>, mpsc::Receiver<Outgoing>) {
let (sender, receiver) = mpsc::channel(OUTGOING_CAPACITY);
let spec = Arc::new(NodeSpawnSpec::new(
DataflowId::from_u128(1),
NodeId::new("planner").unwrap(),
0,
NodeSource::Dynamic,
));
let shared = Arc::new(SessionShared::new(
spec,
SessionId::from_u128(1),
sender,
Arc::new(EventSource::new()),
NodeRuntime::acquire().unwrap(),
4096,
FrameLimits::uds(),
));
let raw = RawOutput::new(Arc::clone(&shared), DataId::new("velocity").unwrap());
(Output::new(raw), shared, receiver)
}
fn take_payload(receiver: &mut mpsc::Receiver<Outgoing>) -> (Metadata, Vec<u8>) {
loop {
let Ok(Outgoing::Request(request)) = receiver.try_recv() else {
panic!("expected a request");
};
if let NodeRequest::SendMessage {
metadata, payload, ..
} = *request
{
return (metadata, payload.bytes().unwrap_or_default().to_vec());
}
}
}
#[test]
fn a_typed_send_round_trips_through_the_wire_payload() {
let (mut output, _shared, mut receiver) = handle::<Vector3>();
let value = Vector3::new(1.0, 2.0, 3.0);
output.send(value, output.metadata()).unwrap();
let (_, bytes) = take_payload(&mut receiver);
let batch = astrs_data::ipc::decode_payload(&bytes).unwrap();
assert_eq!(Vector3::from_record_batch(&batch).unwrap(), value);
assert_eq!(output.type_urn(), "std/geometry/v1/Vector3");
assert_eq!(output.id().as_str(), "velocity");
}
#[test]
fn into_makes_scalar_channels_read_naturally() {
let (mut output, _shared, mut receiver) = handle::<Scalar<f64>>();
output.publish(2.5_f64).unwrap();
let (_, bytes) = take_payload(&mut receiver);
let batch = astrs_data::ipc::decode_payload(&bytes).unwrap();
assert_eq!(
Scalar::<f64>::from_record_batch(&batch)
.unwrap()
.into_inner(),
2.5
);
}
#[test]
fn following_keeps_the_correlation_keys() {
let (mut output, _shared, mut receiver) = handle::<Vector3>();
let mut cause = output.metadata();
cause.set_request_id("req-7");
output.send_following(Vector3::default(), &cause).unwrap();
let (metadata, _) = take_payload(&mut receiver);
assert_eq!(metadata.request_id(), Some("req-7"));
}
#[test]
fn the_untyped_faces_are_reachable() {
let (mut output, _shared, mut receiver) = handle::<Vector3>();
output.send_bytes(vec![1, 2, 3], output.metadata()).unwrap();
let (_, bytes) = take_payload(&mut receiver);
assert_eq!(bytes, vec![1, 2, 3]);
assert_eq!(output.plane(), RoutePlane::Daemon);
assert!(output.consumers().is_empty());
assert_eq!(output.raw().id().as_str(), "velocity");
assert_eq!(output.raw_mut().id().as_str(), "velocity");
let mut sample = output.allocate(2).unwrap();
sample.as_mut_slice().copy_from_slice(&[8, 9]);
sample.send(Metadata::default()).unwrap();
let (_, bytes) = take_payload(&mut receiver);
assert_eq!(bytes, vec![8, 9]);
output.close().unwrap();
assert!(output.into_raw().is_closed());
}
}