From f9d80b83b36aef4cb5b3acb0667fb58aa4ac8fce Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 18 Nov 2026 15:52:59 -0800 Subject: [PATCH 1/3] chore(quest): claim quest/m2/outcome-enums/ordered-gaps.md Quest-Claim: 7296141a8dd667c9 From 4c83b372f16c2f258ea23a33f1ea456f048d3f09 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 18 Nov 2026 16:05:41 -0800 Subject: [PATCH 2/3] feat(net)!: an ordered track's next_group yields groups, next_item yields gaps too Co-Authored-By: Claude Opus 5.5 --- quest/m2/outcome-enums/ordered-gaps.md | 34 -- quest/m2/unused-api/net.md | 9 +- rs/libmoq/src/consume.rs | 13 +- rs/moq-archive/src/consumer/tests.rs | 29 +- rs/moq-archive/src/producer/track.rs | 9 +- rs/moq-bench/src/connection.rs | 28 +- rs/moq-cli/src/main.rs | 2 +- rs/moq-ffi/src/consumer.rs | 20 +- rs/moq-ffi/src/media.rs | 6 +- rs/moq-gst/src/sink/imp.rs | 1 - rs/moq-gst/src/sink/pad.rs | 21 +- rs/moq-hls/src/export/rendition.rs | 5 +- rs/moq-hls/src/import.rs | 3 +- rs/moq-hls/tests/integration/import.rs | 3 +- rs/moq-json/examples/telemetry.rs | 5 +- rs/moq-json/src/snapshot/consumer.rs | 8 +- rs/moq-json/src/snapshot/mod.rs | 9 +- rs/moq-json/src/window/consumer.rs | 12 +- rs/moq-json/src/window/mod.rs | 11 +- rs/moq-mux/src/catalog/msf/consumer.rs | 5 +- rs/moq-mux/src/catalog/producer.rs | 8 +- rs/moq-mux/src/container/fmp4/import_test.rs | 7 +- rs/moq-mux/src/container/fmp4/muxer.rs | 21 +- rs/moq-mux/src/container/ts/export.rs | 5 +- rs/moq-mux/src/container/ts/si.rs | 8 +- rs/moq-net/benches/group.rs | 9 +- rs/moq-net/benches/origin.rs | 8 +- rs/moq-net/src/ietf/subscriber.rs | 5 +- rs/moq-net/src/lite/subscriber/fills.rs | 2 +- rs/moq-net/src/model/resume.rs | 6 +- rs/moq-net/src/model/resume_model.rs | 7 +- rs/moq-net/src/model/track.rs | 424 +++--------------- rs/moq-net/tests/integration/drop_record.rs | 2 +- .../integration/settled_end_survives_abort.rs | 2 +- rs/moq-relay/tests/integration/quic_sim.rs | 7 +- rs/moq-rtmp/src/dial.rs | 1 - rs/moq-stats/src/produce.rs | 15 +- rs/moq-transcode/src/lib.rs | 12 +- rs/moq-transcode/src/rung.rs | 7 +- test/interop/clients/rust/hls.rs | 7 +- 40 files changed, 166 insertions(+), 630 deletions(-) delete mode 100644 quest/m2/outcome-enums/ordered-gaps.md diff --git a/quest/m2/outcome-enums/ordered-gaps.md b/quest/m2/outcome-enums/ordered-gaps.md deleted file mode 100644 index 6c016aabab4..00000000000 --- a/quest/m2/outcome-enums/ordered-gaps.md +++ /dev/null @@ -1,34 +0,0 @@ -# [S] An ordered track's next_group yields groups - -## Goal - -`track::Ordered::next_group` (and `poll_next_group`) yields group consumers -and skips the gaps itself, so no caller writes a `Gap => continue` arm. A new -`next_item` (and `poll_next_item`) yields `track::Item` for the one reader -that needs gaps in order: moq-mux's container reader. - -## Plan - -Decided 2026-11-18 (maintainer, /quest-plan): ✅ two methods (rejected: -keeping `Item` as the only return; replacing gaps with a counter, which -[unused-api/net](/quest/m2/unused-api/net.md)'s reader cannot use, since it -needs each gap's range in order). - -Every production caller skips `Item::Gap` today: libmoq, moq-ffi, moq-json -snapshot and window, moq-hls, moq-mux's TS export and MSF catalog, -moq-archive, moq-stats, and moq-net's benches -(`rg 'Item::Gap|Item::group'`). Tests and benches that write -`.and_then(Item::group)` read a gap as the end of the track; they move to -`next_group`. `Item::group` goes if nothing needs it after. - -Whichever lands second of this and [unused-api/net](/quest/m2/unused-api/net.md) -points the container reader at `next_item`. - -Public API: breaking in moq-net; callers of `next_group` that matched `Item` -drop the match, and the gap-reading one calls `next_item`. No JS or binding -change: js/net's `Ordered` already has `nextGroup` and `nextItem`, and moq-ffi -hides gaps. Wire: none. - -## Related - -- [moq-net's last pub items](/quest/m2/unused-api/net.md) - moves the container reader onto `Ordered`'s gaps diff --git a/quest/m2/unused-api/net.md b/quest/m2/unused-api/net.md index fafd832ccc3..2992efceac3 100644 --- a/quest/m2/unused-api/net.md +++ b/quest/m2/unused-api/net.md @@ -5,7 +5,7 @@ `track::Subscriber::next_in_range`, `is_skipped`, and `poll_start` are crate-private, and so is `Subscriber::with_range` if its last production caller can leave. Their one consumer is moq-mux's container reader, which -orders groups itself; `track::Ordered` reports a `Gap`, so the reader can +orders groups itself; `track::Ordered::next_item` reports a `Gap`, so the reader can move onto it. ## Plan @@ -71,15 +71,12 @@ Steps: - `origin::Consumer::covering` stays `pub`: moq.pro and moq-net's own `benches/origin.rs` call it. -The reader reads gaps through `Ordered::next_item` once -[ordered-gaps](/quest/m2/outcome-enums/ordered-gaps.md) lands, since -`next_group` then yields groups alone (decided 2026-11-18, maintainer, -/quest-plan); whichever lands second makes the switch. +The reader reads gaps through `Ordered::next_item`, since `next_group` +yields groups alone (decided 2026-11-18, maintainer, /quest-plan). Public API: breaking, removals only unless step 1 adds `Ordered` inputs. Wire: none. ## Related -- [Ordered gaps](/quest/m2/outcome-enums/ordered-gaps.md) - splits `Ordered` into `next_group` and the `next_item` this reader uses - [Browser audio holes](/quest/m2/audio-playout/browser-audio-hole-skip.md) - grading the browser counterpart, which already reads `Gap`s diff --git a/rs/libmoq/src/consume.rs b/rs/libmoq/src/consume.rs index 138ebba9454..6c4bc9b0d79 100644 --- a/rs/libmoq/src/consume.rs +++ b/rs/libmoq/src/consume.rs @@ -899,14 +899,11 @@ impl Consume { if Pin::new(&mut close).poll(&mut waiter.context()).is_ready() { return Poll::Ready(Ok(RawStep::Stop)); } - loop { - match ready!(track.poll_next_group(waiter))? { - Some(moq_net::track::Item::Group(group)) => return Poll::Ready(Ok(RawStep::Item(group))), - // The C API reports no gaps. - Some(moq_net::track::Item::Gap { .. }) => continue, - None => return Poll::Ready(Ok(RawStep::End)), - } - } + // The C API reports no gaps. + Poll::Ready(Ok(match ready!(track.poll_next_group(waiter))? { + Some(group) => RawStep::Item(group), + None => RawStep::End, + })) }) .await? { diff --git a/rs/moq-archive/src/consumer/tests.rs b/rs/moq-archive/src/consumer/tests.rs index ca76f4604f0..c0cc6530a21 100644 --- a/rs/moq-archive/src/consumer/tests.rs +++ b/rs/moq-archive/src/consumer/tests.rs @@ -158,15 +158,10 @@ fn from(start: u64) -> track::Range { /// The next group, past the gaps the read reports for what the archive never held. async fn group(reader: &mut track::Ordered) -> Option { - loop { - let item = timeout(Duration::from_secs(10), reader.next_group()) - .await - .expect("a group arrives") - .unwrap()?; - if let track::Item::Group(group) = item { - return Some(group); - } - } + timeout(Duration::from_secs(10), reader.next_group()) + .await + .expect("a group arrives") + .unwrap() } /// The next group's start, without waiting for it to end. @@ -244,7 +239,7 @@ async fn a_recording_round_trips() { let mut reader = subscribe(&broadcast, "video").await; for sequence in 0..6 { - let mut group = reader.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = reader.next_group().await.unwrap().unwrap(); assert_eq!(group.start, sequence); for index in 0..3 { let frame = group.read_frame().await.unwrap().unwrap(); @@ -468,7 +463,7 @@ async fn an_archive_without_markers_stays_open() { let (broadcast, _run) = serve(&archive.store).await; let mut reader = subscribe(&broadcast, "video").await; assert_eq!(next(&mut reader).await.unwrap(), (0, expected(true, 0, 0..1))); - let mut group = reader.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = reader.next_group().await.unwrap().unwrap(); assert!(group.read_frame().await.unwrap().is_some()); let pending = timeout(30 * REFRESH, group.read_frame()).await; assert!(pending.is_err(), "the newest group stays open"); @@ -484,7 +479,7 @@ async fn closing_the_broadcast_cancels_the_live_tracks() { let (broadcast, run) = serve(&archive.store).await; let mut reader = subscribe(&broadcast, "video").await; - let mut group = reader.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = reader.next_group().await.unwrap().unwrap(); assert!(group.read_frame().await.unwrap().is_some()); broadcast.close(); @@ -503,7 +498,7 @@ async fn a_gapped_continuation_aborts_the_open_group() { let (broadcast, run) = serve(&archive.store).await; let mut reader = subscribe(&broadcast, "video").await; - let mut group = reader.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = reader.next_group().await.unwrap().unwrap(); assert!(group.read_frame().await.unwrap().is_some()); // Frame 1 of group 0 is missing. @@ -526,7 +521,7 @@ async fn a_store_failure_aborts_the_served_tracks() { let (broadcast, run) = serve(&archive.store).await; let mut reader = subscribe(&broadcast, "video").await; - let mut group = reader.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = reader.next_group().await.unwrap().unwrap(); assert!(group.read_frame().await.unwrap().is_some()); archive.store.inner().fail_lists(); @@ -582,7 +577,7 @@ async fn a_completed_archive_ends_as_recorded() { let end = timeout(Duration::from_secs(10), reader.next_group()) .await .expect("the track ends"); - let end = end.map(|item| item.map(|item| item.group().expect("a group").start)); + let end = end.map(|group| group.map(|group| group.start)); assert!( matches!(end, Err(moq_net::Error::Stream(moq_net::StreamError::App(7)))), "{end:?}" @@ -735,9 +730,7 @@ async fn read_range(broadcast: &broadcast::Producer, track: &str, range: track:: let mut read = Vec::new(); while let Ok(group) = timeout(5 * REFRESH, reader.next_group()).await { match group.unwrap() { - Some(track::Item::Group(group)) => read.push(group.start), - // Nothing is stored below the first group, which the read reports as a gap. - Some(track::Item::Gap { .. }) => {} + Some(group) => read.push(group.start), None => break, } } diff --git a/rs/moq-archive/src/producer/track.rs b/rs/moq-archive/src/producer/track.rs index eaf83159bdb..fb216bc5ed5 100644 --- a/rs/moq-archive/src/producer/track.rs +++ b/rs/moq-archive/src/producer/track.rs @@ -8,7 +8,7 @@ use std::time::Duration; use bytes::Bytes; use kio::clock::Instant; -use moq_net::track::{Anchor, Delay, Item, Order, Position, Range, Subscription}; +use moq_net::track::{Anchor, Delay, Order, Position, Range, Subscription}; use moq_net::{StreamError, Timescale, group}; use object_store::path::Path; use object_store::{ObjectStore, ObjectStoreExt, PutMode, PutPayload}; @@ -219,11 +219,8 @@ impl Track { } None => { // A group the track gave up on is stored as the hole it leaves. - while let Poll::Ready(next) = ordered.poll_next_group(waiter) { - match next { - Ok(Some(Item::Gap { .. })) => continue, - next => return Poll::Ready(Event::Next(next.map(|item| item.and_then(Item::group)))), - } + if let Poll::Ready(next) = ordered.poll_next_group(waiter) { + return Poll::Ready(Event::Next(next)); } } } diff --git a/rs/moq-bench/src/connection.rs b/rs/moq-bench/src/connection.rs index c9a79cf184f..358c4ac6ab2 100644 --- a/rs/moq-bench/src/connection.rs +++ b/rs/moq-bench/src/connection.rs @@ -896,12 +896,7 @@ mod tests { .await .unwrap() .ordered(); - let mut group = sub - .next_group() - .await - .unwrap() - .and_then(moq_net::track::Item::group) - .expect("a group"); + let mut group = sub.next_group().await.unwrap().expect("a group"); let keyframe = group.read_frame().await.unwrap().expect("keyframe"); let header: serde_json::Value = serde_json::from_slice(&keyframe.payload).unwrap(); @@ -948,12 +943,7 @@ mod tests { .await .unwrap() .ordered(); - let mut group = sub - .next_group() - .await - .unwrap() - .and_then(moq_net::track::Item::group) - .expect("a group"); + let mut group = sub.next_group().await.unwrap().expect("a group"); // Just the keyframe, then the group ends. assert!(group.read_frame().await.unwrap().is_some(), "keyframe"); @@ -985,12 +975,7 @@ mod tests { tokio::time::advance(Duration::from_millis(250)).await; let mut sub = consumer.track(TRACK).unwrap().subscribe(None).await.unwrap().ordered(); - let mut group = sub - .next_group() - .await - .unwrap() - .and_then(moq_net::track::Item::group) - .expect("a group"); + let mut group = sub.next_group().await.unwrap().expect("a group"); let keyframe = group.read_frame().await.unwrap().expect("keyframe").payload; assert_eq!(keyframe.len(), 300, "keyframe padded to the rolled frame size"); @@ -1023,12 +1008,7 @@ mod tests { tokio::time::advance(Duration::from_millis(250)).await; let mut sub = consumer.track(TRACK).unwrap().subscribe(None).await.unwrap().ordered(); - let mut group = sub - .next_group() - .await - .unwrap() - .and_then(moq_net::track::Item::group) - .expect("a group"); + let mut group = sub.next_group().await.unwrap().expect("a group"); let keyframe = group.read_frame().await.unwrap().expect("keyframe").payload; assert!(keyframe.len() > 50, "header is the floor; no truncation to fit"); diff --git a/rs/moq-cli/src/main.rs b/rs/moq-cli/src/main.rs index d0d17423e17..ebde03e6d03 100644 --- a/rs/moq-cli/src/main.rs +++ b/rs/moq-cli/src/main.rs @@ -1421,7 +1421,7 @@ mod tests { .await .unwrap() .ordered(); - let mut group = track.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = track.next_group().await.unwrap().unwrap(); group.read_frame().await.unwrap().unwrap().payload }) .await diff --git a/rs/moq-ffi/src/consumer.rs b/rs/moq-ffi/src/consumer.rs index ab8b8f2c053..102068f58e1 100644 --- a/rs/moq-ffi/src/consumer.rs +++ b/rs/moq-ffi/src/consumer.rs @@ -512,7 +512,8 @@ impl TrackInner { waiter.waker().wake_by_ref(); return Poll::Ready(Ok(Some(group))); } - poll_group(&mut ordered.track, waiter).map(|r| r.map_err(Into::into)) + // The bindings report no gaps, so a group the track gave up on is passed over. + ordered.track.poll_next_group(waiter).map_err(Into::into) } Err(e) => Poll::Ready(Err(e)), } @@ -532,7 +533,7 @@ impl TrackInner { loop { let group = match &mut ordered.pending { Some(group) => group, - None => match ready!(poll_group(&mut ordered.track, waiter)) { + None => match ready!(ordered.track.poll_next_group(waiter)) { Ok(Some(group)) => ordered.pending.insert(group), Ok(None) => return Poll::Ready(Ok(None)), Err(err) => return Poll::Ready(Err(err.into())), @@ -749,18 +750,3 @@ impl MoqGroupConsumer { self.reads.cancel(); } } - -/// The next group of an ordered read. The bindings report no gaps, so a group the track -/// gave up on is passed over. -fn poll_group( - track: &mut moq_net::track::Ordered, - waiter: &kio::Waiter, -) -> Poll, moq_net::Error>> { - loop { - match ready!(track.poll_next_group(waiter))? { - Some(moq_net::track::Item::Group(group)) => return Poll::Ready(Ok(Some(group))), - Some(moq_net::track::Item::Gap { .. }) => continue, - None => return Poll::Ready(Ok(None)), - } - } -} diff --git a/rs/moq-ffi/src/media.rs b/rs/moq-ffi/src/media.rs index 084c4d840e6..83b79f03ba0 100644 --- a/rs/moq-ffi/src/media.rs +++ b/rs/moq-ffi/src/media.rs @@ -2231,11 +2231,7 @@ mod timebase_tests { .await .unwrap() .ordered(); - let mut group = loop { - if let Some(group) = catalogs.next_group().await.unwrap().unwrap().group() { - break group; - } - }; + let mut group = catalogs.next_group().await.unwrap().unwrap(); let stamp = group.read_frame().await.unwrap().unwrap().timestamp; // Catalogs published in the same millisecond, such as a rendition and its first estimate, // start a unit apart, since each starts its own group. diff --git a/rs/moq-gst/src/sink/imp.rs b/rs/moq-gst/src/sink/imp.rs index fdf10b9a140..489ccdb05d5 100644 --- a/rs/moq-gst/src/sink/imp.rs +++ b/rs/moq-gst/src/sink/imp.rs @@ -2076,7 +2076,6 @@ mod tests { .now_or_never() .expect("a group is ready") .unwrap() - .and_then(moq_net::track::Item::group) .expect("the resumed keyframe opens a group"); let frame = group .read_frame() diff --git a/rs/moq-gst/src/sink/pad.rs b/rs/moq-gst/src/sink/pad.rs index 45229505863..94ba2adb22f 100644 --- a/rs/moq-gst/src/sink/pad.rs +++ b/rs/moq-gst/src/sink/pad.rs @@ -2072,12 +2072,7 @@ mod tests { .expect("subscribe to the opaque track") .ordered(); - let mut group = subscriber - .next_group() - .await - .unwrap() - .and_then(moq_net::track::Item::group) - .expect("a first group"); + let mut group = subscriber.next_group().await.unwrap().expect("a first group"); let frame = group.read_frame().await.unwrap().expect("a frame in the first group"); assert_eq!( frame.payload.as_ref(), @@ -2094,12 +2089,7 @@ mod tests { "one buffer produces one group with one frame" ); - let mut group = subscriber - .next_group() - .await - .unwrap() - .and_then(moq_net::track::Item::group) - .expect("a second group"); + let mut group = subscriber.next_group().await.unwrap().expect("a second group"); let frame = group.read_frame().await.unwrap().expect("a frame in the second group"); assert_eq!(frame.payload.as_ref(), b"second"); assert_eq!( @@ -2205,12 +2195,7 @@ mod tests { .await .expect("subscribe to the opaque track") .ordered(); - let mut group = subscriber - .next_group() - .await - .unwrap() - .and_then(moq_net::track::Item::group) - .expect("a group"); + let mut group = subscriber.next_group().await.unwrap().expect("a group"); let frame = group.read_frame().await.unwrap().expect("a frame"); assert_eq!(frame.payload.as_ref(), b"no pts", "the unstamped buffer was published"); assert_eq!( diff --git a/rs/moq-hls/src/export/rendition.rs b/rs/moq-hls/src/export/rendition.rs index d2b39b595aa..85b0aa45f26 100644 --- a/rs/moq-hls/src/export/rendition.rs +++ b/rs/moq-hls/src/export/rendition.rs @@ -2415,10 +2415,9 @@ impl WatchMedia { } } let groups = self.groups.as_mut().expect("subscribed above"); + // A segment is listed from the groups that arrive, so one given up on is read past. match ready!(groups.poll_next_group(waiter))? { - Some(moq_net::track::Item::Group(group)) => self.step = Step::First(group), - // A segment is listed from the groups that arrive, so one given up on is read past. - Some(moq_net::track::Item::Gap { .. }) => {} + Some(group) => self.step = Step::First(group), None => match follow.latest.take() { Some((group, _, reach)) => self.step = Step::End(group, Some(reach)), None => { diff --git a/rs/moq-hls/src/import.rs b/rs/moq-hls/src/import.rs index 42b5efae0a1..cb38bb237bd 100644 --- a/rs/moq-hls/src/import.rs +++ b/rs/moq-hls/src/import.rs @@ -2420,8 +2420,7 @@ mod tests { let mut out = Vec::new(); loop { let mut group = match subscriber.poll_next_group(&kio::Waiter::noop()) { - Poll::Ready(Ok(Some(moq_net::track::Item::Group(group)))) => group, - Poll::Ready(Ok(Some(moq_net::track::Item::Gap { .. }))) => continue, + Poll::Ready(Ok(Some(group))) => group, Poll::Pending | Poll::Ready(Ok(None)) => break, Poll::Ready(Err(error)) => return (out, Some(error)), }; diff --git a/rs/moq-hls/tests/integration/import.rs b/rs/moq-hls/tests/integration/import.rs index bddfa2b8041..39643070f6f 100644 --- a/rs/moq-hls/tests/integration/import.rs +++ b/rs/moq-hls/tests/integration/import.rs @@ -45,8 +45,7 @@ fn groups(track: &mut moq_net::track::Ordered) -> Vec { let mut out = Vec::new(); loop { let mut group = match track.poll_next_group(&kio::Waiter::noop()) { - Poll::Ready(Ok(Some(moq_net::track::Item::Group(group)))) => group, - Poll::Ready(Ok(Some(moq_net::track::Item::Gap { .. }))) => continue, + Poll::Ready(Ok(Some(group))) => group, Poll::Pending | Poll::Ready(Ok(None)) => return out, Poll::Ready(Err(err)) => panic!("the imported track failed: {err}"), }; diff --git a/rs/moq-json/examples/telemetry.rs b/rs/moq-json/examples/telemetry.rs index e60fd3c4e4d..d9badd3cf2b 100644 --- a/rs/moq-json/examples/telemetry.rs +++ b/rs/moq-json/examples/telemetry.rs @@ -109,10 +109,7 @@ fn frame_bytes(config: snapshot::Config, ticks: u64) -> usize { let waiter = kio::Waiter::noop(); let mut total = 0; let mut track = consumer.ordered(); - while let Poll::Ready(Ok(Some(item))) = track.poll_next_group(&waiter) { - let moq_net::track::Item::Group(mut group) = item else { - continue; - }; + while let Poll::Ready(Ok(Some(mut group))) = track.poll_next_group(&waiter) { while let Poll::Ready(Ok(Some(frame))) = group.poll_read_frame(&waiter) { total += frame.payload.len(); } diff --git a/rs/moq-json/src/snapshot/consumer.rs b/rs/moq-json/src/snapshot/consumer.rs index b8560bc9883..a9c45225409 100644 --- a/rs/moq-json/src/snapshot/consumer.rs +++ b/rs/moq-json/src/snapshot/consumer.rs @@ -209,13 +209,7 @@ impl Track { unreachable!("resolved above") }; // A snapshot is the newest group's content, so a group given up on changes nothing. - loop { - match std::task::ready!(track.poll_next_group(waiter))? { - Some(moq_net::track::Item::Group(group)) => return Poll::Ready(Ok(Some(group))), - Some(moq_net::track::Item::Gap { .. }) => continue, - None => return Poll::Ready(Ok(None)), - } - } + track.poll_next_group(waiter) } } diff --git a/rs/moq-json/src/snapshot/mod.rs b/rs/moq-json/src/snapshot/mod.rs index 05dfc56b5da..ea9be1f32dc 100644 --- a/rs/moq-json/src/snapshot/mod.rs +++ b/rs/moq-json/src/snapshot/mod.rs @@ -1110,13 +1110,8 @@ mod test { )); let waiter = kio::Waiter::noop(); - let mut group = loop { - let Poll::Ready(Ok(Some(item))) = subscriber.poll_next_group(&waiter) else { - panic!("the group was published, so a subscriber sees it"); - }; - if let Some(group) = item.group() { - break group; - } + let Poll::Ready(Ok(Some(mut group))) = subscriber.poll_next_group(&waiter) else { + panic!("the group was published, so a subscriber sees it"); }; assert!( matches!(group.poll_read_frame(&waiter), Poll::Ready(Ok(None))), diff --git a/rs/moq-json/src/window/consumer.rs b/rs/moq-json/src/window/consumer.rs index c636081af56..6b2841a915c 100644 --- a/rs/moq-json/src/window/consumer.rs +++ b/rs/moq-json/src/window/consumer.rs @@ -1,6 +1,6 @@ //! Consuming a window from a track: a [`Decoder`] plus the track it reads from. -use std::task::Poll; +use std::task::{Poll, ready}; use serde::de::DeserializeOwned; @@ -72,16 +72,14 @@ impl Consumer { } let Some(group) = &mut self.group else { - match self.track.poll_next_group(waiter)? { - Poll::Ready(Some(moq_net::track::Item::Group(group))) => { + // The window advances by index, so a group given up on is read past. + match ready!(self.track.poll_next_group(waiter)?) { + Some(group) => { self.codec = Some(Codec::new()); self.group = Some(group); continue; } - // The window advances by index, so a group given up on is read past. - Poll::Ready(Some(moq_net::track::Item::Gap { .. })) => continue, - Poll::Ready(None) => return Poll::Ready(Ok(None)), - Poll::Pending => return Poll::Pending, + None => return Poll::Ready(Ok(None)), } }; diff --git a/rs/moq-json/src/window/mod.rs b/rs/moq-json/src/window/mod.rs index b601fa715d3..a6ca2f178e2 100644 --- a/rs/moq-json/src/window/mod.rs +++ b/rs/moq-json/src/window/mod.rs @@ -901,13 +901,8 @@ mod test { assert!(producer.window().is_empty()); let waiter = kio::Waiter::noop(); - let mut group = loop { - let Poll::Ready(Ok(Some(item))) = subscriber.poll_next_group(&waiter) else { - panic!("the rejected group's header was published"); - }; - if let Some(group) = item.group() { - break group; - } + let Poll::Ready(Ok(Some(mut group))) = subscriber.poll_next_group(&waiter) else { + panic!("the rejected group's header was published"); }; assert!(matches!(group.poll_read_frame(&waiter), Poll::Ready(Ok(None)))); } @@ -967,7 +962,7 @@ mod test { let _finished = producer.clone().finish().unwrap(); let waiter = kio::Waiter::noop(); - let Poll::Ready(Ok(Some(moq_net::track::Item::Group(mut group)))) = subscriber.poll_next_group(&waiter) else { + let Poll::Ready(Ok(Some(mut group))) = subscriber.poll_next_group(&waiter) else { panic!("expected the window group"); }; while let Poll::Ready(Ok(Some(_))) = group.poll_read_frame(&waiter) {} diff --git a/rs/moq-mux/src/catalog/msf/consumer.rs b/rs/moq-mux/src/catalog/msf/consumer.rs index 29715ac6b4c..33016547fa0 100644 --- a/rs/moq-mux/src/catalog/msf/consumer.rs +++ b/rs/moq-mux/src/catalog/msf/consumer.rs @@ -42,10 +42,9 @@ impl Consumer { // Drain pending groups, keeping only the newest. Remember whether the track is done // so we can distinguish "more groups may arrive" from "no more groups, ever". let track_finished = loop { + // Only the newest catalog matters, so a group given up on changes nothing. match self.track.poll_next_group(waiter)? { - Poll::Ready(Some(moq_net::track::Item::Group(group))) => self.group = Some(group), - // Only the newest catalog matters, so a group given up on changes nothing. - Poll::Ready(Some(moq_net::track::Item::Gap { .. })) => {} + Poll::Ready(Some(group)) => self.group = Some(group), Poll::Ready(None) => break true, Poll::Pending => break false, } diff --git a/rs/moq-mux/src/catalog/producer.rs b/rs/moq-mux/src/catalog/producer.rs index 9ecd387fa38..17fb3394ce0 100644 --- a/rs/moq-mux/src/catalog/producer.rs +++ b/rs/moq-mux/src/catalog/producer.rs @@ -1542,7 +1542,7 @@ mod test { .await .unwrap() .ordered(); - let mut group = track.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = track.next_group().await.unwrap().unwrap(); let frame = group.read_frame().await.unwrap().unwrap(); let wire: serde_json::Value = serde_json::from_slice(&frame.payload).unwrap(); assert_eq!(wire["tracks"][0]["namespace"], expected); @@ -2343,11 +2343,7 @@ mod test { home.block_on(async { for (name, mut track) in readers { let (mut stamps, mut starts) = (Vec::new(), Vec::::new()); - while let Some(item) = track.next_group().await.unwrap() { - // Nothing exists below the first group, which the read reports as a gap. - let moq_net::track::Item::Group(mut group) = item else { - continue; - }; + while let Some(mut group) = track.next_group().await.unwrap() { let first = stamps.len(); while let Some(frame) = group.read_frame().await.unwrap() { stamps.push(frame.timestamp.as_micros().unwrap()); diff --git a/rs/moq-mux/src/container/fmp4/import_test.rs b/rs/moq-mux/src/container/fmp4/import_test.rs index 73dede8aba7..ae90d4a8671 100644 --- a/rs/moq-mux/src/container/fmp4/import_test.rs +++ b/rs/moq-mux/src/container/fmp4/import_test.rs @@ -1675,11 +1675,8 @@ async fn starts(consumer: &moq_net::broadcast::Consumer, track: &str) -> Vec { + // SI carries the last snapshot over a group given up on. + Poll::Ready(Ok(Some(group))) => { self.pending = Some((group, Default::default(), Timestamp::ZERO)); } - // SI carries the last snapshot over a group given up on. - Poll::Ready(Ok(Some(moq_net::track::Item::Gap { .. }))) => {} Poll::Ready(Ok(None)) => { ended = true; break; diff --git a/rs/moq-mux/src/container/ts/si.rs b/rs/moq-mux/src/container/ts/si.rs index c0aca90af28..d27f9d0834e 100644 --- a/rs/moq-mux/src/container/ts/si.rs +++ b/rs/moq-mux/src/container/ts/si.rs @@ -823,11 +823,9 @@ mod tests { .ordered(); let waiter = kio::Waiter::noop(); let mut read = Vec::new(); - while let std::task::Poll::Ready(Ok(Some(item))) = reader.poll_next_group(&waiter) { - // A group given up on is a gap, which reads no group. - if let Some(group) = item.group() { - read.push(group.start); - } + // A group given up on is passed over. + while let std::task::Poll::Ready(Ok(Some(group))) = reader.poll_next_group(&waiter) { + read.push(group.start); } assert_eq!(read, expected); } diff --git a/rs/moq-net/benches/group.rs b/rs/moq-net/benches/group.rs index b2ced6deae8..05379f0d2d8 100644 --- a/rs/moq-net/benches/group.rs +++ b/rs/moq-net/benches/group.rs @@ -319,14 +319,7 @@ fn bench_track_recv(c: &mut Criterion) { }, |(ctx, mut subscriber)| { for _ in 0..n { - let group = subscriber - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap(); + let group = subscriber.next_group().now_or_never().unwrap().unwrap().unwrap(); black_box(group); } (ctx, subscriber) diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index 637216c9407..1fac9133935 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -1705,13 +1705,7 @@ impl ResumeReader { fn poll_group(&mut self, waiter: &kio::Waiter) -> Poll>> { match self { Self::Arrival(reader) => reader.poll_recv_group(waiter), - Self::Key(reader) => loop { - match std::task::ready!(reader.poll_next_group(waiter))? { - Some(track::Item::Group(group)) => return Poll::Ready(Ok(Some(group))), - Some(track::Item::Gap { .. }) => continue, - None => return Poll::Ready(Ok(None)), - } - }, + Self::Key(reader) => reader.poll_next_group(waiter), } } } diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index d696d623abe..d7f1c7036ca 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -16627,13 +16627,12 @@ mod stitch_tests { let mut next = h.stream().await; h.subscriber.clone().recv_group(&mut next).await.expect("next group"); // The refused group comes back as a gap, then the next group. - let Poll::Ready(Ok(Some(track::Item::Gap { range, .. }))) = ordered.poll_next_group(&kio::Waiter::noop()) - else { + let Poll::Ready(Ok(Some(track::Item::Gap { range, .. }))) = ordered.poll_next_item(&kio::Waiter::noop()) else { panic!("the refused group is not reported"); }; assert!(range.contains(&KEY), "{range:?}"); let group = match ordered.poll_next_group(&kio::Waiter::noop()) { - Poll::Ready(Ok(Some(track::Item::Group(group)))) => group, + Poll::Ready(Ok(Some(group))) => group, Poll::Ready(_) => panic!("no next group"), Poll::Pending => panic!("the ordered reader still waits on the refused group"), }; diff --git a/rs/moq-net/src/lite/subscriber/fills.rs b/rs/moq-net/src/lite/subscriber/fills.rs index 8eda571c896..df128d291b4 100644 --- a/rs/moq-net/src/lite/subscriber/fills.rs +++ b/rs/moq-net/src/lite/subscriber/fills.rs @@ -883,7 +883,7 @@ mod tests { group.finish().unwrap(); } for key in 0..3 { - let Poll::Ready(Ok(Some(track::Item::Group(group)))) = reader.poll_next_group(&waiter) else { + let Poll::Ready(Ok(Some(group))) = reader.poll_next_group(&waiter) else { panic!("group {key} was delivered"); }; assert_eq!(group.start, key); diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index d9bf17d5ef8..343ad8754fb 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -5366,7 +5366,7 @@ mod test { let waiter = kio::Waiter::noop(); let read = |sub: &mut track::Ordered| -> Vec { let mut items = Vec::new(); - while let Poll::Ready(Ok(Some(item))) = sub.poll_next_group(&waiter) { + while let Poll::Ready(Ok(Some(item))) = sub.poll_next_item(&waiter) { items.push(match item { track::Item::Group(group) => format!("group {}", group.start), track::Item::Gap { range, error } => format!("gap {range:?} ({error})"), @@ -5397,7 +5397,7 @@ mod test { let waiter = kio::Waiter::noop(); let read = |sub: &mut track::Ordered| -> Vec { let mut items = Vec::new(); - while let Poll::Ready(Ok(Some(item))) = sub.poll_next_group(&waiter) { + while let Poll::Ready(Ok(Some(item))) = sub.poll_next_item(&waiter) { items.push(match item { track::Item::Group(group) => format!("group {}", group.start), track::Item::Gap { range, error } => format!("gap {range:?} ({error})"), @@ -5424,7 +5424,7 @@ mod test { let waiter = kio::Waiter::noop(); let read = |sub: &mut track::Ordered| -> Vec { let mut items = Vec::new(); - while let Poll::Ready(Ok(Some(item))) = sub.poll_next_group(&waiter) { + while let Poll::Ready(Ok(Some(item))) = sub.poll_next_item(&waiter) { items.push(match item { track::Item::Group(group) => format!("group {}", group.start), track::Item::Gap { range, error } => format!("gap {range:?} ({error})"), diff --git a/rs/moq-net/src/model/resume_model.rs b/rs/moq-net/src/model/resume_model.rs index 52d2f716966..dc0f1b46a9a 100644 --- a/rs/moq-net/src/model/resume_model.rs +++ b/rs/moq-net/src/model/resume_model.rs @@ -667,13 +667,16 @@ impl Model { while reader.end.is_none() { let polled = match reader.cursor.as_mut().unwrap() { Cursor::Arrival(sub) => sub.poll_recv_group(&waiter), - Cursor::Ordered(sub) => match sub.poll_next_group(&waiter) { + Cursor::Ordered(sub) => match sub.poll_next_item(&waiter) { // An ordered read reports its drops in turn. Poll::Ready(Ok(Some(track::Item::Gap { range, error }))) => { reader.report_drop(index, range, &format!("{error:?}"))?; continue; } - polled => polled.map(|res| res.map(|item| item.map(|item| item.group().expect("a group")))), + Poll::Ready(Ok(Some(track::Item::Group(group)))) => Poll::Ready(Ok(Some(group))), + Poll::Ready(Ok(None)) => Poll::Ready(Ok(None)), + Poll::Ready(Err(err)) => Poll::Ready(Err(err)), + Poll::Pending => Poll::Pending, }, }; match polled { diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index d30b32c485c..a2cdc840a04 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -11304,7 +11304,7 @@ impl Drop for Ticket { /// Created by [`Subscriber::ordered`], which consumes the subscriber, so a track is read /// one way or the other and never both. Every group it returns has a higher key /// than the last, so a late arrival (network reordering, or a gap the cache filled after -/// the fact) is reported as a [gap](Item::Gap) rather than delivered out of turn. +/// the fact) is skipped, or reported as a [gap](Item::Gap), rather than delivered out of turn. /// /// # Age and skipping /// @@ -11335,7 +11335,7 @@ impl Drop for Ticket { /// ordered moq-transport FETCH. A moq-transport SUBSCRIBE signals no gaps, so there a group /// lost in transit can hold the ordered reader at its hole until the track ends. /// -/// A group this reader gives up on is not lost silently: it comes back as an +/// A group this reader gives up on is not lost silently: [`Self::poll_next_item`] returns it as an /// [`Item::Gap`], so a reader that paces on what was sent counts the loss instead of /// waiting for a group that will never come. That is every group the publisher or a relay /// dropped, the transport evicted, the budget aged out, a fetch could not find, or that @@ -11364,7 +11364,7 @@ pub struct Ordered { idle: Option>, } -/// What an [`Ordered`] read returns next. +/// What [`Ordered::poll_next_item`] returns next. pub enum Item { /// A group, with a higher key than any group returned before. Group(group::Consumer), @@ -11377,16 +11377,6 @@ pub enum Item { }, } -impl Item { - /// The group, or `None` for a gap. - pub fn group(self) -> Option { - match self { - Self::Group(group) => Some(group), - Self::Gap { .. } => None, - } - } -} - impl Ordered { /// The track's [`Info`], resolved when the subscription was established. pub fn info(&self) -> &Info { @@ -11403,6 +11393,22 @@ impl Ordered { self.inner.broadcast() } + /// The next group with a higher key than any previously returned, passing over any gap + /// [`Self::poll_next_item`] would report below it. + /// + /// Returns `Ok(Some(group))` when a group is available, and otherwise ends as + /// [`Self::poll_next_item`] does. + #[cfg_attr(feature = "async", kio::wrapper)] + pub fn poll_next_group(&mut self, waiter: &kio::Waiter) -> Poll>> { + loop { + match ready!(self.poll_next_item(waiter)?) { + Some(Item::Group(group)) => return Poll::Ready(Ok(Some(group))), + Some(Item::Gap { .. }) => continue, + None => return Poll::Ready(Ok(None)), + } + } + } + /// The next group with a higher key than any previously returned, or a gap this reader /// gave up on (see [Gaps](Self#gaps)). /// @@ -11418,7 +11424,7 @@ impl Ordered { /// or the ranges are read, or the error when the track has been aborted short of its end. /// Every gap is returned before the end, even a clean one. #[cfg_attr(feature = "async", kio::wrapper)] - pub fn poll_next_group(&mut self, waiter: &kio::Waiter) -> Poll>> { + pub fn poll_next_item(&mut self, waiter: &kio::Waiter) -> Poll>> { if idle::Idle::parked(&self.idle, (), waiter) { return Poll::Pending; } @@ -12669,7 +12675,7 @@ mod test { #[cfg(feature = "async")] fn items(ordered: &mut Ordered) -> Vec { let mut items = Vec::new(); - while let Some(next) = ordered.next_group().now_or_never() { + while let Some(next) = ordered.next_item().now_or_never() { match next { Ok(Some(Item::Group(group))) => items.push(format!("group {}", group.start)), Ok(Some(Item::Gap { range, error })) => items.push(format!("gap {range:?} ({error})")), @@ -12685,10 +12691,6 @@ mod test { } /// An ordered read that expects no gap, as the groups it returns. - fn groups_only(polled: Poll>>) -> Poll>> { - polled.map(|res| res.map(|item| item.map(|item| item.group().expect("a group, not a gap")))) - } - fn read_groups( mut next: impl FnMut(&kio::Waiter) -> Poll>>, ) -> Vec<(u64, Vec)> { @@ -12728,7 +12730,7 @@ mod test { let mut arrival = bounded(); assert_eq!(read_groups(|waiter| arrival.poll_recv_group(waiter)), want); let mut ordered = bounded().ordered(); - assert_eq!(read_groups(|waiter| groups_only(ordered.poll_next_group(waiter))), want); + assert_eq!(read_groups(|waiter| ordered.poll_next_group(waiter)), want); } /// A group missing its head is never served short: reading it is [`Error::Lagged`], @@ -16512,10 +16514,8 @@ mod test { #[cfg(feature = "async")] fn drain_ordered(subscriber: &mut Ordered) -> Vec { let mut keys = Vec::new(); - while let Some(Ok(Some(item))) = subscriber.next_group().now_or_never() { - if let Item::Group(group) = item { - keys.push(group.start); - } + while let Some(Ok(Some(group))) = subscriber.next_group().now_or_never() { + keys.push(group.start); } keys } @@ -17772,7 +17772,7 @@ mod test { } let _producer = producer.finish().unwrap(); for key in 0..3 { - let Poll::Ready(Ok(Some(Item::Group(group)))) = ordered.poll_next_group(&kio::Waiter::noop()) else { + let Poll::Ready(Ok(Some(Item::Group(group)))) = ordered.poll_next_item(&kio::Waiter::noop()) else { panic!("group {key}, given_up={given_up}") }; assert_eq!(group.start, key); @@ -17783,7 +17783,7 @@ mod test { } // The group given up is reported, then the read ends. if given_up { - let Poll::Ready(Ok(Some(Item::Gap { range, error }))) = ordered.poll_next_group(&kio::Waiter::noop()) + let Poll::Ready(Ok(Some(Item::Gap { range, error }))) = ordered.poll_next_item(&kio::Waiter::noop()) else { panic!("the given up group is reported") }; @@ -17847,23 +17847,9 @@ mod test { late.write_frame(late.key_time(), &b"late"[..]).unwrap(); let late = late.finish().unwrap(); assert_eq!(late.frame_count(), 1); - let first = ordered - .next_group() - .now_or_never() - .expect("group 0") - .unwrap() - .unwrap() - .group() - .unwrap(); + let first = ordered.next_group().now_or_never().expect("group 0").unwrap().unwrap(); assert_eq!(first.start, 0); - let second = ordered - .next_group() - .now_or_never() - .expect("group 1") - .unwrap() - .unwrap() - .group() - .unwrap(); + let second = ordered.next_group().now_or_never().expect("group 1").unwrap().unwrap(); assert_eq!(second.start, 1); let done = ordered.next_group().now_or_never().expect("end").unwrap(); assert!(done.is_none(), "the finished track ends after its late group"); @@ -18079,7 +18065,7 @@ mod test { let mut ordered = producer.subscribe(replay().with_range(0..)).ordered(); for key in 0..2 { assert_eq!(arrival.assert_group().start, key); - assert_eq!(ordered.next_group().await.unwrap().unwrap().group().unwrap().start, key); + assert_eq!(ordered.next_group().await.unwrap().unwrap().start, key); } assert!(matches!(arrival.recv_group().await, Err(Error::App(7)))); assert!(matches!(ordered.next_group().await, Err(Error::App(7)))); @@ -18117,7 +18103,7 @@ mod test { let mut reader = producer.subscribe(replay().with_range(0..)).ordered(); let _finished = producer.clone().fail(Error::App(7)).unwrap(); for key in 0..3 { - assert_eq!(reader.next_group().await.unwrap().unwrap().group().unwrap().start, key); + assert_eq!(reader.next_group().await.unwrap().unwrap().start, key); } assert!(matches!(reader.next_group().await, Err(Error::App(7)))); assert!(matches!(producer.append_next(), Err(Error::Closed))); @@ -18198,11 +18184,11 @@ mod test { // The last group's own stream remains open independently of the track end. assert_eq!(arrival.assert_group().start, 2); // They are reported as one gap, since nothing was produced below the group. - let Some(Item::Gap { range, .. }) = ordered.next_group().await.unwrap() else { + let Some(Item::Gap { range, .. }) = ordered.next_item().await.unwrap() else { panic!("the missing groups are reported") }; assert_eq!(range, 0..2); - assert_eq!(ordered.next_group().await.unwrap().unwrap().group().unwrap().start, 2); + assert_eq!(ordered.next_group().await.unwrap().unwrap().start, 2); assert!(arrival.recv_group().now_or_never().unwrap().unwrap().is_none()); assert!(ordered.next_group().now_or_never().unwrap().unwrap().is_none()); @@ -18212,7 +18198,7 @@ mod test { arrival.recv_group().now_or_never().unwrap(), Err(Error::Timeout) )); - let next = ordered.next_group().now_or_never().unwrap(); + let next = ordered.next_item().now_or_never().unwrap(); assert!( matches!(next, Err(Error::Timeout)), "{:?}", @@ -18836,7 +18822,7 @@ mod test { .next_group() .now_or_never() .expect("should not block") - .map(|item| item.map(|item| item.group().expect("a group").start)); + .map(|item| item.map(|item| item.start)); assert!(matches!(res, Err(Error::Timeout)), "expected the abort, got {res:?}"); } @@ -18967,7 +18953,7 @@ mod test { .next_group() .now_or_never() .expect("should not block") - .map(|item| item.map(|item| item.group().expect("a group").start)); + .map(|item| item.map(|item| item.start)); assert!(matches!(end, Ok(None)), "expected the clean end, got {end:?}"); } @@ -18995,7 +18981,7 @@ mod test { .next_group() .now_or_never() .expect("should not block") - .map(|item| item.map(|item| item.group().expect("a group").start)); + .map(|item| item.map(|item| item.start)); assert!( matches!(end, Ok(None)), "capped at the end: expected the clean end, got {end:?}" @@ -19019,7 +19005,7 @@ mod test { .next_group() .now_or_never() .expect("should not block") - .map(|item| item.map(|item| item.group().expect("a group").start)); + .map(|item| item.map(|item| item.start)); assert!( matches!(end, Ok(None)), "gap below the cap: expected the clean end, got {end:?}" @@ -19853,7 +19839,7 @@ mod test { // A group handed out and then cut is read as the failure it is, never reported twice. let cut = producer.create_group(group::Info { start: 7 }).unwrap(); - let Poll::Ready(Ok(Some(Item::Group(read)))) = ordered.poll_next_group(&kio::Waiter::noop()) else { + let Poll::Ready(Ok(Some(Item::Group(read)))) = ordered.poll_next_item(&kio::Waiter::noop()) else { panic!("group 7 is ready") }; assert_eq!(read.start, 7); @@ -19999,7 +19985,7 @@ mod test { put(&producer, 2, None); producer.drop_groups(0..2, StreamError::DeliveryTimeout); producer.drop_groups(3..6, StreamError::DeliveryTimeout); - let first = ordered.next_group().now_or_never().expect("ready").unwrap().unwrap(); + let first = ordered.next_item().now_or_never().expect("ready").unwrap().unwrap(); assert!(matches!(first, Item::Gap { range, .. } if range == (0..2))); ordered.set_range(4..5); assert_eq!(items(&mut ordered), ["gap 4..5 (delivery timeout)", "pending"]); @@ -20074,7 +20060,7 @@ mod test { put(&producer, 2, None); producer.drop_groups(0..2, StreamError::DeliveryTimeout); producer.drop_groups(3..6, StreamError::DeliveryTimeout); - let first = ordered.next_group().now_or_never().expect("ready").unwrap().unwrap(); + let first = ordered.next_item().now_or_never().expect("ready").unwrap().unwrap(); assert!(matches!(first, Item::Gap { range, .. } if range == (0..2))); ordered.set_range(..2); assert_eq!( @@ -20094,7 +20080,7 @@ mod test { put(&producer, 2, None); put(&producer, 3, None); producer.drop_groups(0..2, StreamError::DeliveryTimeout); - let first = ordered.next_group().now_or_never().expect("ready").unwrap().unwrap(); + let first = ordered.next_item().now_or_never().expect("ready").unwrap().unwrap(); assert!(matches!(first, Item::Gap { range, .. } if range == (0..2))); ordered.set_range(3..); assert_eq!( @@ -20114,7 +20100,7 @@ mod test { put(&producer, 2, None); producer.drop_groups(0..2, StreamError::DeliveryTimeout); producer.drop_groups(3..6, StreamError::DeliveryTimeout); - let first = ordered.next_group().now_or_never().expect("ready").unwrap().unwrap(); + let first = ordered.next_item().now_or_never().expect("ready").unwrap().unwrap(); assert!(matches!(first, Item::Gap { range, .. } if range == (0..2))); ordered.set_range(..4); assert_eq!( @@ -20180,9 +20166,7 @@ mod test { .now_or_never() .expect("should not block") .expect("would have errored") - .expect("track should not be closed") - .group() - .expect("a group"); + .expect("track should not be closed"); assert_eq!(group.start, 5); // Seq 3 arrives late, skipped because 3 <= 5. @@ -20230,9 +20214,7 @@ mod test { .now_or_never() .expect("should not block") .expect("would have errored") - .expect("track should not be closed") - .group() - .expect("a group"); + .expect("track should not be closed"); assert_eq!(group.start, 3); let group = consumer @@ -20240,9 +20222,7 @@ mod test { .now_or_never() .expect("should not block") .expect("would have errored") - .expect("track should not be closed") - .group() - .expect("a group"); + .expect("track should not be closed"); assert_eq!(group.start, 5); } @@ -20439,9 +20419,7 @@ mod test { .now_or_never() .expect("should not block") .expect("would have errored") - .expect("track should not be closed") - .group() - .expect("a group"); + .expect("track should not be closed"); assert_eq!(group.start, 3); // The plain handle walks arrivals, so it still starts at seq 5. @@ -20465,42 +20443,9 @@ mod test { consumer.set_range(..3); // Groups 0, 1, 2 are within the cap. - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 0 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 1 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 2 - ); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 0); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 1); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 2); // Group 3 is beyond the cap: next_group parks even though cached groups exist. assert!( @@ -20524,86 +20469,20 @@ mod test { } consumer.set_range(..2); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 0 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 1 - ); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 0); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 1); assert!(consumer.next_group().now_or_never().is_none(), "capped at 2"); // Raise the cap; previously-blocked cached groups become available again. consumer.set_range(..5); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 2 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 3 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 4 - ); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 2); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 3); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 4); assert!(consumer.next_group().now_or_never().is_none(), "capped at 5"); // Remove the cap; everything remaining flows. consumer.set_range(..); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 5 - ); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 5); assert!(consumer.next_group().now_or_never().is_none(), "no more groups"); } @@ -20622,42 +20501,9 @@ mod test { } // Drain everything with no cap. - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 0 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 1 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 2 - ); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 0); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 1); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 2); // Lower the cap below the cursor. New groups beyond the cap are blocked. consumer.set_range(..2); @@ -20678,30 +20524,8 @@ mod test { // Restoring the cap to no-limit (or any value >= cursor) releases them. consumer.set_range(..); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 3 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 4 - ); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 3); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 4); } #[test] @@ -20741,71 +20565,16 @@ mod test { .unwrap(); // next_group walks in key order through everything <= cap. - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 2 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 3 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 4 - ); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 5 - ); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 2); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 3); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 4); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 5); // Now blocked: 8 is still beyond the cap. assert!(consumer.next_group().now_or_never().is_none()); // Raise the cap; cached seq 8 is finally served. consumer.set_range(..11); - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 8 - ); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 8); } /// `recv_group` (arrival order) honors the `end_at` cap like `next_group`: a group @@ -21063,26 +20832,8 @@ mod test { group.finish().unwrap(); } - assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, - 0 - ); - let mut last = consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap(); + assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 0); + let mut last = consumer.next_group().now_or_never().unwrap().unwrap().unwrap(); assert_eq!(last.start, 1); last = last.with_range(..end.frame); assert_eq!( @@ -21123,15 +20874,7 @@ mod test { .unwrap(); assert!(matches!(producer.append_next(), Err(Error::BoundsExceeded(_)))); assert_eq!( - consumer - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap() - .start, + consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, u64::MAX - 1 ); // The track's end lands on the reserved key. @@ -21771,14 +21514,7 @@ mod test { assert_eq!(cut.start, 0); assert!(matches!(cut.with_range(200..).read_frame().await, Err(Error::App(5)))); arrival.assert_no_group(); - let cut = ordered - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap(); + let cut = ordered.next_group().now_or_never().unwrap().unwrap().unwrap(); assert_eq!(cut.start, 0); assert!(matches!(cut.with_range(200..).read_frame().await, Err(Error::App(5)))); assert!( @@ -22233,7 +21969,7 @@ mod test { let mut sub = producer.subscribe(replay().with_range(0..2)).ordered(); let reading = kio::clock::sim::spawn(async move { let mut read = Vec::new(); - while let Some(item) = sub.next_group().await.unwrap() { + while let Some(item) = sub.next_item().await.unwrap() { read.push(match item { Item::Group(group) => format!("group {}", group.start), Item::Gap { range, .. } => format!("gap {range:?}"), @@ -25769,7 +25505,7 @@ mod test { write_filled(fill.accept(key, None), key); served.push(key); while let Poll::Ready(Ok(Some(item))) = ordered.poll_next_group(&waiter) { - read.push(item.group().expect("a group").start); + read.push(item.start); } } assert_eq!(served, [3, 2, 1, 0]); @@ -28195,14 +27931,7 @@ mod test { assert_eq!(arrival.assert_group().start, 1); assert!(matches!(arrival.recv_group().now_or_never(), Some(Ok(None)))); - let mut first = ordered - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap(); + let mut first = ordered.next_group().now_or_never().unwrap().unwrap().unwrap(); assert_eq!(first.start, 0); assert!(matches!(first.read_frame().now_or_never(), Some(Err(Error::App(5))))); assert_eq!(drain_ordered(&mut ordered), [1]); @@ -28306,14 +28035,7 @@ mod test { assert_eq!(drain_ordered(&mut ordered), [0]); ordered = ordered.with_range(..); - let mut reoffered = ordered - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap(); + let mut reoffered = ordered.next_group().now_or_never().unwrap().unwrap().unwrap(); assert_eq!(reoffered.start, 1); assert!(matches!( reoffered.read_frame().now_or_never(), diff --git a/rs/moq-net/tests/integration/drop_record.rs b/rs/moq-net/tests/integration/drop_record.rs index 6e54433e259..bac43090c65 100644 --- a/rs/moq-net/tests/integration/drop_record.rs +++ b/rs/moq-net/tests/integration/drop_record.rs @@ -506,7 +506,7 @@ async fn an_ordered_reader_is_told_of_every_group_the_origin_evicted() { let mut got = BTreeSet::new(); let mut told = BTreeSet::new(); - while let Some(item) = kio::clock::timeout(TIMEOUT, reader.next_group()) + while let Some(item) = kio::clock::timeout(TIMEOUT, reader.next_item()) .await .expect("the reader stalled on a group that will not come") .expect("the reader runs on") diff --git a/rs/moq-net/tests/integration/settled_end_survives_abort.rs b/rs/moq-net/tests/integration/settled_end_survives_abort.rs index 539883cebe3..826149ef5b5 100644 --- a/rs/moq-net/tests/integration/settled_end_survives_abort.rs +++ b/rs/moq-net/tests/integration/settled_end_survives_abort.rs @@ -59,7 +59,7 @@ async fn round(abort: bool, ordered: bool) -> (Vec, Option) { let mut consumer = consumer.ordered(); loop { match consumer.next_group().await { - Ok(Some(item)) => got.push(item.group().expect("a group").start), + Ok(Some(item)) => got.push(item.start), Ok(None) => return (got, None), Err(err) => return (got, Some(err)), } diff --git a/rs/moq-relay/tests/integration/quic_sim.rs b/rs/moq-relay/tests/integration/quic_sim.rs index 05a2a7ce014..f130593f1fc 100644 --- a/rs/moq-relay/tests/integration/quic_sim.rs +++ b/rs/moq-relay/tests/integration/quic_sim.rs @@ -293,12 +293,7 @@ fn a_group_carries_a_bulk_transfer_losslessly() { .await .unwrap(); let mut ordered = consumer.ordered(); - let mut group = ordered - .next_group() - .await - .unwrap() - .and_then(moq_net::track::Item::group) - .expect("a group"); + let mut group = ordered.next_group().await.unwrap().expect("a group"); let mut read = 0; while let Some(frame) = group .read_frame() diff --git a/rs/moq-rtmp/src/dial.rs b/rs/moq-rtmp/src/dial.rs index 3d51c3be4db..30f923e2cd9 100644 --- a/rs/moq-rtmp/src/dial.rs +++ b/rs/moq-rtmp/src/dial.rs @@ -1274,7 +1274,6 @@ mod tests { .await .expect("catalog read timed out") .expect("catalog read") - .and_then(moq_net::track::Item::group) .expect("a catalog group"); let frame = group .read_frame() diff --git a/rs/moq-stats/src/produce.rs b/rs/moq-stats/src/produce.rs index 1e89e76ae79..6c3b3540356 100644 --- a/rs/moq-stats/src/produce.rs +++ b/rs/moq-stats/src/produce.rs @@ -1695,13 +1695,8 @@ mod tests { .await .unwrap() .ordered(); - let mut reading = loop { - match ordered.next_group().await.unwrap().unwrap() { - track::Item::Group(group) => break group, - // Keys below where the subscription began were never this reader's. - track::Item::Gap { .. } => continue, - } - }; + // Keys below where the subscription began were never this reader's. + let mut reading = ordered.next_group().await.unwrap().unwrap(); assert_eq!(reading.read_frame().await.unwrap().unwrap().payload, b"{}".as_slice()); first.write_frame(at(2), b"{\"a\":1}".to_vec()).unwrap(); assert_eq!( @@ -1719,7 +1714,7 @@ mod tests { reading.read_frame().await.unwrap().is_none(), "{version}: the group ends cleanly" ); - match ordered.next_group().await.unwrap().unwrap() { + match ordered.next_item().await.unwrap().unwrap() { track::Item::Group(group) => assert_eq!(group.start, second.start, "{version}"), track::Item::Gap { range, error } => panic!("{version}: groups {range:?} given up: {error}"), } @@ -2000,7 +1995,7 @@ mod tests { /// The same, without blocking: `None` once nothing more is buffered. fn try_next_frame(track: &mut track::Ordered) -> Option { use futures::FutureExt; - let mut group = track.next_group().now_or_never()?.expect("ok")?.group()?; + let mut group = track.next_group().now_or_never()?.expect("ok")?; group.read_frame().now_or_never()?.expect("ok") } @@ -3285,7 +3280,7 @@ mod tests { let mut track = subscribe(broadcast, &name).await; let mut first = None; while let Some(group) = futures::FutureExt::now_or_never(track.next_group()) { - let start = group.unwrap().unwrap().group().expect("a group").start; + let start = group.unwrap().unwrap().start; first = Some(first.map_or(start, |first: u64| first.min(start))); } let first = first.expect("a run's first group is listed"); diff --git a/rs/moq-transcode/src/lib.rs b/rs/moq-transcode/src/lib.rs index 370fc6d675c..fb9d180386b 100644 --- a/rs/moq-transcode/src/lib.rs +++ b/rs/moq-transcode/src/lib.rs @@ -510,7 +510,7 @@ mod tests { group.finish().unwrap(); for (name, subscriber) in &mut subscribers { - let mut group = subscriber.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = subscriber.next_group().await.unwrap().unwrap(); assert_eq!(group.start, sequence, "{name} changed the group start"); let mut received = Vec::new(); while let Some(payload) = group.read_frame().await.unwrap() { @@ -1017,7 +1017,7 @@ mod tests { .await .unwrap() .ordered(); - let mut group = subscriber.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = subscriber.next_group().await.unwrap().unwrap(); assert!(group.start <= 1, "unexpected sequence {}", group.start); let payload = group.read_frame().await.unwrap().unwrap(); let frame = hang::container::Frame::decode(payload.payload).unwrap(); @@ -1120,11 +1120,7 @@ mod tests { .await .unwrap() .ordered(); - let mut group = loop { - if let Some(group) = live.next_group().await.unwrap().unwrap().group() { - break group; - } - }; + let mut group = live.next_group().await.unwrap().unwrap(); assert!(group.read_frame().await.unwrap().is_some()); transcoder.abort(); @@ -1173,7 +1169,7 @@ mod tests { assert!(update.encoding); // Real frames, so the counters are counting encoding rather than intent. - let mut group = subscriber.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = subscriber.next_group().await.unwrap().unwrap(); group.read_frame().await.unwrap().unwrap(); assert!(rendition.frames() > 0); assert!(rendition.bytes() > 0); diff --git a/rs/moq-transcode/src/rung.rs b/rs/moq-transcode/src/rung.rs index 85385461bb6..548be029682 100644 --- a/rs/moq-transcode/src/rung.rs +++ b/rs/moq-transcode/src/rung.rs @@ -893,11 +893,8 @@ async fn drop_gap( let mut groups = track.subscribe(subscription).await?.ordered(); // The newest source group below the miss, as the output start it maps to. let mut before = None; - while let Some(item) = groups.next_group().await? { - // A group given up on is no source group. - let moq_net::track::Item::Group(group) = item else { - continue; - }; + // A group given up on is no source group. + while let Some(group) = groups.next_group().await? { if group.start >= miss { return Ok::<_, moq_net::Error>((before, output_start(group.start, scale))); } diff --git a/test/interop/clients/rust/hls.rs b/test/interop/clients/rust/hls.rs index 80e3fe17a8e..3b41d882b30 100644 --- a/test/interop/clients/rust/hls.rs +++ b/test/interop/clients/rust/hls.rs @@ -145,11 +145,8 @@ async fn main() -> anyhow::Result<()> { .with_delay(moq_net::track::Delay::default().with_max(Duration::from_secs(3600))); let mut groups = broadcast.track(&name)?.subscribe(replay).await?.ordered(); let mut out = Vec::new(); - while let Some(item) = groups.next_group().await? { - // A group given up on starts no segment. - let moq_net::track::Item::Group(mut group) = item else { - continue; - }; + // A group given up on starts no segment. + while let Some(mut group) = groups.next_group().await? { let Some(frame) = group.read_frame().await? else { continue; }; From dfb38f847a9c370d521b4f7543ece19ede817394 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 18 Nov 2026 16:20:15 -0800 Subject: [PATCH 3/3] test(net): next_group passes the gaps next_item reports Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/model/track.rs | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index a2cdc840a04..5009585c678 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -20090,6 +20090,37 @@ mod test { ); } + /// `next_group` passes over every gap `next_item` reports, trailing ones included, and ends + /// where it does. + #[test] + #[cfg(feature = "async")] + fn next_group_passes_the_gaps_next_item_reports() { + let mut producer = track_producer("test", None); + let mut every = producer.subscribe(replay()).ordered(); + let mut groups = producer.subscribe(replay()).ordered(); + put(&producer, 2, None); + put(&producer, 4, None); + producer.drop_groups(0..2, StreamError::DeliveryTimeout); + producer.drop_groups(3..4, StreamError::DeliveryTimeout); + producer.drop_groups(5..7, StreamError::DeliveryTimeout); + producer.finish_at(Position::group(7)).unwrap(); + assert_eq!( + items(&mut every), + [ + "gap 0..2 (delivery timeout)", + "group 2", + "gap 3..4 (delivery timeout)", + "group 4", + "gap 5..7 (delivery timeout)", + ] + ); + let mut read = Vec::new(); + while let Some(group) = groups.next_group().now_or_never().expect("ready").unwrap() { + read.push(group.start); + } + assert_eq!(read, [2, 4]); + } + /// A gap a moved range only partly covers returns that part, and the rest stays for the /// range to widen over. #[test]