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, CatalogWatch, GroupReader, GroupWriter};
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)]
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 struct DataPublisher {
settings: DataSettings,
clock: StreamClock,
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(),
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.write(moq_net::Timestamp::now(), payload.into())
}
pub fn publish_at(&mut self, capture: Duration, payload: impl Into<Bytes>) -> Result<()> {
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 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)]
pub struct DataMessage {
pub timestamp: Duration,
pub capture_time: Option<Duration>,
pub payload: Bytes,
}
pub struct DataSubscriber {
_broadcast: moq_net::broadcast::Consumer,
reader: GroupReader,
settings: DataSettings,
catalog: CatalogWatch,
}
impl DataSubscriber {
pub(crate) fn new(
broadcast: moq_net::broadcast::Consumer,
reader: GroupReader,
settings: DataSettings,
catalog: CatalogWatch,
) -> Self {
Self {
_broadcast: broadcast,
reader,
settings,
catalog,
}
}
pub fn settings(&self) -> &DataSettings {
&self.settings
}
pub async fn next_message(&mut self) -> Result<Option<DataMessage>> {
loop {
let frame = tokio::select! {
biased;
() = self.catalog.changed() => continue,
frame = self.reader.next_frame() => frame?,
};
return Ok(frame.map(|frame| {
let timestamp = frame.timestamp.into();
DataMessage {
timestamp,
capture_time: self.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 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));
}
}