use std::time::Duration;
use bytes::Bytes;
use hang::catalog::PRIORITY;
use hang::moq_net;
use crate::catalog::{self, DATA_TRACK, MoqrosSection};
use crate::clock::StreamClock;
use crate::track::{BroadcastWriter, GroupWriter, TrackReader};
use crate::{Error, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum DataFormat {
Json,
Cdr,
}
crate::names::named_enum!(DataFormat, "data format", {
Json => "json",
Cdr => "cdr",
});
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum DataMode {
#[default]
Snapshot,
Stream,
}
crate::names::named_enum!(DataMode, "data mode", {
Snapshot => "snapshot",
Stream => "stream",
});
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct DataSettings {
pub format: DataFormat,
pub mode: DataMode,
pub ros_type: Option<String>,
}
impl DataSettings {
pub fn new(format: DataFormat) -> Self {
Self {
format,
mode: DataMode::default(),
ros_type: None,
}
}
pub fn with_mode(mut self, mode: DataMode) -> Self {
self.mode = mode;
self
}
pub fn with_ros_type(mut self, ros_type: impl Into<String>) -> Self {
self.ros_type = Some(ros_type.into());
self
}
}
pub struct DataPublisher {
settings: DataSettings,
clock: StreamClock,
stamps: Option<Stamps>,
section: MoqrosSection,
track: GroupWriter,
broadcast: BroadcastWriter,
}
impl DataPublisher {
pub(crate) fn new(origin: &moq_net::origin::Producer, name: &str, settings: DataSettings) -> Result<Self> {
let section = MoqrosSection::default();
let catalog = catalog::data(&settings, §ion)?;
let mut broadcast = BroadcastWriter::create(origin, name)?;
let track = broadcast.create_track(DATA_TRACK, moq_net::track::Info::default().with_priority(PRIORITY.text))?;
broadcast.publish_catalog(&catalog)?;
tracing::info!(
broadcast = name,
format = %settings.format,
mode = %settings.mode,
ros_type = settings.ros_type.as_deref().unwrap_or_default(),
"announced data broadcast"
);
Ok(Self {
settings,
clock: StreamClock::default(),
stamps: None,
section,
track: GroupWriter::new(track),
broadcast,
})
}
pub fn name(&self) -> &str {
self.broadcast.name()
}
pub fn settings(&self) -> &DataSettings {
&self.settings
}
pub fn publish(&mut self, payload: impl Into<Bytes>) -> Result<()> {
self.stamp_with(Stamps::SendTime)?;
self.write(moq_net::Timestamp::now(), payload.into())
}
pub fn publish_at(&mut self, capture: Duration, payload: impl Into<Bytes>) -> Result<()> {
self.stamp_with(Stamps::CaptureTime)?;
let pts = self.clock.micros(capture);
let origin = self.clock.origin_micros();
if origin != self.section.capture_origin {
self.section.capture_origin = origin;
self.broadcast
.publish_catalog(&catalog::data(&self.settings, &self.section)?)?;
}
let timestamp = moq_net::Timestamp::from_micros(pts).map_err(|_| Error::Timestamp)?;
self.write(timestamp, payload.into())
}
fn stamp_with(&mut self, stamps: Stamps) -> Result<()> {
if *self.stamps.get_or_insert(stamps) == stamps {
return Ok(());
}
Err(Error::InvalidSettings(format!(
"data broadcast {:?} mixes publish (send times) and publish_at (capture times)",
self.name()
)))
}
fn write(&mut self, timestamp: moq_net::Timestamp, payload: Bytes) -> Result<()> {
match self.settings.mode {
DataMode::Snapshot => {
self.track.write_frame(timestamp, payload)?;
self.track.finish_group()?;
}
DataMode::Stream => {
if !self.track.fits(payload.len()) {
self.track.finish_group()?;
}
self.track.write_frame(timestamp, payload)?;
}
}
Ok(())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Stamps {
SendTime,
CaptureTime,
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct DataMessage {
pub timestamp: Duration,
pub capture_time: Option<Duration>,
pub payload: Bytes,
}
pub struct DataSubscriber {
reader: TrackReader,
settings: DataSettings,
}
impl DataSubscriber {
pub(crate) fn new(reader: TrackReader, settings: DataSettings) -> Self {
Self { reader, settings }
}
pub fn settings(&self) -> &DataSettings {
&self.settings
}
pub async fn next_message(&mut self) -> Result<Option<DataMessage>> {
let frame = self.reader.next_frame().await?;
Ok(frame.map(|frame| {
let timestamp = frame.timestamp.into();
DataMessage {
timestamp,
capture_time: self.reader.catalog().capture_time(timestamp),
payload: frame.payload,
}
}))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn names_round_trip() {
for format in [DataFormat::Json, DataFormat::Cdr] {
assert_eq!(format.to_string().parse::<DataFormat>().unwrap(), format);
}
for mode in [DataMode::Snapshot, DataMode::Stream] {
assert_eq!(mode.to_string().parse::<DataMode>().unwrap(), mode);
}
assert_eq!("JSON".parse::<DataFormat>().unwrap(), DataFormat::Json);
assert!(matches!("xml".parse::<DataFormat>(), Err(Error::InvalidSettings(_))));
assert!(matches!("log".parse::<DataMode>(), Err(Error::InvalidSettings(_))));
}
fn settings(format: DataFormat, mode: DataMode, ros_type: Option<&str>) -> DataSettings {
DataSettings {
format,
mode,
ros_type: ros_type.map(String::from),
}
}
#[tokio::test]
async fn send_and_capture_times_do_not_mix() {
let origin = moq_tokio::origin::spawn();
let new =
|name| DataPublisher::new(&origin, name, settings(DataFormat::Json, DataMode::Snapshot, None)).unwrap();
let mut sent = new("sent");
sent.publish("0").unwrap();
let err = sent.publish_at(Duration::from_secs(1), "1").unwrap_err();
assert!(matches!(err, Error::InvalidSettings(_)), "{err}");
assert_eq!(sent.section.capture_origin, None);
sent.publish("2").unwrap();
let mut captured = new("captured");
captured.publish_at(Duration::from_secs(1), "0").unwrap();
let err = captured.publish("1").unwrap_err();
assert!(matches!(err, Error::InvalidSettings(_)), "{err}");
captured.publish_at(Duration::from_secs(2), "2").unwrap();
}
#[tokio::test]
async fn stream_continues_past_a_full_group() {
let origin = moq_tokio::origin::spawn();
let mut publisher =
DataPublisher::new(&origin, "log", settings(DataFormat::Json, DataMode::Stream, None)).unwrap();
let broadcast = origin.consume().request_broadcast("log").await.unwrap();
let mut track = broadcast
.track(DATA_TRACK)
.unwrap()
.subscribe(moq_net::track::Subscription::default())
.await
.unwrap()
.ordered();
publisher.publish("0").unwrap();
let mut group = track.next_group().await.unwrap().unwrap();
let count = moq_net::group::MAX_GROUP_FRAMES + 100;
for i in 1..count {
publisher.publish(i.to_string()).unwrap();
}
drop(publisher);
let mut groups = 1;
let mut received = 0;
loop {
while let Some(frame) = group.read_frame().await.unwrap() {
assert_eq!(frame.payload, received.to_string().as_bytes());
received += 1;
}
let Ok(Some(next)) = track.next_group().await else {
break;
};
group = next;
groups += 1;
}
assert_eq!((groups, received), (2, count));
}
}