From 20efc7146796bbdf15e10607574dac051ab723a2 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 03:29:23 -0800 Subject: [PATCH 1/9] chore(quest): claim quest/m2/group-drops.md Quest-Claim: 5656fd911b9a602e From 0dd452dd453a73f629129c873ecaf58847fb7303 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 06:27:02 -0800 Subject: [PATCH 2/9] feat(net)!: an ordered track reports the groups it gives up on `track::Ordered::next_group` now yields `Item::Group` or `Item::Gap`, so a group the subscriber gives up on (evicted, cut, stale, or arriving after the read passed its key) is always reported with its range and error. Resume readers feed the same gaps into their drop model. Co-Authored-By: Claude Sonnet 5.5 --- quest/m2/README.md | 4 +- quest/m2/group-drops.md | 83 -- quest/m2/lite07-finalize.md | 2 +- quest/m2/time-addressing/lite07.md | 3 +- quest/m2/unused-api/net.md | 5 +- quest/m3/receive-windows-evicted.md | 28 +- rs/moq-archive/src/consumer/tests.rs | 40 +- rs/moq-archive/src/producer/track.rs | 10 +- rs/moq-bench/src/connection.rs | 28 +- rs/moq-boy/src/input.rs | 7 +- rs/moq-c/src/consume.rs | 10 +- rs/moq-cli/src/main.rs | 2 +- rs/moq-ffi/src/consumer.rs | 19 +- rs/moq-ffi/src/media.rs | 2 +- rs/moq-gst/src/sink/imp.rs | 1 + rs/moq-gst/src/sink/pad.rs | 21 +- rs/moq-hls/src/export/rendition.rs | 4 +- rs/moq-hls/src/import.rs | 3 +- rs/moq-json/examples/telemetry.rs | 5 +- rs/moq-json/src/snapshot/consumer.rs | 13 +- rs/moq-json/src/snapshot/mod.rs | 2 +- rs/moq-json/src/window/consumer.rs | 4 +- rs/moq-json/src/window/mod.rs | 4 +- rs/moq-mux/src/catalog/msf/consumer.rs | 4 +- 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 | 4 +- rs/moq-mux/src/container/ts/si.rs | 4 +- rs/moq-net/benches/group.rs | 9 +- rs/moq-net/benches/origin.rs | 8 +- rs/moq-net/src/ietf/subscriber.rs | 10 +- rs/moq-net/src/lite/subscriber/fills.rs | 2 +- rs/moq-net/src/model/resume.rs | 44 + rs/moq-net/src/model/resume_model.rs | 45 +- rs/moq-net/src/model/track.rs | 788 ++++++++++++++++-- rs/moq-net/tests/integration/drop_record.rs | 63 ++ .../integration/settled_end_survives_abort.rs | 2 +- rs/moq-net/tests/integration/socket.rs | 3 +- rs/moq-relay/tests/integration/quic_sim.rs | 7 +- rs/moq-relay/tests/integration/socket_auth.rs | 7 +- rs/moq-rtmp/src/dial.rs | 1 + rs/moq-stats/src/produce.rs | 4 +- .../tests/integration/receive_credit.rs | 10 +- rs/moq-transcode/src/lib.rs | 8 +- rs/moq-transcode/src/rung.rs | 6 +- test/interop/clients/rust/hls.rs | 6 +- test/interop/clients/rust/socket-js.rs | 12 +- test/interop/clients/rust/socket.rs | 6 +- 49 files changed, 1115 insertions(+), 274 deletions(-) delete mode 100644 quest/m2/group-drops.md diff --git a/quest/m2/README.md b/quest/m2/README.md index 87c4e57f072..236d5a29769 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -27,7 +27,7 @@ removal, a rename, or a wire, catalog, or format change that is free until gains its reader, reversing 2026-11-14; and [lite-07 by start](/quest/m2/time-addressing/lite07.md) carries the smaller wire fixes. [Refresh](/quest/m2/refresh-interval.md) and - [group drops](/quest/m2/group-drops.md) took simpler contracts. + group drops took simpler contracts. [moq-transport time addressing](/quest/m2/ietf-time-addressing.md) returned from m4, and the two moq-transport interop quests in m3 were deleted. Kept as they are: datagram tracks with their lite-05/06 bridge, @@ -331,7 +331,7 @@ what would need a breaking release had it landed right after the cut: the routes epic and gates the cut, per the 2026-10-13 rule that routes' tier and partition tests run before it (maintainer; rejected: moving it to m3 and fixing late routing flaws in lite-08). -- ✅ [Group drops](/quest/m2/group-drops.md) split: its lite-07 wire question +- ✅ Group drops split: its lite-07 wire question was its own quest, settled without a wire-format change in [moq-dev/moq#8774](https://github.com/moq-dev/moq/pull/8774); the public `Ordered` API waits for the model. diff --git a/quest/m2/group-drops.md b/quest/m2/group-drops.md deleted file mode 100644 index 69d44aa0fe5..00000000000 --- a/quest/m2/group-drops.md +++ /dev/null @@ -1,83 +0,0 @@ -# [S] A group a subscriber gives up on is always reported - -## Goal - -Every group a moq-lite subscriber gives up on surfaces to the application. -In the API, `track::Subscriber`'s drop signal (today the crate-private -`poll_drop`, which the ordered reader and resume use to skip gaps) is public, -so the receive-windows benchmark and applications can count losses instead of -waiting forever, and that benchmark's overcommitted cells finish with -`delivered_frames` plus the reported drops accounting for every group sent. - -## Plan - -Planned 2026-11-04 with the maintainer, from -[moq-dev/moq#7838](https://github.com/moq-dev/moq/pull/7838): no public API -reports a group the subscriber dropped without `recv_group` returning it, so a -reader that paces on delivered-or-evicted groups stalls. Split 2026-11-14 (the -m2 triage before the cut, under /quest-afk, for the maintainer's review): -the wire half made every abandoned group known and decided lite-07's part; -this publishes it. It stays in m2 because the `Ordered` change below is -breaking. - -The wire half ([moq-dev/moq#8774](https://github.com/moq-dev/moq/pull/8774)) -found every group the overcommitted cells lose already in the drop set: a -scratch reader polling `poll_drop` beside `recv_group` finished every cell of -the receive-windows benchmark with delivered, evicted-after-header and dropped -groups summing to those sent, on lite-06 and lite-07. So surfacing -`poll_drop` alone unskips those cells. - -- ✅ **Milestone** (maintainer, 2026-11-04): it changes public API, so it - lands before the cut. -- **After the drop set.** Drop set finished in - [moq-dev/moq#8476](https://github.com/moq-dev/moq/pull/8476) on 2026-11-12. - `poll_drop` now takes no `Delivered` argument and yields the given-up run - with its `Hole` (`rs/moq-net/src/model/track.rs`, `track/hole.rs`). Publish - the API against that record. The drop set owns the per-cursor drop runs and - their reasons; this reports what a cursor gives up. -- Mirror it in `@moq/net` and the bindings only for a named consumer (for - example a player or container reader that skips gaps), per the API audit - rule that new surface needs one; name it in the PR or leave the mirror out. - -Decided 2026-11-07 (maintainer, /quest-plan from the API sweep of open PRs and -remaining quests): ✅ key the drop signal by group start and land after -[time addressing's model](https://github.com/moq-dev/moq/blob/7d1bee79cb8fcb4d816fc53f0547ef8b2b19756a/quest/m2/time-addressing/model.md), so its public -API never ships sequence-keyed (rejected: landing first and rekeying with -the model). ✅ Drops surface as a `Gap { range, error }` item on -`track::Ordered`, which already skips gaps through `poll_drop`, mirroring -the container consumer's `Read::Gap` (`rs/moq-mux/src/container/consumer.rs`); -`recv_group` is unchanged (rejected: a separate `recv_drop` read; a drop -variant on `recv_group`). - -Decided 2026-11-16 (maintainer, /quest-plan of the pre-cut audit): ✅ a -drop is a span and nothing more: SUBSCRIBE_DROP carries no group count on -lite-07, and `Gap` reports its start-keyed `range` with no count (rejected: -a count on SUBSCRIBE_DROP that `Gap` passes on, which would also have let a -skip become a drop with a count of 0). This settles the question left open -here on 2026-11-07, against its recommendation. Once starts are sparse a -span's length is not a number of groups, and only the node that dropped -them could count; a relay's downstream would need the count carried on the -wire at every hop for a number few readers use. A reader that needs a count -measures what it lost in time, which the span gives, or counts the groups -it did receive. So "count losses" in the Goal means account for every span: -the receive-windows benchmark's overcommitted cells finish when delivered -groups plus reported spans cover everything sent. At HEAD -`SubscribeDrop`'s `Group Count` (`rs/moq-net/src/lite/subscribe.rs`) is a -count of keys, which [the wire rewrite](/quest/m2/time-addressing/lite07.md) -turns into the span's end. - -Public API: breaking for `track::Ordered` only. Its one read, -`poll_next_group` (and its async wrapper), returns -`Result>` instead of `Result>`, where -`Item` is a group or a `Gap { range, error }`; `Ok(None)` still ends the -read and `Err` still carries a track abort. -Callers match the new item, and a caller that ignores drops takes the group -arm; the PR's MIGRATE notes say so. `recv_group` and the unordered cursor are -unchanged, so a reader that needs drop accounting reads through `Ordered`. -`@moq/net` and the bindings mirror it only with a named consumer. -Wire: none. - -## Related - -- [The lite-07 wire addresses groups by start](/quest/m2/time-addressing/lite07.md) - SUBSCRIBE_DROP names the time spans `Gap` reports -- [The receive-windows benchmark](/quest/m3/receive-windows-evicted.md) - its overcommitted cells wait on this (skipped by [moq-dev/moq#7838](https://github.com/moq-dev/moq/pull/7838) until it lands) diff --git a/quest/m2/lite07-finalize.md b/quest/m2/lite07-finalize.md index 3646a454881..efc961de291 100644 --- a/quest/m2/lite07-finalize.md +++ b/quest/m2/lite07-finalize.md @@ -149,7 +149,7 @@ would need a breaking release had it landed right after the cut: waits on nixpkgs as well as the cut; dropping the check, which would find a transcript flaw only after the freeze. - ✅ The wire half of group drops split out as its own quest, which this - waited on in place of [the public drop signal](/quest/m2/group-drops.md), + waited on in place of the public drop signal, an API change that doesn't touch the wire. It settled without a wire-format change ([moq-dev/moq#8774](https://github.com/moq-dev/moq/pull/8774)): both publishers already name a Group Stream the subscriber stopped in diff --git a/quest/m2/time-addressing/lite07.md b/quest/m2/time-addressing/lite07.md index 0f03820d24d..0c0804ff2a6 100644 --- a/quest/m2/time-addressing/lite07.md +++ b/quest/m2/time-addressing/lite07.md @@ -138,7 +138,7 @@ is free only until lite-07 freezes: - ✅ SUBSCRIBE_DROP names a span and carries no group count (rejected: a count, which would also have let SUBSCRIBE_SKIP become a drop with a count of 0). Today's `Group Count` is a count of keys, so it becomes the - span's end. [Group drops](/quest/m2/group-drops.md) reports the span. + span's end. `track::Ordered`'s `Gap` reports the span. Recommendations for the same PR, not decided: @@ -188,6 +188,5 @@ TRACKS_ADD change, and the Padding stream and datagram types go. ## Related - [YIELDED deferred](/quest/m2/yield-defer.md) - removes continuations, the last use of GROUP's `Frame Start` -- [A group a subscriber gives up on is always reported](/quest/m2/group-drops.md) - reads the spans SUBSCRIBE_DROP names - [Refresh a track](/quest/m2/refresh-interval.md) - raises the `Wanted Group` this turns into a start time - [A cold join reaches back](/quest/m2/min-age-join.md) - gives SUBSCRIBE's `Subscriber Min Age` its reader diff --git a/quest/m2/unused-api/net.md b/quest/m2/unused-api/net.md index 6ab781f3d9b..55848253cc4 100644 --- a/quest/m2/unused-api/net.md +++ b/quest/m2/unused-api/net.md @@ -62,8 +62,8 @@ Not in this sweep, with their owners: - `Subscriber::next_in_range`, `is_skipped`, and `poll_start` have one consumer, moq-mux's container reader, which orders groups itself. - [Group drops](/quest/m2/group-drops.md) adds `Gap` to `track::Ordered`; - once the container reader moves onto it these three can go private. + `track::Ordered` now reports a `Gap`; once the container reader moves onto it + these three can go private. - `socket::is_endpoint` leaves with [socket endpoints](/quest/m2/sockets/remove.md). - `origin::Producer::update_hold`, `with_proxy`, `Source`, `source()`, @@ -82,4 +82,3 @@ Public API: breaking, removals only (`Position::after`, `after_group`, ## Related - [moq-net's node, version, handshake, and route priority](/quest/m2/net-renames.md) - makes `Version` opaque -- [A group a subscriber gives up on is always reported](/quest/m2/group-drops.md) - gives the container reader the `Gap` that frees three more methods diff --git a/quest/m3/receive-windows-evicted.md b/quest/m3/receive-windows-evicted.md index aadefaebfa9..75ccededee1 100644 --- a/quest/m3/receive-windows-evicted.md +++ b/quest/m3/receive-windows-evicted.md @@ -8,7 +8,7 @@ overcommitted cells again, and Nightly's `Rust benchmark tests` job (`gh nightly rust-test`) still passes. Those cells are 256 streams, 4 MiB frames, and 4 MiB frames with a following stream window. Until then, the benchmark skips them and prints each one with -`quest/m2/group-drops.md` as the reason. +`quest/m3/receive-windows-evicted.md` as the reason. Every cell keeps the workload it offers. A cell whose incomplete units fit the connection window fails on any eviction. A cell that @@ -24,8 +24,8 @@ pulling the m2 blocker into m1). It ranks right after m2, when it can start. Moved to m1 2026-11-04 with the maintainer, after [moq-dev/moq#7838](https://github.com/moq-dev/moq/pull/7838) landed the -fitting cells: what remains waits on -[group-drops](/quest/m2/group-drops.md), an m2 quest, and with the +fitting cells: what remained waited on +`quest/m2/group-drops.md`, an m2 quest, and with the overcommitted cells skipped the benchmark no longer fails Nightly, so this no longer holds the m0 [Nightly passes on main](/quest/m0/nightly/README.md) epic open. It replaces @@ -42,7 +42,7 @@ Overload policy, decided 2026-11-04 (maintainer): Silent loss, decided 2026-11-04 (maintainer): -- ✅ Fix it at the source in `quest/m2/group-drops.md`, planned in +- ✅ Fix it at the source in `quest/m2/group-drops.md` (landed), planned in [moq-dev/moq#7890](https://github.com/moq-dev/moq/pull/7890). There, the wire always names an abandoned group, and `track::Subscriber`'s drop signal becomes public. @@ -84,10 +84,18 @@ What remains: (traced as `fetch abandoned`). Such a group's in-flight permit never returns, so the writer stalls and the reader times out. The 4 MiB-frame cell hit this on every run, and the 256-stream cell intermittently. -- Once group-drops lands, the reader returns a dropped group's permit and - counts the group as lost. Then remove the skip (`OVERCOMMITTED` and the - `Cell::fits` partition in `benchmark_receive_windows`), and run the full - sweep through `quest gate`. +- The drop signal landed in `quest/m2/group-drops.md` as `track::Item::Gap` + on `track::Ordered`, which the reader must read through: its subscription + anchors at group 0 (`Anchor::Time(0)`), and `next_group` returns each + group or the span given up. The reader returns a permit per group in a + span (the writer's `sent` map holds the keys) and counts them lost. A + scratch run found two things for this PR to settle: `Ordered` reports a + group landing after a higher one was returned as `Old`, so a fitting cell + loses reordered frames with no eviction and `measure`'s "lost a frame + without an eviction" check must count `Old` gaps; and the default cell + runs only once the reader is anchored at group 0. Then remove the skip + (`OVERCOMMITTED` and the `Cell::fits` partition in + `benchmark_receive_windows`), and run the full sweep through `quest gate`. - Retain the stream/frame/window axes and the actual offered workload for a shared receive budget, if one is planned again. - Repro: `just rs test -p moq-tokio --test integration --release -E @@ -101,7 +109,3 @@ connection-wide admission semaphore are recorded in [moq-dev/moq#7838](https://github.com/moq-dev/moq/pull/7838). Public API: none. Wire: none. - -## Required - -- [A group a subscriber gives up on is always reported](/quest/m2/group-drops.md) - the public drop signal the reader needs to return a dropped group's permit diff --git a/rs/moq-archive/src/consumer/tests.rs b/rs/moq-archive/src/consumer/tests.rs index cb374c1cf77..2757beaa239 100644 --- a/rs/moq-archive/src/consumer/tests.rs +++ b/rs/moq-archive/src/consumer/tests.rs @@ -144,21 +144,27 @@ 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); + } + } +} + /// The next group's start, without waiting for it to end. async fn sequence(reader: &mut track::Ordered) -> Option { - timeout(Duration::from_secs(10), reader.next_group()) - .await - .expect("a group arrives") - .unwrap() - .map(|group| group.start) + group(reader).await.map(|group| group.start) } /// The next group and every frame in it, once the group ends. async fn next(reader: &mut track::Ordered) -> Option<(u64, Vec)> { - let mut group = timeout(Duration::from_secs(10), reader.next_group()) - .await - .expect("a group arrives") - .unwrap()?; + let mut group = group(reader).await?; let mut frames = Vec::new(); while let Some(frame) = timeout(Duration::from_secs(10), group.read_frame()) .await @@ -226,7 +232,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(); + let mut group = reader.next_group().await.unwrap().unwrap().group().unwrap(); assert_eq!(group.start, sequence); for index in 0..3 { let frame = group.read_frame().await.unwrap().unwrap(); @@ -450,7 +456,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(); + let mut group = reader.next_group().await.unwrap().unwrap().group().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"); @@ -466,7 +472,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(); + let mut group = reader.next_group().await.unwrap().unwrap().group().unwrap(); assert!(group.read_frame().await.unwrap().is_some()); broadcast.close(); @@ -485,7 +491,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(); + let mut group = reader.next_group().await.unwrap().unwrap().group().unwrap(); assert!(group.read_frame().await.unwrap().is_some()); // Frame 1 of group 0 is missing. @@ -508,7 +514,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(); + let mut group = reader.next_group().await.unwrap().unwrap().group().unwrap(); assert!(group.read_frame().await.unwrap().is_some()); archive.store.inner().fail_lists(); @@ -564,7 +570,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(|group| group.map(|group| group.start)); + let end = end.map(|item| item.map(|item| item.group().expect("a group").start)); assert!( matches!(end, Err(moq_net::Error::Stream(moq_net::StreamError::App(7)))), "{end:?}" @@ -697,7 +703,9 @@ 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(group) => read.push(group.start), + 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 { .. }) => {} None => break, } } diff --git a/rs/moq-archive/src/producer/track.rs b/rs/moq-archive/src/producer/track.rs index 204d0a362ce..722c9f23421 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, Order, Position, Range, Subscription}; +use moq_net::track::{Anchor, Delay, Item, Order, Position, Range, Subscription}; use moq_net::{StreamError, Timescale, group}; use object_store::path::Path; use object_store::{ObjectStore, ObjectStoreExt, PutMode, PutPayload}; @@ -218,8 +218,12 @@ impl Track { } } None => { - if let Poll::Ready(next) = ordered.poll_next_group(waiter) { - return Poll::Ready(Event::Next(next)); + // 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)))), + } } } } diff --git a/rs/moq-bench/src/connection.rs b/rs/moq-bench/src/connection.rs index 7ae5d84b385..06cba723c1f 100644 --- a/rs/moq-bench/src/connection.rs +++ b/rs/moq-bench/src/connection.rs @@ -896,7 +896,12 @@ mod tests { .await .unwrap() .ordered(); - let mut group = sub.next_group().await.unwrap().expect("a group"); + let mut group = sub + .next_group() + .await + .unwrap() + .and_then(moq_net::track::Item::group) + .expect("a group"); let keyframe = group.read_frame().await.unwrap().expect("keyframe"); let header: serde_json::Value = serde_json::from_slice(&keyframe.payload).unwrap(); @@ -943,7 +948,12 @@ mod tests { .await .unwrap() .ordered(); - let mut group = sub.next_group().await.unwrap().expect("a group"); + let mut group = sub + .next_group() + .await + .unwrap() + .and_then(moq_net::track::Item::group) + .expect("a group"); // Just the keyframe, then the group ends. assert!(group.read_frame().await.unwrap().is_some(), "keyframe"); @@ -975,7 +985,12 @@ 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().expect("a group"); + let mut group = sub + .next_group() + .await + .unwrap() + .and_then(moq_net::track::Item::group) + .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"); @@ -1008,7 +1023,12 @@ 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().expect("a group"); + let mut group = sub + .next_group() + .await + .unwrap() + .and_then(moq_net::track::Item::group) + .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-boy/src/input.rs b/rs/moq-boy/src/input.rs index bb4d739b789..19ae8378664 100644 --- a/rs/moq-boy/src/input.rs +++ b/rs/moq-boy/src/input.rs @@ -156,7 +156,11 @@ async fn read_commands( let live = consumer.subscription().with_delay(moq_net::track::Delay::default()); consumer.control().update(live)?; let mut commands = consumer.ordered(); - while let Some(mut group) = commands.next_group().await? { + while let Some(item) = commands.next_group().await? { + // A command given up on is lost the same way as one the delay budget dropped. + let moq_net::track::Item::Group(mut group) = item else { + continue; + }; let frame = match group.read_frame().await { Ok(Some(frame)) => frame, Ok(None) => continue, @@ -330,6 +334,7 @@ mod tests { .await .expect("reply timeout") .unwrap() + .and_then(moq_net::track::Item::group) .expect("a reply"); let frame = group.read_frame().await.unwrap().expect("a frame"); assert_eq!(&frame.payload[..], br#"{"latency":[{"label":"input","ms":42}]}"#); diff --git a/rs/moq-c/src/consume.rs b/rs/moq-c/src/consume.rs index 0ba8738f4ef..e44a93b7c7d 100644 --- a/rs/moq-c/src/consume.rs +++ b/rs/moq-c/src/consume.rs @@ -881,9 +881,13 @@ impl Consume { if Pin::new(&mut close).poll(&mut waiter.context()).is_ready() { return Poll::Ready(Ok(RawStep::Stop)); } - match ready!(track.poll_next_group(waiter))? { - Some(group) => Poll::Ready(Ok(RawStep::Item(group))), - None => Poll::Ready(Ok(RawStep::End)), + 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)), + } } }) .await? diff --git a/rs/moq-cli/src/main.rs b/rs/moq-cli/src/main.rs index 5210131b3b4..4143fd8b052 100644 --- a/rs/moq-cli/src/main.rs +++ b/rs/moq-cli/src/main.rs @@ -1409,7 +1409,7 @@ mod tests { .await .unwrap() .ordered(); - let mut group = track.next_group().await.unwrap().unwrap(); + let mut group = track.next_group().await.unwrap().unwrap().group().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 69a27d6da31..4eaaa65e8e2 100644 --- a/rs/moq-ffi/src/consumer.rs +++ b/rs/moq-ffi/src/consumer.rs @@ -509,7 +509,7 @@ impl TrackInner { waiter.waker().wake_by_ref(); return Poll::Ready(Ok(Some(group))); } - ordered.track.poll_next_group(waiter).map(|r| r.map_err(Into::into)) + poll_group(&mut ordered.track, waiter).map(|r| r.map_err(Into::into)) } Err(e) => Poll::Ready(Err(e)), } @@ -529,7 +529,7 @@ impl TrackInner { loop { let group = match &mut ordered.pending { Some(group) => group, - None => match ready!(ordered.track.poll_next_group(waiter)) { + None => match ready!(poll_group(&mut ordered.track, waiter)) { Ok(Some(group)) => ordered.pending.insert(group), Ok(None) => return Poll::Ready(Ok(None)), Err(err) => return Poll::Ready(Err(err.into())), @@ -730,3 +730,18 @@ 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 7eaacedcf2c..16f344730b2 100644 --- a/rs/moq-ffi/src/media.rs +++ b/rs/moq-ffi/src/media.rs @@ -2154,7 +2154,7 @@ mod timebase_tests { .await .unwrap() .ordered(); - let mut group = catalogs.next_group().await.unwrap().unwrap(); + let mut group = catalogs.next_group().await.unwrap().unwrap().group().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 6a3e50c1ecf..44b732e8af2 100644 --- a/rs/moq-gst/src/sink/imp.rs +++ b/rs/moq-gst/src/sink/imp.rs @@ -2076,6 +2076,7 @@ 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 2a8e1b03a2d..54b511b4c63 100644 --- a/rs/moq-gst/src/sink/pad.rs +++ b/rs/moq-gst/src/sink/pad.rs @@ -2068,7 +2068,12 @@ mod tests { .expect("subscribe to the opaque track") .ordered(); - let mut group = subscriber.next_group().await.unwrap().expect("a first group"); + let mut group = subscriber + .next_group() + .await + .unwrap() + .and_then(moq_net::track::Item::group) + .expect("a first group"); let frame = group.read_frame().await.unwrap().expect("a frame in the first group"); assert_eq!( frame.payload.as_ref(), @@ -2085,7 +2090,12 @@ mod tests { "one buffer produces one group with one frame" ); - let mut group = subscriber.next_group().await.unwrap().expect("a second group"); + let mut group = subscriber + .next_group() + .await + .unwrap() + .and_then(moq_net::track::Item::group) + .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!( @@ -2191,7 +2201,12 @@ mod tests { .await .expect("subscribe to the opaque track") .ordered(); - let mut group = subscriber.next_group().await.unwrap().expect("a group"); + let mut group = subscriber + .next_group() + .await + .unwrap() + .and_then(moq_net::track::Item::group) + .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 4942ccc9e9b..f552ae185ce 100644 --- a/rs/moq-hls/src/export/rendition.rs +++ b/rs/moq-hls/src/export/rendition.rs @@ -2416,7 +2416,9 @@ impl WatchMedia { } let groups = self.groups.as_mut().expect("subscribed above"); match ready!(groups.poll_next_group(waiter))? { - Some(group) => self.step = Step::First(group), + 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 { .. }) => {} 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 79ddd36b5aa..3bcc2b46844 100644 --- a/rs/moq-hls/src/import.rs +++ b/rs/moq-hls/src/import.rs @@ -2405,7 +2405,8 @@ mod tests { let mut out = Vec::new(); loop { let mut group = match subscriber.poll_next_group(&kio::Waiter::noop()) { - Poll::Ready(Ok(Some(group))) => group, + Poll::Ready(Ok(Some(moq_net::track::Item::Group(group)))) => group, + Poll::Ready(Ok(Some(moq_net::track::Item::Gap { .. }))) => continue, Poll::Pending | Poll::Ready(Ok(None)) => break, Poll::Ready(Err(error)) => return (out, Some(error)), }; diff --git a/rs/moq-json/examples/telemetry.rs b/rs/moq-json/examples/telemetry.rs index 310085307e7..935d5f0ef26 100644 --- a/rs/moq-json/examples/telemetry.rs +++ b/rs/moq-json/examples/telemetry.rs @@ -111,7 +111,10 @@ 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(mut group))) = track.poll_next_group(&waiter) { + 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(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 b4649b0ccd8..29788e4217d 100644 --- a/rs/moq-json/src/snapshot/consumer.rs +++ b/rs/moq-json/src/snapshot/consumer.rs @@ -190,9 +190,16 @@ impl Track { if let Self::Subscribing(pending) = self { *self = Self::Ordered(Box::new(std::task::ready!(pending.poll_ok(waiter))?.ordered())); } - match self { - Self::Ordered(track) => track.poll_next_group(waiter), - Self::Subscribing(_) => unreachable!("resolved above"), + let Self::Ordered(track) = self else { + 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)), + } } } } diff --git a/rs/moq-json/src/snapshot/mod.rs b/rs/moq-json/src/snapshot/mod.rs index 91d9287a179..393553fcb28 100644 --- a/rs/moq-json/src/snapshot/mod.rs +++ b/rs/moq-json/src/snapshot/mod.rs @@ -1073,7 +1073,7 @@ mod test { )); let waiter = kio::Waiter::noop(); - let Poll::Ready(Ok(Some(mut group))) = subscriber.poll_next_group(&waiter) else { + let Poll::Ready(Ok(Some(moq_net::track::Item::Group(mut group)))) = subscriber.poll_next_group(&waiter) else { panic!("the group was published, so a subscriber sees it"); }; assert!( diff --git a/rs/moq-json/src/window/consumer.rs b/rs/moq-json/src/window/consumer.rs index f1355071729..f0feb4f82d4 100644 --- a/rs/moq-json/src/window/consumer.rs +++ b/rs/moq-json/src/window/consumer.rs @@ -60,11 +60,13 @@ impl Consumer { let Some(group) = &mut self.group else { match self.track.poll_next_group(waiter)? { - Poll::Ready(Some(group)) => { + Poll::Ready(Some(moq_net::track::Item::Group(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, } diff --git a/rs/moq-json/src/window/mod.rs b/rs/moq-json/src/window/mod.rs index 391330354b3..5f651c0d102 100644 --- a/rs/moq-json/src/window/mod.rs +++ b/rs/moq-json/src/window/mod.rs @@ -877,7 +877,7 @@ mod test { assert!(producer.window().is_empty()); let waiter = kio::Waiter::noop(); - let Poll::Ready(Ok(Some(mut group))) = subscriber.poll_next_group(&waiter) else { + let Poll::Ready(Ok(Some(moq_net::track::Item::Group(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)))); @@ -938,7 +938,7 @@ mod test { let _finished = producer.clone().finish().unwrap(); let waiter = kio::Waiter::noop(); - let Poll::Ready(Ok(Some(mut group))) = subscriber.poll_next_group(&waiter) else { + let Poll::Ready(Ok(Some(moq_net::track::Item::Group(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 81ceb084a05..29715ac6b4c 100644 --- a/rs/moq-mux/src/catalog/msf/consumer.rs +++ b/rs/moq-mux/src/catalog/msf/consumer.rs @@ -43,7 +43,9 @@ impl Consumer { // so we can distinguish "more groups may arrive" from "no more groups, ever". let track_finished = loop { match self.track.poll_next_group(waiter)? { - Poll::Ready(Some(group)) => self.group = Some(group), + 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(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 75795805588..71f953a6a14 100644 --- a/rs/moq-mux/src/catalog/producer.rs +++ b/rs/moq-mux/src/catalog/producer.rs @@ -1540,7 +1540,7 @@ mod test { .await .unwrap() .ordered(); - let mut group = track.next_group().await.unwrap().unwrap(); + let mut group = track.next_group().await.unwrap().unwrap().group().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); @@ -2333,7 +2333,11 @@ mod test { home.block_on(async { for (name, mut track) in readers { let (mut stamps, mut starts) = (Vec::new(), Vec::::new()); - while let Some(mut group) = track.next_group().await.unwrap() { + 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; + }; 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 04d73bf81a8..c75570d9285 100644 --- a/rs/moq-mux/src/container/fmp4/import_test.rs +++ b/rs/moq-mux/src/container/fmp4/import_test.rs @@ -1675,8 +1675,11 @@ async fn starts(consumer: &moq_net::broadcast::Consumer, track: &str) -> Vec { + Poll::Ready(Ok(Some(moq_net::track::Item::Group(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 1b345d313da..7606476d043 100644 --- a/rs/moq-mux/src/container/ts/si.rs +++ b/rs/moq-mux/src/container/ts/si.rs @@ -822,8 +822,8 @@ mod tests { .ordered(); let waiter = kio::Waiter::noop(); let mut read = Vec::new(); - while let std::task::Poll::Ready(Ok(Some(group))) = reader.poll_next_group(&waiter) { - read.push(group.start); + while let std::task::Poll::Ready(Ok(Some(item))) = reader.poll_next_group(&waiter) { + read.push(item.group().expect("a group").start); } assert_eq!(read, expected); } diff --git a/rs/moq-net/benches/group.rs b/rs/moq-net/benches/group.rs index 91211f4e8f8..a47cc3ce325 100644 --- a/rs/moq-net/benches/group.rs +++ b/rs/moq-net/benches/group.rs @@ -319,7 +319,14 @@ 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(); + let group = subscriber + .next_group() + .now_or_never() + .unwrap() + .unwrap() + .unwrap() + .group() + .unwrap(); black_box(group); } (ctx, subscriber) diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index 49514f7158b..c23c2892d32 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -1704,7 +1704,13 @@ impl ResumeReader { fn poll_group(&mut self, waiter: &kio::Waiter) -> Poll>> { match self { Self::Arrival(reader) => reader.poll_recv_group(waiter), - Self::Key(reader) => reader.poll_next_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)), + } + }, } } } diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index eb1ada63d65..8ee172d791f 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -16555,9 +16555,15 @@ 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 { + 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(group))) => group, - Poll::Ready(other) => panic!("no next group: {:?}", other.map(|group| group.map(|g| g.start))), + Poll::Ready(Ok(Some(track::Item::Group(group)))) => group, + Poll::Ready(_) => panic!("no next group"), Poll::Pending => panic!("the ordered reader still waits on the refused group"), }; assert_eq!(group.start, KEY + 1); diff --git a/rs/moq-net/src/lite/subscriber/fills.rs b/rs/moq-net/src/lite/subscriber/fills.rs index 3b1d481e8a5..387ae85b996 100644 --- a/rs/moq-net/src/lite/subscriber/fills.rs +++ b/rs/moq-net/src/lite/subscriber/fills.rs @@ -867,7 +867,7 @@ mod tests { group.close().unwrap(); } for key in 0..3 { - let Poll::Ready(Ok(Some(group))) = reader.poll_next_group(&waiter) else { + let Poll::Ready(Ok(Some(track::Item::Group(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 666c7a21c09..fa44e3b1e77 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -870,6 +870,21 @@ impl Subscriber { self.reader().take(candidate) } + /// The keys that landed on any copy since the last call, below `below`; see + /// [`track::Subscriber::note_late`]. + pub(super) fn late(&mut self, below: u64) -> Vec { + let mut reader = self.reader(); + reader + .copies + .iter_mut() + .filter_map(|copy| match &mut copy.sub { + Sub::Ready(sub) => Some(sub.late(below)), + Sub::Pending(_) => None, + }) + .flatten() + .collect() + } + /// Forget the gaps in `delivered` below each group past the reader's budget, judged on /// the newest copy that answered; see [`track::Subscriber::forget_past_budget`]. pub(super) fn forget_past_budget(&self, delivered: &mut Delivered) { @@ -5224,6 +5239,35 @@ mod test { } } + /// A front's key-order reader reports a group that lands on its copy after the read passed + /// its key, as old, and never one it handed out. + #[test] + fn a_front_reports_a_late_arrival_as_a_gap() { + let routes = Producer::new(); + let logical = logical(&routes); + let a = copy(); + routes.serve(a.consume()); + let mut sub = subscribe(&logical, HOUR).ordered(); + 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) { + items.push(match item { + track::Item::Group(group) => format!("group {}", group.start), + track::Item::Gap { range, error } => format!("gap {range:?} ({error})"), + }); + } + items + }; + write(&a, 0); + write(&a, 5); + assert_eq!(read(&mut sub), ["group 0", "group 5"]); + write(&a, 3); + assert_eq!(read(&mut sub), ["gap 3..4 (old)"]); + write(&a, 6); + assert_eq!(read(&mut sub), ["group 6"]); + } + /// Lowering a front reader's local floor offers the cached groups below the old one it /// passed over, as a plain reader does. #[test] diff --git a/rs/moq-net/src/model/resume_model.rs b/rs/moq-net/src/model/resume_model.rs index dc20efe6c7d..43bf85c8379 100644 --- a/rs/moq-net/src/model/resume_model.rs +++ b/rs/moq-net/src/model/resume_model.rs @@ -305,6 +305,20 @@ impl Reader { ranges && self.bounds.is_none_or(|(start, end)| (start..end).contains(&group)) } + /// Record a run this reader gave up, failing if it handed one of its groups out. + fn report_drop(&mut self, index: usize, range: std::ops::Range, why: &str) -> Result<(), TestCaseError> { + for group in range.clone() { + if self.reading.contains_key(&group) { + return Err(fail( + index, + format!("dropped {range:?} ({why}) after handing out {group}"), + )); + } + } + self.dropped.extend(range.start..range.end.min(GROUPS)); + Ok(()) + } + /// Everything observed, to tell whether a poll found anything new. fn observed(&self) -> (usize, usize, bool, usize) { let frames = self @@ -653,7 +667,14 @@ 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) => sub.poll_next_group(&waiter), + Cursor::Ordered(sub) => match sub.poll_next_group(&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")))), + }, }; match polled { Poll::Pending => break, @@ -728,19 +749,15 @@ impl Model { } } - if reader.spec.drops - && let Some(Cursor::Arrival(sub)) = &mut reader.cursor - { - while let Poll::Ready((range, err)) = sub.poll_drop(&waiter) { - for group in range.clone() { - if reader.reading.contains_key(&group) { - return Err(fail( - index, - format!("dropped {range:?} ({err:?}) after handing out {group}"), - )); - } - } - reader.dropped.extend(range.start..range.end.min(GROUPS)); + if reader.spec.drops && matches!(reader.cursor, Some(Cursor::Arrival(_))) { + loop { + let Some(Cursor::Arrival(sub)) = &mut reader.cursor else { + unreachable!("matched above") + }; + let Poll::Ready((range, err)) = sub.poll_drop(&waiter) else { + break; + }; + reader.report_drop(index, range, &format!("{err:?}"))?; } } diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index eeda631ad97..3d75981eb84 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -7931,6 +7931,8 @@ struct Cursor { /// One past the highest key returned by `next_group`. /// Used only by that method to skip late arrivals; does not affect `recv_group`. next_key: u64, + /// The absolute arrival index [`Self::late`] has read up to. + late: usize, /// Exclusive upper key bound for `next_group` and `recv_group`. `None` means no /// cap. Set by `set_range`; /// can be raised, lowered, or unset at any time. Groups at or past the cap stay in @@ -8292,6 +8294,7 @@ impl Cursor { filter: Box::new(filter), index: 0, next_key: 0, + late: 0, end_key: None, // Uncapped, the servable groups are the window's. servable: published.servable.clone(), @@ -8358,6 +8361,21 @@ impl Cursor { } } + /// The keys that landed in this cursor's window since it last looked, below `below`: a key + /// cursor already read past them, so it never hands them out. + fn late(&mut self, below: u64) -> Vec { + let state = self.state.read(); + let from = self.late.max(state.offset); + self.late = state.offset + state.arrival.len(); + state + .arrival + .iter() + .skip(from - state.offset) + .map(|(key, _)| *key) + .filter(|key| *key < below && self.filter.window.contains(*key)) + .collect() + } + /// Resolve [`Self::servable`] again once the window or cap moved, and publish it to the /// groups already handed out. Costs the ranges, never the cache. fn update_servable(&mut self) { @@ -10114,6 +10132,46 @@ impl Subscriber { }) || owed()) } + /// The keys that landed on this copy since the last call, below `below`. + pub(super) fn late(&mut self, below: u64) -> Vec { + match &mut self.inner { + Inner::Plain(cursor) => cursor.late(below), + Inner::Resume(..) => Vec::new(), + } + } + + /// Report the groups that landed below where this key-order reader had read, which it + /// never hands out, as given up `Old`. A group it handed out or judged stale is already + /// settled, so the record blocks it. + fn note_late(&mut self) { + let (record, late) = match &mut self.inner { + Inner::Plain(cursor) => { + let late = cursor.late(cursor.next_key); + (&mut cursor.record, late) + } + Inner::Resume(resume, logical) => { + let late = resume.late(logical.record.delivered.floor()); + (&mut logical.record, late) + } + }; + for key in late { + if let Some(end) = key.checked_add(1) { + DropCursor::give_up(record, key..end, Hole::drop(StreamError::Old)); + } + } + } + + /// Record `key` as served, so no cut or drop of it is reported afterwards. + fn settle(&mut self, key: u64) { + let record = match &mut self.inner { + Inner::Plain(cursor) => &mut cursor.record, + Inner::Resume(_, logical) => &mut logical.record, + }; + if let Some(end) = key.checked_add(1) { + record.tell(key..end, Report::Settled); + } + } + /// The key cursor behind [`Ordered`], which owns the only public door to it. pub(super) fn poll_next_group(&mut self, waiter: &kio::Waiter) -> Poll>> { self.poll_group(true, waiter) @@ -10126,7 +10184,14 @@ impl Subscriber { /// The two advance independently, and interleaving them produces a group stream that /// is neither, which is why the choice is a handle rather than a method. pub fn ordered(self) -> Ordered { - Ordered { inner: self } + Ordered { + inner: self, + held: None, + gap: None, + at: 0, + started: false, + idle: None, + } } /// Whether `other` was cloned from this subscriber (shares the same underlying state). @@ -10708,7 +10773,7 @@ impl Subscriber { /// 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 skipped rather than delivered out of turn. +/// the fact) is reported as a [gap](Item::Gap) rather than delivered out of turn. /// /// # Age and skipping /// @@ -10739,11 +10804,55 @@ impl Subscriber { /// 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 +/// [`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 +/// landed after the read passed its key (reported as `Old`). A gap carries the keys it +/// spans and is returned once, after any group the read still owes below it and before +/// the next group above it, or when the track ends. Keys the publisher declared skipped +/// (see [`Producer::skip_groups`]) were never groups, so they are no gap; +/// [`Self::is_skipped`] answers for them. +/// /// The budget is updatable mid-stream through [`Self::control`]. [`Duration::ZERO`] (the /// default) keeps only what nothing newer has superseded, so a consumer that stalls and /// resumes rejoins the live edge instead of replaying at 1x. pub struct Ordered { inner: Subscriber, + /// A group read and not yet returned, because a gap below it goes first. + held: Option>, + /// The lowest gap found and not yet returned. + gap: Option<(ops::Range, Error)>, + /// One past the highest key returned, as a group or the end of a gap. + at: u64, + /// Whether the drop record exists. It holds only what happened after it began, so it + /// starts before the first read. + started: bool, + /// The read that last parked, answered again until something it parked on fires. + idle: Option>, +} + +/// What an [`Ordered`] read returns next. +pub enum Item { + /// A group, with a higher key than any group returned before. + Group(group::Consumer), + /// Groups this reader gave up on, which it will not return. + Gap { + /// The keys given up, as group starts. + range: ops::Range, + /// Why: what a read of those groups would have ended with. + error: Error, + }, +} + +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 { @@ -10762,7 +10871,8 @@ impl Ordered { self.inner.broadcast() } - /// The next group with a higher key than any previously returned. + /// The next group with a higher key than any previously returned, or a gap this reader + /// gave up on (see [Gaps](Self#gaps)). /// /// Honors the group range set by [`Self::with_range`]: /// a group past the cap stays in the producer's cache and becomes eligible again if @@ -10771,12 +10881,107 @@ impl Ordered { /// Later reads return `Ok(None)` immediately too; widening the ranges with /// [`Self::update`] resumes reading above the last key returned. /// - /// Returns `Ok(Some(group))` when a group is available, `Ok(None)` when the track is + /// Returns `Ok(Some(item))` when a group or gap is available, `Ok(None)` when the track is /// finished (including an abort after its declared end settled, see [`Producer::abort`]) /// 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>> { - self.inner.poll_next_group(waiter) + pub fn poll_next_group(&mut self, waiter: &kio::Waiter) -> Poll>> { + if idle::Idle::parked(&self.idle, (), waiter) { + return Poll::Pending; + } + let mut idle = idle::Idle::start(&mut self.idle, waiter); + let polled = self.poll_item(idle.waiter()); + idle.finish(&mut self.idle, (), polled.is_pending()); + polled + } + + fn poll_item(&mut self, waiter: &kio::Waiter) -> Poll>> { + // Gaps are recorded only once polled for, so before the first read. + if !self.started { + self.started = true; + self.find_gap(true, waiter); + } + let read = match self.held.take() { + Some(group) => Poll::Ready(Ok(Some(*group))), + None => { + let read = self.inner.poll_next_group(waiter); + if let Poll::Ready(Ok(Some(group))) = &read { + // Handed out, so no later cut or drop of it is a gap. + self.inner.settle(group.start); + } + read + } + }; + // After the read, which judged what it walked past: a group it handed out leaves only + // what that queued, and anything else judges the live edge for the gaps it parks on. + self.find_gap(!matches!(read, Poll::Ready(Ok(Some(_)))), waiter); + match read { + Poll::Ready(Ok(Some(group))) => match self.gap.take() { + // The gap lies wholly below it, or around it: the part below goes first. + Some((range, error)) if range.start < group.start => { + let key = group.start; + let above = key.saturating_add(1)..range.end; + if !above.is_empty() { + self.gap = Some((above, error.clone())); + } + self.held = Some(Box::new(group)); + Poll::Ready(Ok(Some(self.give(range.start..range.end.min(key), error)))) + } + // A group handed out is no gap, even one a drop also named, as a cut group is. + gap => { + self.gap = gap.and_then(|(range, error)| { + let range = range.start.max(group.start.saturating_add(1))..range.end; + (!range.is_empty()).then_some((range, error)) + }); + self.at = self.at.max(group.start.saturating_add(1)); + Poll::Ready(Ok(Some(Item::Group(group)))) + } + }, + // What the read still owes lies above the gap, so the gap goes first. + Poll::Pending if self.gap_is_next() => { + let (range, error) = self.gap.take().expect("a gap is held"); + Poll::Ready(Ok(Some(self.give(range, error)))) + } + Poll::Pending => Poll::Pending, + // Every gap is returned before the end. + Poll::Ready(end) => match self.gap.take() { + Some((range, error)) => Poll::Ready(Ok(Some(self.give(range, error)))), + None => Poll::Ready(end.map(|_| None)), + }, + } + } + + /// Look for the lowest gap, if none is held. + fn find_gap(&mut self, judge: bool, waiter: &kio::Waiter) { + self.inner.note_late(); + while self.gap.is_none() { + let polled = match judge { + true => self.inner.poll_drop(waiter), + false => self.inner.poll_queued_drop(waiter), + }; + let Poll::Ready((range, hole)) = polled else { + return; + }; + // A skip was never a group: nothing was given up. + if let Hole::Drop { error, .. } = hole { + self.gap = Some((range, error.into())); + } + } + } + + /// Whether the held gap may go out now: nothing the read still owes lies below it. + fn gap_is_next(&self) -> bool { + let Some((range, _)) = &self.gap else { + return false; + }; + range.start <= self.at || self.inner.next_in_range(self.at).is_none_or(|owed| owed >= range.start) + } + + /// A gap as an item, which the read has now moved past. + fn give(&mut self, range: ops::Range, error: Error) -> Item { + self.at = self.at.max(range.end); + Item::Gap { range, error } } /// Limit subsequent reads to these group keys, returning `self` for chaining. @@ -10790,6 +10995,8 @@ impl Ordered { /// [`Self::with_range`] on a reader held in place. fn set_range(&mut self, groups: impl RangeBounds) { + // A moved range notifies nothing a parked read waits on. + idle::Idle::disarm(&mut self.idle); self.inner.set_range(groups); } @@ -10808,6 +11015,7 @@ impl Ordered { /// /// Returns [`Error::Closed`] if the track already ended. pub fn update(&mut self, subscription: Subscription) -> Result<()> { + idle::Idle::disarm(&mut self.idle); self.inner.update(subscription) } @@ -11783,6 +11991,30 @@ mod test { } /// Every group a reader hands out with the frame indices it reads, until one would block. + /// What an ordered read returns until it ends, as `group 2` or `gap 1..2 (error)`. + #[cfg(feature = "async")] + fn items(ordered: &mut Ordered) -> Vec { + let mut items = Vec::new(); + while let Some(next) = ordered.next_group().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})")), + Ok(None) => return items, + Err(err) => { + items.push(format!("error ({err})")); + return items; + } + } + } + items.push("pending".to_string()); + items + } + + /// 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)> { @@ -11822,7 +12054,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| ordered.poll_next_group(waiter)), want); + assert_eq!(read_groups(|waiter| groups_only(ordered.poll_next_group(waiter))), want); } /// A group missing its head is never served short: reading it is [`Error::Lagged`], @@ -15261,8 +15493,10 @@ mod test { #[cfg(feature = "async")] fn drain_ordered(subscriber: &mut Ordered) -> Vec { let mut keys = Vec::new(); - while let Some(Ok(Some(group))) = subscriber.next_group().now_or_never() { - keys.push(group.start); + while let Some(Ok(Some(item))) = subscriber.next_group().now_or_never() { + if let Item::Group(group) = item { + keys.push(group.start); + } } keys } @@ -15641,7 +15875,14 @@ mod test { let mut subscriber = producer.subscribe(Subscription::default().with_range(0..2)); assert_eq!(drain(&mut subscriber), vec![1]); let mut subscriber = producer.subscribe(Subscription::default().with_range(0..2)).ordered(); - let next = subscriber.next_group().now_or_never().unwrap().unwrap().unwrap(); + let next = subscriber + .next_group() + .now_or_never() + .unwrap() + .unwrap() + .unwrap() + .group() + .unwrap(); assert_eq!(next.start, 1); // A budget that covers it delivers the range, and nothing above it. @@ -16494,12 +16735,8 @@ mod test { let mut ordered = producer.subscribe(replay()).ordered(); drop(producer); - 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 2").unwrap().unwrap(); - assert_eq!(second.start, 2); - let done = ordered.next_group().now_or_never().expect("end").unwrap(); - assert!(done.is_none(), "missing groups below the boundary are not an error"); + // A group never produced below a later one is given up, and the end is clean. + assert_eq!(items(&mut ordered), ["group 0", "gap 1..2 (not found)", "group 2"]); } /// A finished track ends both readers with nothing left in range, whether the range @@ -16519,7 +16756,7 @@ mod test { } let _producer = producer.finish().unwrap(); for key in 0..3 { - let Poll::Ready(Ok(Some(group))) = ordered.poll_next_group(&kio::Waiter::noop()) else { + let Poll::Ready(Ok(Some(Item::Group(group)))) = ordered.poll_next_group(&kio::Waiter::noop()) else { panic!("group {key}, given_up={given_up}") }; assert_eq!(group.start, key); @@ -16528,6 +16765,18 @@ mod test { }; assert_eq!(group.start, key); } + // 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()) + else { + panic!("the given up group is reported") + }; + assert_eq!(range, 3..4); + assert!( + matches!(error, Error::Stream(StreamError::DeliveryTimeout)), + "{error:?}" + ); + } assert!( matches!(ordered.poll_next_group(&kio::Waiter::noop()), Poll::Ready(Ok(None))), "given_up={given_up}" @@ -16582,9 +16831,23 @@ mod test { late.write_frame(late.key_time(), &b"late"[..]).unwrap(); let late = late.close().unwrap(); assert_eq!(late.frame_count(), 1); - let first = ordered.next_group().now_or_never().expect("group 0").unwrap().unwrap(); + let first = ordered + .next_group() + .now_or_never() + .expect("group 0") + .unwrap() + .unwrap() + .group() + .unwrap(); assert_eq!(first.start, 0); - let second = ordered.next_group().now_or_never().expect("group 1").unwrap().unwrap(); + let second = ordered + .next_group() + .now_or_never() + .expect("group 1") + .unwrap() + .unwrap() + .group() + .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"); @@ -16800,7 +17063,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().start, key); + assert_eq!(ordered.next_group().await.unwrap().unwrap().group().unwrap().start, key); } assert!(matches!(arrival.recv_group().await, Err(Error::App(7)))); assert!(matches!(ordered.next_group().await, Err(Error::App(7)))); @@ -16838,7 +17101,12 @@ mod test { // Missing lower groups do not hold either reader for the wire's grace. // The last group's own stream remains open independently of the track end. assert_eq!(arrival.assert_group().start, 2); - assert_eq!(ordered.next_group().await.unwrap().unwrap().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 { + panic!("the missing groups are reported") + }; + assert_eq!(range, 0..2); + assert_eq!(ordered.next_group().await.unwrap().unwrap().group().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()); @@ -16848,10 +17116,15 @@ mod test { arrival.recv_group().now_or_never().unwrap(), Err(Error::Timeout) )); - assert!(matches!( - ordered.next_group().now_or_never().unwrap(), - Err(Error::Timeout) - )); + let next = ordered.next_group().now_or_never().unwrap(); + assert!( + matches!(next, Err(Error::Timeout)), + "{:?}", + next.map(|i| i.map(|i| match i { + Item::Gap { range, error } => format!("{range:?} {error}"), + _ => "group".into(), + })) + ); } /// A received copy's end holds readers at a hole below it, since a lower group's stream @@ -17470,7 +17743,7 @@ mod test { .next_group() .now_or_never() .expect("should not block") - .map(|group| group.map(|group| group.start)); + .map(|item| item.map(|item| item.group().expect("a group").start)); assert!(matches!(res, Err(Error::Timeout)), "expected the abort, got {res:?}"); } @@ -17601,7 +17874,7 @@ mod test { .next_group() .now_or_never() .expect("should not block") - .map(|group| group.map(|group| group.start)); + .map(|item| item.map(|item| item.group().expect("a group").start)); assert!(matches!(end, Ok(None)), "expected the clean end, got {end:?}"); } @@ -17629,7 +17902,7 @@ mod test { .next_group() .now_or_never() .expect("should not block") - .map(|group| group.map(|group| group.start)); + .map(|item| item.map(|item| item.group().expect("a group").start)); assert!( matches!(end, Ok(None)), "capped at the end: expected the clean end, got {end:?}" @@ -17653,7 +17926,7 @@ mod test { .next_group() .now_or_never() .expect("should not block") - .map(|group| group.map(|group| group.start)); + .map(|item| item.map(|item| item.group().expect("a group").start)); assert!( matches!(end, Ok(None)), "gap below the cap: expected the clean end, got {end:?}" @@ -18461,6 +18734,112 @@ mod test { assert_eq!(drain_ordered(&mut consumer), [0, 1]); } + /// A group the track gives up on comes back as a gap, in key order among the groups, with + /// why; a group already returned is no gap, nor is a key the publisher skipped. + #[test] + #[cfg(feature = "async")] + fn an_ordered_read_reports_what_it_gives_up() { + let producer = track_producer("test", None); + let mut ordered = producer.subscribe(replay()).ordered(); + put(&producer, 0, None); + put(&producer, 3, None); + producer.drop_groups(1..3, StreamError::DeliveryTimeout); + producer.skip_groups(4..6); + put(&producer, 6, None); + assert_eq!( + items(&mut ordered), + [ + "group 0", + "gap 1..3 (delivery timeout)", + "group 3", + "group 6", + "pending" + ], + "a skip is no gap" + ); + + // 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 { + panic!("group 7 is ready") + }; + assert_eq!(read.start, 7); + cut.abort(Error::Cancel).unwrap(); + assert_eq!(items(&mut ordered), ["pending"]); + } + + /// A gap waits behind a group the read still owes below it, and goes out once nothing is + /// owed, or the end comes: every gap is returned before the track ends. + #[test] + #[cfg(feature = "async")] + fn a_gap_waits_behind_what_is_owed_below_it() { + let producer = received_producer(None); + let mut ordered = producer + .subscribe(Subscription::default().with_delay(Delay::default().with_max(None))) + .ordered(); + put(&producer, 0, None); + put(&producer, 2, None); + producer.drop_groups(4..5, StreamError::DeliveryTimeout); + assert_eq!( + items(&mut ordered), + ["group 0", "pending"], + "group 1 is owed below the gap" + ); + put(&producer, 1, None); + assert_eq!( + items(&mut ordered), + ["group 1", "group 2", "pending"], + "group 3 is owed below the gap" + ); + put(&producer, 3, None); + assert_eq!( + items(&mut ordered), + ["group 3", "gap 4..5 (delivery timeout)", "pending"] + ); + + let producer = track_producer("test", None); + let mut ordered = producer.subscribe(replay()).ordered(); + put(&producer, 0, None); + producer.drop_groups(1..2, StreamError::DeliveryTimeout); + let _producer = producer.finish().unwrap(); + assert_eq!( + items(&mut ordered), + ["group 0", "gap 1..2 (delivery timeout)"], + "the end is clean after every gap" + ); + } + + /// A group landing after the read passed its key is given up as old, since the read never + /// goes back; the group it was passed for is no gap. + #[test] + #[cfg(feature = "async")] + fn a_late_arrival_is_a_gap() { + let producer = track_producer("test", None); + let mut ordered = producer.subscribe(replay()).ordered(); + put(&producer, 0, None); + put(&producer, 5, None); + assert_eq!(items(&mut ordered), ["group 0", "group 5", "pending"]); + put(&producer, 3, None); + assert_eq!(items(&mut ordered), ["gap 3..4 (old)", "pending"]); + put(&producer, 6, None); + assert_eq!( + items(&mut ordered), + ["group 6", "pending"], + "reported once, nothing else" + ); + } + + /// A gap is clipped to what the reader asked for. + #[test] + #[cfg(feature = "async")] + fn a_gap_is_clipped_to_the_reader_range() { + let producer = track_producer("test", None); + let mut ordered = producer.subscribe(replay()).ordered().with_range(2..4); + producer.drop_groups(0..6, StreamError::DeliveryTimeout); + put(&producer, 5, None); + assert_eq!(items(&mut ordered), ["gap 2..4 (delivery timeout)", "pending"]); + } + /// The wait follows the reader's budget: a zero budget waits for nothing, a budget /// narrowed mid-wait ends it, and an unbounded one waits until the hole resolves. #[test] @@ -18511,7 +18890,9 @@ mod test { .now_or_never() .expect("should not block") .expect("would have errored") - .expect("track should not be closed"); + .expect("track should not be closed") + .group() + .expect("a group"); assert_eq!(group.start, 5); // Seq 3 arrives late, skipped because 3 <= 5. @@ -18526,26 +18907,14 @@ mod test { .unwrap() .close() .unwrap(); - // Seq 7 arrives and is returned. + // Seq 7 arrives and is returned, after the groups it passed are reported. producer .create_group(group::Info { start: 7 }) .unwrap() .close() .unwrap(); - let group = consumer - .next_group() - .now_or_never() - .expect("should not block") - .expect("would have errored") - .expect("track should not be closed"); - assert_eq!(group.start, 7); - - // No more groups. This would block. - assert!( - consumer.next_group().now_or_never().is_none(), - "should block waiting for a higher key" - ); + assert_eq!(items(&mut consumer), ["gap 3..5 (old)", "group 7", "pending"]); } #[test] @@ -18571,7 +18940,9 @@ mod test { .now_or_never() .expect("should not block") .expect("would have errored") - .expect("track should not be closed"); + .expect("track should not be closed") + .group() + .expect("a group"); assert_eq!(group.start, 3); let group = consumer @@ -18579,7 +18950,9 @@ mod test { .now_or_never() .expect("should not block") .expect("would have errored") - .expect("track should not be closed"); + .expect("track should not be closed") + .group() + .expect("a group"); assert_eq!(group.start, 5); } @@ -18776,7 +19149,9 @@ mod test { .now_or_never() .expect("should not block") .expect("would have errored") - .expect("track should not be closed"); + .expect("track should not be closed") + .group() + .expect("a group"); assert_eq!(group.start, 3); // The plain handle walks arrivals, so it still starts at seq 5. @@ -18800,9 +19175,42 @@ 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().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); + 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 + ); // Group 3 is beyond the cap: next_group parks even though cached groups exist. assert!( @@ -18826,20 +19234,86 @@ mod test { } consumer.set_range(..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() + .group() + .unwrap() + .start, + 0 + ); + assert_eq!( + consumer + .next_group() + .now_or_never() + .unwrap() + .unwrap() + .unwrap() + .group() + .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().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() + .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!(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().start, 5); + assert_eq!( + consumer + .next_group() + .now_or_never() + .unwrap() + .unwrap() + .unwrap() + .group() + .unwrap() + .start, + 5 + ); assert!(consumer.next_group().now_or_never().is_none(), "no more groups"); } @@ -18858,9 +19332,42 @@ mod test { } // Drain everything with no cap. - 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); + 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 + ); // Lower the cap below the cursor. New groups beyond the cap are blocked. consumer.set_range(..2); @@ -18881,8 +19388,30 @@ 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().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() + .group() + .unwrap() + .start, + 3 + ); + assert_eq!( + consumer + .next_group() + .now_or_never() + .unwrap() + .unwrap() + .unwrap() + .group() + .unwrap() + .start, + 4 + ); } #[test] @@ -18922,16 +19451,71 @@ mod test { .unwrap(); // next_group walks in key order through everything <= cap. - 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); + 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 + ); // 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().start, 8); + assert_eq!( + consumer + .next_group() + .now_or_never() + .unwrap() + .unwrap() + .unwrap() + .group() + .unwrap() + .start, + 8 + ); } /// `recv_group` (arrival order) honors the `end_at` cap like `next_group`: a group @@ -19189,8 +19773,26 @@ mod test { group.close().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!( + 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!(last.start, 1); last = last.with_range(..end.frame); assert_eq!( @@ -19231,7 +19833,15 @@ mod test { .unwrap(); assert!(matches!(producer.append_next(), Err(Error::BoundsExceeded(_)))); assert_eq!( - consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, + consumer + .next_group() + .now_or_never() + .unwrap() + .unwrap() + .unwrap() + .group() + .unwrap() + .start, u64::MAX - 1 ); // The track's end lands on the reserved key. @@ -19871,7 +20481,14 @@ 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(); + let cut = ordered + .next_group() + .now_or_never() + .unwrap() + .unwrap() + .unwrap() + .group() + .unwrap(); assert_eq!(cut.start, 0); assert!(matches!(cut.with_range(200..).read_frame().await, Err(Error::App(5)))); assert!( @@ -20326,8 +20943,11 @@ 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(group) = sub.next_group().await.unwrap() { - read.push(group.start); + while let Some(item) = sub.next_group().await.unwrap() { + read.push(match item { + Item::Group(group) => format!("group {}", group.start), + Item::Gap { range, .. } => format!("gap {range:?}"), + }); } read }); @@ -20336,7 +20956,7 @@ mod test { .expect("the head is asked") .unwrap(); request.reject(Error::NotFound); - assert_eq!(reading.await.unwrap(), [1]); + assert_eq!(reading.await.unwrap(), ["gap 0..1", "group 1"]); } /// A refused mid-group end caps none of its group's copies, even one that fit under it. @@ -23571,8 +24191,8 @@ mod test { while let Poll::Ready(Some(key)) = fill.poll_wanted_changed(&waiter) { write_filled(fill.accept(key, None), key); served.push(key); - while let Poll::Ready(Ok(Some(group))) = ordered.poll_next_group(&waiter) { - read.push(group.start); + while let Poll::Ready(Ok(Some(item))) = ordered.poll_next_group(&waiter) { + read.push(item.group().expect("a group").start); } } assert_eq!(served, [3, 2, 1, 0]); @@ -26206,7 +26826,14 @@ 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(); + let mut first = ordered + .next_group() + .now_or_never() + .unwrap() + .unwrap() + .unwrap() + .group() + .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]); @@ -26310,7 +26937,14 @@ 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(); + let mut reoffered = ordered + .next_group() + .now_or_never() + .unwrap() + .unwrap() + .unwrap() + .group() + .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 a1b86b05e50..34441ac918e 100644 --- a/rs/moq-net/tests/integration/drop_record.rs +++ b/rs/moq-net/tests/integration/drop_record.rs @@ -470,6 +470,69 @@ async fn an_origin_eviction_drop_is_forwarded_final() { } } +/// A group the publisher's origin reclaimed before it was sent reaches an ordered reader on +/// the far side of a relay as a gap, so the groups it receives plus the spans it is told of +/// cover every group written, with nothing held waiting for one that will not come. +#[kio::test] +async fn an_ordered_reader_is_told_of_every_group_the_origin_evicted() { + const EXPIRY: Duration = Duration::from_secs(10); + const PAYLOAD: usize = 16 * 1024; + const WRITTEN: u64 = 4; + for versions in [[LITE06, LITE06], [LITE07, LITE07]] { + kio::clock::timeout(TIMEOUT * 10, async { + // One stream of credit, held from the relay, so the groups queue until reclaimed. + let chain = Chain::with_credit(versions, [expiring(EXPIRY), forever(), forever()], Some(1)).await; + // A budget bounds the wait on a group a hop judged stale; none would fill it instead. + let mut reader = chain + .subscribe(reading(Duration::from_secs(3600), [support::keys(0..)])) + .await + .ordered(); + chain.upstream.server_transport.hold_unis(); + for key in 0..WRITTEN { + let mut group = chain.source.create_group(moq_net::group::Info { start: key }).unwrap(); + group + .write_frame(Timestamp::from_millis(key * 1000).unwrap(), vec![0u8; PAYLOAD]) + .unwrap(); + group.close().unwrap(); + } + // Nobody reads the queued groups, so the origin reclaims all but the newest. + kio::clock::sleep(EXPIRY * 3).await; + chain.upstream.server_transport.release_unis(); + let finished = chain.source.clone().finish().unwrap(); + + let mut got = BTreeSet::new(); + let mut told = BTreeSet::new(); + while let Some(item) = kio::clock::timeout(TIMEOUT, reader.next_group()) + .await + .expect("the reader stalled on a group that will not come") + .expect("the reader runs on") + { + match item { + track::Item::Group(group) => assert!(got.insert(group.start), "group {} twice", group.start), + track::Item::Gap { range, .. } => { + for key in range { + assert!(told.insert(key), "group {key} reported twice"); + } + } + } + } + assert!(got.is_disjoint(&told), "{versions:?}: {got:?} also reported {told:?}"); + assert!( + got.contains(&(WRITTEN - 1)), + "{versions:?}: the newest is delivered: {got:?}" + ); + assert_eq!( + got.union(&told).copied().collect::>(), + (0..WRITTEN).collect::>(), + "{versions:?}: delivered {got:?} and reported {told:?}" + ); + drop(finished); + }) + .await + .unwrap_or_else(|_| panic!("{versions:?}: timed out")); + } +} + /// After a widening from max delay B1 to B2 for a group the publisher no longer holds, its /// stale drop under B1, still in flight when the relay sends the B2 update, settles no reader; /// the drop the publisher sends again under the B2 update settles the B2 reader, over lite-07. 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 af5063ee4d3..b05dde3013a 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(group)) => got.push(group.start), + Ok(Some(item)) => got.push(item.group().expect("a group").start), Ok(None) => return (got, None), Err(err) => return (got, Some(err)), } diff --git a/rs/moq-net/tests/integration/socket.rs b/rs/moq-net/tests/integration/socket.rs index 5b91e4351c9..77c65850465 100644 --- a/rs/moq-net/tests/integration/socket.rs +++ b/rs/moq-net/tests/integration/socket.rs @@ -108,9 +108,10 @@ fn send(track: &track::Producer, payload: &'static [u8]) { /// Read the next message from a session, or `None` once the peer finished. async fn recv(reader: &mut track::Ordered) -> Result>, Error> { kio::clock::timeout(TIMEOUT, async { - let Some(mut group) = reader.next_group().await? else { + let Some(item) = reader.next_group().await? else { return Ok(None); }; + let mut group = item.group().expect("a group, not a gap"); let frame = group.read_frame().await?.expect("a frame"); Ok(Some(frame.payload.to_vec())) }) diff --git a/rs/moq-relay/tests/integration/quic_sim.rs b/rs/moq-relay/tests/integration/quic_sim.rs index a861683fcc5..4cb6a7d62b7 100644 --- a/rs/moq-relay/tests/integration/quic_sim.rs +++ b/rs/moq-relay/tests/integration/quic_sim.rs @@ -283,7 +283,12 @@ fn a_socket_session_carries_a_bulk_transfer_losslessly() { }; let read = async { let mut ordered = dialed.consumer.ordered(); - let mut group = ordered.next_group().await.unwrap().expect("a group"); + let mut group = ordered + .next_group() + .await + .unwrap() + .and_then(moq_net::track::Item::group) + .expect("a group"); let mut read = 0; while let Some(frame) = group .read_frame() diff --git a/rs/moq-relay/tests/integration/socket_auth.rs b/rs/moq-relay/tests/integration/socket_auth.rs index 8cdbc722f74..438340b2bf3 100644 --- a/rs/moq-relay/tests/integration/socket_auth.rs +++ b/rs/moq-relay/tests/integration/socket_auth.rs @@ -173,7 +173,12 @@ fn send(track: &moq_net::track::Producer, payload: &'static [u8]) { /// Read the next message of a session. async fn recv(reader: &mut moq_net::track::Ordered) -> Vec { kio::clock::timeout(TIMEOUT, async { - let mut group = reader.next_group().await.expect("group").expect("a group"); + let mut group = reader + .next_group() + .await + .expect("group") + .and_then(moq_net::track::Item::group) + .expect("a group"); let frame = group.read_frame().await.expect("frame").expect("a frame"); frame.payload.to_vec() }) diff --git a/rs/moq-rtmp/src/dial.rs b/rs/moq-rtmp/src/dial.rs index 613eea242b1..795bc06e7a4 100644 --- a/rs/moq-rtmp/src/dial.rs +++ b/rs/moq-rtmp/src/dial.rs @@ -1241,6 +1241,7 @@ 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 54a597da756..1657d42e316 100644 --- a/rs/moq-stats/src/produce.rs +++ b/rs/moq-stats/src/produce.rs @@ -1921,7 +1921,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")?; + let mut group = track.next_group().now_or_never()?.expect("ok")?.group()?; group.read_frame().now_or_never()?.expect("ok") } @@ -3190,7 +3190,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().start; + let start = group.unwrap().unwrap().group().expect("a group").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-tokio/tests/integration/receive_credit.rs b/rs/moq-tokio/tests/integration/receive_credit.rs index 05682f7b3e8..ba0f3b2dfb4 100644 --- a/rs/moq-tokio/tests/integration/receive_credit.rs +++ b/rs/moq-tokio/tests/integration/receive_credit.rs @@ -1021,10 +1021,10 @@ const INFLIGHT: usize = 1 << 20; /// The receiver's storage segment (`moq_net`'s crate-private `frame::SEGMENT`): a frame within /// one keeps its credit until it completes, and a larger one returns each segment's as it seals. const SEGMENT: usize = 1 << 20; -/// Why cells whose incomplete units overcommit the window are skipped: the quest that makes -/// `track::Subscriber` report each group it abandons, which their readers need to return its +/// Why cells whose incomplete units overcommit the window are skipped: their readers must +/// read through `track::Ordered`, which reports each group it abandons, to return its /// in-flight credit. -const OVERCOMMITTED: &str = "waits on quest/m2/group-drops.md"; +const OVERCOMMITTED: &str = "waits on quest/m3/receive-windows-evicted.md"; /// One benchmark configuration. #[derive(Clone, Copy)] @@ -1188,8 +1188,8 @@ async fn measure(cell: Cell, profile: Option, bytes: usize) /// /// Cells whose units overcommit the window are skipped, each printed with [`OVERCOMMITTED`] /// as the reason. They should keep their offered load and report what eviction cost them, but -/// the subscriber can abandon a group without handing it out, so its in-flight credit never -/// returns and the track's writer stalls. +/// the reader abandons a group without handing it out, so its in-flight credit never returns +/// and the track's writer stalls, until it reads the gaps `track::Ordered` reports. #[tokio::test(flavor = "multi_thread")] #[ignore = "release benchmark, run by nightly"] async fn benchmark_receive_windows() { diff --git a/rs/moq-transcode/src/lib.rs b/rs/moq-transcode/src/lib.rs index d0d62c4089a..58d4c9b1a64 100644 --- a/rs/moq-transcode/src/lib.rs +++ b/rs/moq-transcode/src/lib.rs @@ -502,7 +502,7 @@ mod tests { group.close().unwrap(); for (name, subscriber) in &mut subscribers { - let mut group = subscriber.next_group().await.unwrap().unwrap(); + let mut group = subscriber.next_group().await.unwrap().unwrap().group().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() { @@ -1005,7 +1005,7 @@ mod tests { .await .unwrap() .ordered(); - let mut group = subscriber.next_group().await.unwrap().unwrap(); + let mut group = subscriber.next_group().await.unwrap().unwrap().group().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(); @@ -1108,7 +1108,7 @@ mod tests { .await .unwrap() .ordered(); - let mut group = live.next_group().await.unwrap().unwrap(); + let mut group = live.next_group().await.unwrap().unwrap().group().unwrap(); assert!(group.read_frame().await.unwrap().is_some()); transcoder.abort(); @@ -1157,7 +1157,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(); + let mut group = subscriber.next_group().await.unwrap().unwrap().group().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 44374730a4d..a0877f8d6c3 100644 --- a/rs/moq-transcode/src/rung.rs +++ b/rs/moq-transcode/src/rung.rs @@ -883,7 +883,11 @@ 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(group) = groups.next_group().await? { + 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; + }; 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 df011da6aba..f29076ec3d3 100644 --- a/test/interop/clients/rust/hls.rs +++ b/test/interop/clients/rust/hls.rs @@ -145,7 +145,11 @@ 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(mut group) = groups.next_group().await? { + 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; + }; let Some(frame) = group.read_frame().await? else { continue; }; diff --git a/test/interop/clients/rust/socket-js.rs b/test/interop/clients/rust/socket-js.rs index 5fd37c47a8f..ab38cd224a5 100644 --- a/test/interop/clients/rust/socket-js.rs +++ b/test/interop/clients/rust/socket-js.rs @@ -56,7 +56,11 @@ async fn main() -> anyhow::Result<()> { if dial { stream.producer.write_frame(key(i), vec![own + i])?; } - let mut group = reader.next_group().await?.context("short track half")?; + let mut group = reader + .next_group() + .await? + .and_then(moq_net::track::Item::group) + .context("short track half")?; ensure!(group.start == u64::from(i), "wrong group key"); let frame = group.read_frame().await?.context("empty track message")?; ensure!(frame.payload.as_ref() == [peer + i], "wrong track frame"); @@ -80,7 +84,11 @@ async fn main() -> anyhow::Result<()> { ensure!(reset_reader.next_group().await.is_err(), "track RST became FIN"); eprintln!("socket reset verified dial"); } else { - let mut group = reset_reader.next_group().await?.context("missing reset signal")?; + let mut group = reset_reader + .next_group() + .await? + .and_then(moq_net::track::Item::group) + .context("missing reset signal")?; ensure!( group .read_frame() diff --git a/test/interop/clients/rust/socket.rs b/test/interop/clients/rust/socket.rs index d75a63ed1e1..5ac195d69fd 100644 --- a/test/interop/clients/rust/socket.rs +++ b/test/interop/clients/rust/socket.rs @@ -61,7 +61,11 @@ async fn main() -> anyhow::Result<()> { } let _producer = producer.finish()?; for start in 0..3 { - let mut next = consumer.next_group().await?.context("short track")?; + let mut next = consumer + .next_group() + .await? + .and_then(moq_net::track::Item::group) + .context("short track")?; ensure!(next.start == start, "wrong group order"); group(&mut next).await?; } From dbb75363af36706a6c0f9cff0bd3f344461cd196 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 06:55:02 -0800 Subject: [PATCH 3/9] fix(net): an ordered read applies moved ranges to what it holds and queues every gap Co-Authored-By: Claude Sonnet 5.5 --- rs/moq-net/src/model/track.rs | 193 +++++++++++++++++++++++++--------- 1 file changed, 144 insertions(+), 49 deletions(-) diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 3d75981eb84..9d7a7961471 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -10187,7 +10187,7 @@ impl Subscriber { Ordered { inner: self, held: None, - gap: None, + gaps: BTreeMap::new(), at: 0, started: false, idle: None, @@ -10821,8 +10821,9 @@ pub struct Ordered { inner: Subscriber, /// A group read and not yet returned, because a gap below it goes first. held: Option>, - /// The lowest gap found and not yet returned. - gap: Option<(ops::Range, Error)>, + /// The gaps found and not yet returned, as `start => (end, error)`. They never overlap, and + /// a drop found while others wait goes in order among them. + gaps: BTreeMap, /// One past the highest key returned, as a group or the end of a gap. at: u64, /// Whether the drop record exists. It holds only what happened after it began, so it @@ -10902,60 +10903,94 @@ impl Ordered { self.started = true; self.find_gap(true, waiter); } - let read = match self.held.take() { - Some(group) => Poll::Ready(Ok(Some(*group))), - None => { - let read = self.inner.poll_next_group(waiter); - if let Poll::Ready(Ok(Some(group))) = &read { - // Handed out, so no later cut or drop of it is a gap. - self.inner.settle(group.start); - } - read - } - }; + let read = self.read(waiter); // After the read, which judged what it walked past: a group it handed out leaves only // what that queued, and anything else judges the live edge for the gaps it parks on. self.find_gap(!matches!(read, Poll::Ready(Ok(Some(_)))), waiter); match read { - Poll::Ready(Ok(Some(group))) => match self.gap.take() { - // The gap lies wholly below it, or around it: the part below goes first. - Some((range, error)) if range.start < group.start => { - let key = group.start; - let above = key.saturating_add(1)..range.end; - if !above.is_empty() { - self.gap = Some((above, error.clone())); + Poll::Ready(Ok(Some(group))) => { + let key = group.start; + match self.lowest_gap() { + // The gap lies wholly below it, or around it: the part below goes first. + Some((at, span)) if span.start < key => { + let (end, error) = self.gaps.remove(&at).expect("the lowest gap is held"); + if end > key.saturating_add(1) { + self.gaps.insert(key + 1, (end, error.clone())); + } + self.held = Some(Box::new(group)); + Poll::Ready(Ok(Some(self.give(span.start..span.end.min(key), error)))) + } + // A group handed out is no gap, even one a drop also named, as a cut group is. + lowest => { + if let Some((at, span)) = lowest + && span.start == key + { + let (end, error) = self.gaps.remove(&at).expect("the lowest gap is held"); + if end > key.saturating_add(1) { + self.gaps.insert(key + 1, (end, error)); + } + } + self.at = self.at.max(key.saturating_add(1)); + Poll::Ready(Ok(Some(Item::Group(group)))) } - self.held = Some(Box::new(group)); - Poll::Ready(Ok(Some(self.give(range.start..range.end.min(key), error)))) - } - // A group handed out is no gap, even one a drop also named, as a cut group is. - gap => { - self.gap = gap.and_then(|(range, error)| { - let range = range.start.max(group.start.saturating_add(1))..range.end; - (!range.is_empty()).then_some((range, error)) - }); - self.at = self.at.max(group.start.saturating_add(1)); - Poll::Ready(Ok(Some(Item::Group(group)))) } - }, - // What the read still owes lies above the gap, so the gap goes first. - Poll::Pending if self.gap_is_next() => { - let (range, error) = self.gap.take().expect("a gap is held"); - Poll::Ready(Ok(Some(self.give(range, error)))) } - Poll::Pending => Poll::Pending, + // What the read still owes lies above the gap, so the gap goes first. + Poll::Pending => match self.next_gap() { + Some(item) => Poll::Ready(Ok(Some(item))), + None => Poll::Pending, + }, // Every gap is returned before the end. - Poll::Ready(end) => match self.gap.take() { - Some((range, error)) => Poll::Ready(Ok(Some(self.give(range, error)))), + Poll::Ready(end) => match self.lowest_gap() { + Some((at, span)) => Poll::Ready(Ok(Some(self.take_gap(at, span)))), None => Poll::Ready(end.map(|_| None)), }, } } - /// Look for the lowest gap, if none is held. + /// The next group in key order: the one held behind a gap, if the ranges still cover it. + fn read(&mut self, waiter: &kio::Waiter) -> Poll>> { + if let Some(group) = self.held.take() { + let key = group.start; + if !self.inner.runs_in_range(key, key.saturating_add(1)).is_empty() { + return Poll::Ready(Ok(Some(*group))); + } + // A range moved off it. With nothing in range above, it waits for the range to widen + // again, and the read ends as capped ranges do; otherwise the read passes it. + if self.inner.runs_in_range(key, u64::MAX).is_empty() { + self.held = Some(group); + return Poll::Ready(Ok(None)); + } + } + let read = self.inner.poll_next_group(waiter); + if let Poll::Ready(Ok(Some(group))) = &read { + // Handed out, so no later cut or drop of it is a gap. + self.inner.settle(group.start); + } + read + } + + /// The lowest gap the ranges cover now, as its key in `gaps` and the keys of it they cover, + /// since they may have moved since it was found. Disjoint ranges leave the span from the + /// first run to the last. A gap they exclude waits, in case they widen again. + fn lowest_gap(&mut self) -> Option<(u64, ops::Range)> { + let gaps: Vec<_> = self.gaps.iter().map(|(start, (end, _))| (*start, *end)).collect(); + gaps.into_iter().find_map(|(start, end)| { + let runs = self.inner.runs_in_range(start, end); + Some((start, runs.first()?.start..runs.last()?.end)) + }) + } + + /// Take the gap `lowest_gap` found, as an item. + fn take_gap(&mut self, at: u64, span: ops::Range) -> Item { + let (_, error) = self.gaps.remove(&at).expect("the lowest gap is held"); + self.give(span, error) + } + + /// Look for every drop recorded, in whatever order they come. fn find_gap(&mut self, judge: bool, waiter: &kio::Waiter) { self.inner.note_late(); - while self.gap.is_none() { + loop { let polled = match judge { true => self.inner.poll_drop(waiter), false => self.inner.poll_queued_drop(waiter), @@ -10965,17 +11000,16 @@ impl Ordered { }; // A skip was never a group: nothing was given up. if let Hole::Drop { error, .. } = hole { - self.gap = Some((range, error.into())); + self.gaps.insert(range.start, (range.end, error.into())); } } } - /// Whether the held gap may go out now: nothing the read still owes lies below it. - fn gap_is_next(&self) -> bool { - let Some((range, _)) = &self.gap else { - return false; - }; - range.start <= self.at || self.inner.next_in_range(self.at).is_none_or(|owed| owed >= range.start) + /// The lowest gap, once nothing the read still owes lies below it. + fn next_gap(&mut self) -> Option { + let (at, span) = self.lowest_gap()?; + let ready = span.start <= self.at || self.inner.next_in_range(self.at).is_none_or(|owed| owed >= span.start); + ready.then(|| self.take_gap(at, span)) } /// A gap as an item, which the read has now moved past. @@ -18840,6 +18874,67 @@ mod test { assert_eq!(items(&mut ordered), ["gap 2..4 (delivery timeout)", "pending"]); } + /// A drop found while a higher gap waits goes out first, in key order, rather than staying + /// hidden behind it. + #[test] + #[cfg(feature = "async")] + fn a_lower_drop_found_late_goes_before_a_buffered_gap() { + let producer = received_producer(None); + let mut ordered = producer + .subscribe(Subscription::default().with_delay(Delay::default().with_max(None))) + .ordered(); + put(&producer, 0, None); + put(&producer, 2, None); + producer.drop_groups(4..5, StreamError::DeliveryTimeout); + assert_eq!(items(&mut ordered), ["group 0", "pending"]); + producer.drop_groups(1..2, StreamError::DeliveryTimeout); + assert_eq!( + items(&mut ordered), + ["gap 1..2 (delivery timeout)", "group 2", "pending"] + ); + put(&producer, 3, None); + assert_eq!( + items(&mut ordered), + ["group 3", "gap 4..5 (delivery timeout)", "pending"] + ); + } + + /// A range narrowed after a gap went out ahead of a group read keeps that group back, + /// handing it out again once the range widens, and clips the gaps still waiting. + #[test] + #[cfg(feature = "async")] + fn a_range_moved_after_a_gap_applies_to_what_is_buffered() { + let producer = track_producer("test", None); + let mut ordered = producer.subscribe(replay()).ordered(); + 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(); + assert!(matches!(first, Item::Gap { range, .. } if range == (0..2))); + ordered.set_range(..2); + assert_eq!(items(&mut ordered), Vec::::new(), "capped below the held group"); + ordered.set_range(..4); + assert_eq!( + items(&mut ordered), + ["group 2", "gap 3..4 (delivery timeout)", "pending"], + "the held group returns, and the gap above is clipped to the range" + ); + + let producer = track_producer("test", None); + let mut ordered = producer.subscribe(replay()).ordered(); + 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(); + assert!(matches!(first, Item::Gap { range, .. } if range == (0..2))); + ordered.set_range(3..); + assert_eq!( + items(&mut ordered), + ["group 3", "pending"], + "a floor raised over the held group passes it" + ); + } + /// The wait follows the reader's budget: a zero budget waits for nothing, a budget /// narrowed mid-wait ends it, and an unbounded one waits until the hole resolves. #[test] From 9699e408af865a39f38c9efa440f265db2d29831 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 07:03:18 -0800 Subject: [PATCH 4/9] fix(net): a clipped gap keeps what the ranges leave out, and returns one covered run at a time Co-Authored-By: Claude Sonnet 5.5 --- rs/moq-net/src/model/track.rs | 73 +++++++++++++++++++++++++++-------- 1 file changed, 56 insertions(+), 17 deletions(-) diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 9d7a7961471..d0a729cb8f5 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -10913,21 +10913,26 @@ impl Ordered { match self.lowest_gap() { // The gap lies wholly below it, or around it: the part below goes first. Some((at, span)) if span.start < key => { - let (end, error) = self.gaps.remove(&at).expect("the lowest gap is held"); - if end > key.saturating_add(1) { - self.gaps.insert(key + 1, (end, error.clone())); - } + // What lies above the group, or above the run when it ends before it, waits. + let resume = if span.end <= key { + span.end + } else { + key.saturating_add(1) + }; + let below = span.start..span.end.min(key); + let item = self.take_gap(at, below, resume); self.held = Some(Box::new(group)); - Poll::Ready(Ok(Some(self.give(span.start..span.end.min(key), error)))) + Poll::Ready(Ok(Some(item))) } // A group handed out is no gap, even one a drop also named, as a cut group is. lowest => { if let Some((at, span)) = lowest && span.start == key { + let resume = key.saturating_add(1); let (end, error) = self.gaps.remove(&at).expect("the lowest gap is held"); - if end > key.saturating_add(1) { - self.gaps.insert(key + 1, (end, error)); + if end > resume { + self.gaps.insert(resume, (end, error)); } } self.at = self.at.max(key.saturating_add(1)); @@ -10942,7 +10947,10 @@ impl Ordered { }, // Every gap is returned before the end. Poll::Ready(end) => match self.lowest_gap() { - Some((at, span)) => Poll::Ready(Ok(Some(self.take_gap(at, span)))), + Some((at, span)) => { + let resume = span.end; + Poll::Ready(Ok(Some(self.take_gap(at, span, resume)))) + } None => Poll::Ready(end.map(|_| None)), }, } @@ -10970,21 +10978,25 @@ impl Ordered { read } - /// The lowest gap the ranges cover now, as its key in `gaps` and the keys of it they cover, - /// since they may have moved since it was found. Disjoint ranges leave the span from the - /// first run to the last. A gap they exclude waits, in case they widen again. + /// The lowest run of a gap the ranges cover now, as the gap's key in `gaps` and the keys of + /// it that run covers, since the ranges may have moved since the gap was found. A gap they + /// exclude waits, in case they widen again. fn lowest_gap(&mut self) -> Option<(u64, ops::Range)> { let gaps: Vec<_> = self.gaps.iter().map(|(start, (end, _))| (*start, *end)).collect(); gaps.into_iter().find_map(|(start, end)| { let runs = self.inner.runs_in_range(start, end); - Some((start, runs.first()?.start..runs.last()?.end)) + Some((start, runs.into_iter().next()?)) }) } - /// Take the gap `lowest_gap` found, as an item. - fn take_gap(&mut self, at: u64, span: ops::Range) -> Item { - let (_, error) = self.gaps.remove(&at).expect("the lowest gap is held"); - self.give(span, error) + /// Take `given` from the gap `lowest_gap` found, as an item. What lies from `resume` on stays + /// a gap, to be clipped and returned later. + fn take_gap(&mut self, at: u64, given: ops::Range, resume: u64) -> Item { + let (end, error) = self.gaps.remove(&at).expect("the lowest gap is held"); + if end > resume { + self.gaps.insert(resume, (end, error.clone())); + } + self.give(given, error) } /// Look for every drop recorded, in whatever order they come. @@ -11009,7 +11021,8 @@ impl Ordered { fn next_gap(&mut self) -> Option { let (at, span) = self.lowest_gap()?; let ready = span.start <= self.at || self.inner.next_in_range(self.at).is_none_or(|owed| owed >= span.start); - ready.then(|| self.take_gap(at, span)) + let resume = span.end; + ready.then(|| self.take_gap(at, span, resume)) } /// A gap as an item, which the read has now moved past. @@ -18935,6 +18948,32 @@ mod test { ); } + /// A gap a moved range only partly covers returns that part, and the rest stays for the + /// range to widen over. + #[test] + #[cfg(feature = "async")] + fn a_moved_range_returns_a_buffered_gap_by_the_part_it_covers() { + let producer = track_producer("test", None); + let mut ordered = producer.subscribe(replay()).ordered(); + 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(); + assert!(matches!(first, Item::Gap { range, .. } if range == (0..2))); + ordered.set_range(..4); + assert_eq!( + items(&mut ordered), + ["group 2", "gap 3..4 (delivery timeout)", "pending"], + "capped inside the gap" + ); + ordered.set_range(..); + assert_eq!( + items(&mut ordered), + ["gap 4..6 (delivery timeout)", "pending"], + "widening returns the rest" + ); + } + /// The wait follows the reader's budget: a zero budget waits for nothing, a budget /// narrowed mid-wait ends it, and an unbounded one waits until the hole resolves. #[test] From df94debc18cc18e9c7fd4193c0013fcaf8b1ae14 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 19:55:47 -0800 Subject: [PATCH 5/9] fix(net): a front's late arrival the ranges leave out is no gap, and draining gaps stops copying the queue --- rs/moq-net/src/model/resume.rs | 35 +++++++++++++++++++++ rs/moq-net/src/model/track.rs | 31 ++++++++++-------- rs/moq-net/tests/integration/drop_record.rs | 6 ++-- 3 files changed, 57 insertions(+), 15 deletions(-) diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 9be86dc63c7..6f22501ce89 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -5498,6 +5498,41 @@ mod test { assert_eq!(read(&mut sub), ["group 6"]); } + /// A late arrival the reader's ranges leave out is no gap of its own: it is neither reported + /// nor held, and widening the ranges offers it as the group it is. + #[test] + fn a_front_ignores_a_late_arrival_its_ranges_exclude() { + let routes = Producer::new(); + let logical = logical(&routes); + let a = copy(); + routes.serve(a.consume()); + let mut sub = subscribe(&logical, HOUR).ordered().with_range(50..); + 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) { + items.push(match item { + track::Item::Group(group) => format!("group {}", group.start), + track::Item::Gap { range, error } => format!("gap {range:?} ({error})"), + }); + } + items + }; + write(&a, 50); + write(&a, 60); + assert_eq!(read(&mut sub), ["group 50", "group 60"]); + for key in (0..40).step_by(2) { + write(&a, key); + assert!(read(&mut sub).is_empty(), "group {key} is outside the ranges"); + } + let mut sub = sub.with_range(..); + let widened = read(&mut sub); + assert!( + widened.iter().all(|item| item.starts_with("group")), + "widening offers groups, not gaps: {widened:?}" + ); + } + /// Lowering a front reader's local floor offers the cached groups below the old one it /// passed over, as a plain reader does. #[test] diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 48f4dcd1ff7..2a328edd181 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -10263,15 +10263,18 @@ impl Subscriber { /// never hands out, as given up `Old`. A group it handed out or judged stale is already /// settled, so the record blocks it. fn note_late(&mut self) { - let (record, late) = match &mut self.inner { - Inner::Plain(cursor) => { - let late = cursor.late(cursor.next_key); - (&mut cursor.record, late) - } - Inner::Resume(resume, logical) => { - let late = resume.late(logical.record.delivered.floor()); - (&mut logical.record, late) - } + let mut late = match &mut self.inner { + Inner::Plain(cursor) => cursor.late(cursor.next_key), + Inner::Resume(resume, logical) => resume.late(logical.record.delivered.floor()), + }; + // A copy's window can be wider than this reader's ranges and bounds, so a late key they + // leave out is no gap of this reader's, as the plain path's window already clips it. + if matches!(self.inner, Inner::Resume(..)) { + late.retain(|key| !self.runs_in_range(*key, key.saturating_add(1)).is_empty()); + } + let record = match &mut self.inner { + Inner::Plain(cursor) => &mut cursor.record, + Inner::Resume(_, logical) => &mut logical.record, }; for key in late { if let Some(end) = key.checked_add(1) { @@ -11106,10 +11109,12 @@ impl Ordered { /// it that run covers, since the ranges may have moved since the gap was found. A gap they /// exclude waits, in case they widen again. fn lowest_gap(&mut self) -> Option<(u64, ops::Range)> { - let gaps: Vec<_> = self.gaps.iter().map(|(start, (end, _))| (*start, *end)).collect(); - gaps.into_iter().find_map(|(start, end)| { - let runs = self.inner.runs_in_range(start, end); - Some((start, runs.into_iter().next()?)) + // The fields borrow apart, so the map is walked in place and the walk stops at the + // first gap the ranges cover. + let Self { inner, gaps, .. } = self; + gaps.iter().find_map(|(start, (end, _))| { + let runs = inner.runs_in_range(*start, *end); + Some((*start, runs.into_iter().next()?)) }) } diff --git a/rs/moq-net/tests/integration/drop_record.rs b/rs/moq-net/tests/integration/drop_record.rs index 20d4a282740..f2a7fbd2d22 100644 --- a/rs/moq-net/tests/integration/drop_record.rs +++ b/rs/moq-net/tests/integration/drop_record.rs @@ -481,8 +481,10 @@ async fn an_ordered_reader_is_told_of_every_group_the_origin_evicted() { const WRITTEN: u64 = 4; for versions in [[LITE06, LITE06], [LITE07, LITE07]] { kio::clock::timeout(TIMEOUT * 10, async { - // One stream of credit, held from the relay, so the groups queue until reclaimed. - let chain = Chain::with_credit(versions, [expiring(EXPIRY), forever(), forever()], Some(1)).await; + // One stream of credit past the Announce Stream that lite-07 holds: group 0's, held from the relay, + // so the rest queue. + let credit = if versions == [LITE07, LITE07] { 2 } else { 1 }; + let chain = Chain::with_credit(versions, [expiring(EXPIRY), forever(), forever()], Some(credit)).await; // A budget bounds the wait on a group a hop judged stale; none would fill it instead. let mut reader = chain .subscribe(reading(Duration::from_secs(3600), [support::keys(0..)])) From bbc9c61cdd5b355f8978f5ad87557e32c44a6606 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 20:14:41 -0800 Subject: [PATCH 6/9] fix(net): a gap is returned once, and a skip removes the gaps waiting under it Co-Authored-By: Claude Sonnet 5.5 --- rs/moq-net/src/model/track.rs | 97 ++++++++++++++++++++++++++++++++--- 1 file changed, 91 insertions(+), 6 deletions(-) diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 2a328edd181..f84ccbcae82 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -10285,13 +10285,18 @@ impl Subscriber { /// Record `key` as served, so no cut or drop of it is reported afterwards. fn settle(&mut self, key: u64) { + if let Some(end) = key.checked_add(1) { + self.settle_range(key..end); + } + } + + /// Record `keys` as served or reported, so no cut or drop of them is reported again. + fn settle_range(&mut self, keys: ops::Range) { let record = match &mut self.inner { Inner::Plain(cursor) => &mut cursor.record, Inner::Resume(_, logical) => &mut logical.record, }; - if let Some(end) = key.checked_add(1) { - record.tell(key..end, Report::Settled); - } + record.tell(keys, Report::Settled); } /// The key cursor behind [`Ordered`], which owns the only public door to it. @@ -11139,9 +11144,35 @@ impl Ordered { let Poll::Ready((range, hole)) = polled else { return; }; - // A skip was never a group: nothing was given up. - if let Hole::Drop { error, .. } = hole { - self.gaps.insert(range.start, (range.end, error.into())); + match hole { + Hole::Drop { error, .. } => { + self.gaps.insert(range.start, (range.end, error.into())); + } + // A skip was never a group: nothing was given up, and it replaces a drop + // still waiting. + Hole::Skip => self.forget_gaps(range), + } + } + } + + /// Remove `skipped` from the gaps waiting, splitting those it only partly covers. + fn forget_gaps(&mut self, skipped: ops::Range) { + // The gaps never overlap, so their ends rise with their starts: walk down from the + // highest one that starts below the skip's end, and stop at the first that ends before it. + let hit: Vec = self + .gaps + .range(..skipped.end) + .rev() + .take_while(|(_, (end, _))| *end > skipped.start) + .map(|(start, _)| *start) + .collect(); + for start in hit { + let (end, error) = self.gaps.remove(&start).expect("the gap was just found"); + if start < skipped.start { + self.gaps.insert(start, (skipped.start, error.clone())); + } + if end > skipped.end { + self.gaps.insert(skipped.end, (end, error)); } } } @@ -11157,6 +11188,8 @@ impl Ordered { /// A gap as an item, which the read has now moved past. fn give(&mut self, range: ops::Range, error: Error) -> Item { self.at = self.at.max(range.end); + // Told once: no later drop of these keys is a gap again. + self.inner.settle_range(range.clone()); Item::Gap { range, error } } @@ -19362,6 +19395,58 @@ mod test { ); } + /// A gap returned is told once: a later drop of the same keys, even a final one that would + /// replace a stale report on the wire, is no second gap. + #[test] + #[cfg(feature = "async")] + fn a_gap_is_returned_once() { + let producer = received_producer(None); + let budget = Duration::from_millis(50); + let mut ordered = producer + .subscribe(Subscription::default().with_delay(Delay::default().with_max(budget))) + .ordered(); + put(&producer, 0, None); + put(&producer, 2, None); + assert_eq!(items(&mut ordered), ["group 0", "pending"]); + // The budget gives up on the group still owed, as stale. + elapse(&producer, budget); + assert_eq!(items(&mut ordered), ["gap 1..2 (old)", "group 2", "pending"]); + producer.drop_groups(1..2, StreamError::DeliveryTimeout); + put(&producer, 3, None); + assert_eq!(items(&mut ordered), ["group 3", "pending"]); + } + + /// A skip replaces a drop still waiting for the groups below it, so the keys it names are + /// no gap, and the part of a drop it leaves still is. + #[test] + #[cfg(feature = "async")] + fn a_skip_replaces_a_buffered_gap() { + let producer = received_producer(None); + let mut ordered = producer + .subscribe(Subscription::default().with_delay(Delay::default().with_max(None))) + .ordered(); + put(&producer, 0, None); + put(&producer, 2, None); + producer.drop_groups(4..8, StreamError::DeliveryTimeout); + assert_eq!(items(&mut ordered), ["group 0", "pending"]); + producer.skip_groups(5..7); + producer.drop_groups(1..2, StreamError::DeliveryTimeout); + assert_eq!( + items(&mut ordered), + ["gap 1..2 (delivery timeout)", "group 2", "pending"] + ); + put(&producer, 3, None); + assert_eq!( + items(&mut ordered), + [ + "group 3", + "gap 4..5 (delivery timeout)", + "gap 7..8 (delivery timeout)", + "pending" + ] + ); + } + /// A group landing after the read passed its key is given up as old, since the read never /// goes back; the group it was passed for is no gap. #[test] From 6b14a869c7a184de622ea3b3500f4604e5602501 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 23:15:34 -0800 Subject: [PATCH 7/9] fix(net): a key seek reports the stale groups it passes, and buffered gaps keep what clipping and replacement leave Co-Authored-By: Claude Sonnet 5.5 --- rs/moq-mux/src/container/ts/si.rs | 5 +- rs/moq-net/src/model/resume.rs | 29 ++++++++ rs/moq-net/src/model/track.rs | 106 ++++++++++++++++++++++++------ 3 files changed, 118 insertions(+), 22 deletions(-) diff --git a/rs/moq-mux/src/container/ts/si.rs b/rs/moq-mux/src/container/ts/si.rs index 2ed2287597c..5c4d75fc4b5 100644 --- a/rs/moq-mux/src/container/ts/si.rs +++ b/rs/moq-mux/src/container/ts/si.rs @@ -823,7 +823,10 @@ mod tests { let waiter = kio::Waiter::noop(); let mut read = Vec::new(); while let std::task::Poll::Ready(Ok(Some(item))) = reader.poll_next_group(&waiter) { - read.push(item.group().expect("a group").start); + // A group given up on is a gap, which reads no group. + if let Some(group) = item.group() { + read.push(group.start); + } } assert_eq!(read, expected); } diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 6f22501ce89..5952dcdbe7a 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -5498,6 +5498,35 @@ mod test { assert_eq!(read(&mut sub), ["group 6"]); } + /// A front served by another front reports a late arrival on the inner copy too. + #[test] + fn a_nested_front_reports_a_late_arrival_as_a_gap() { + let inner_routes = Producer::new(); + let inner = logical(&inner_routes); + let b = copy(); + inner_routes.serve(b.consume()); + let routes = Producer::new(); + let outer = logical(&routes); + routes.serve(inner.consume()); + let mut sub = subscribe(&outer, HOUR).ordered(); + 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) { + items.push(match item { + track::Item::Group(group) => format!("group {}", group.start), + track::Item::Gap { range, error } => format!("gap {range:?} ({error})"), + }); + } + items + }; + write(&b, 0); + write(&b, 5); + assert_eq!(read(&mut sub), ["group 0", "group 5"]); + write(&b, 3); + assert_eq!(read(&mut sub), ["gap 3..4 (old)"]); + } + /// A late arrival the reader's ranges leave out is no gap of its own: it is neither reported /// nor held, and widening the ranges offers it as the group it is. #[test] diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index f84ccbcae82..748272f7176 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -8048,8 +8048,9 @@ struct Cursor { /// [`Subscriber`], which drains this after every read. stale: stats::Content, /// Groups the seek path has convicted but whose keys no caller has committed - /// past yet, keyed by key; see [`Self::commit_seek_stale`]. - seek_pending: BTreeMap, + /// past yet, keyed by key, with the budget that convicted each; see + /// [`Self::commit_seek_stale`]. + seek_pending: BTreeMap, /// What this cursor handed out, skipped, gave up, and reported. record: Record, /// The drops a wire publisher forwards, once it first polls for one. @@ -9641,7 +9642,7 @@ impl Cursor { // the edge can be evicted), so the group may still be delivered. // Re-snapshot on every re-examination so the eventual count reflects the // group's latest observed content. - self.seek_pending.insert(group.start, group.content()); + self.seek_pending.insert(group.start, (group.content(), drift.budget)); floor = group.start.saturating_add(1); continue; } @@ -9708,8 +9709,15 @@ impl Cursor { /// then be delivered after all. fn commit_seek_stale(&mut self, committed: u64) { let keep = self.seek_pending.split_off(&committed); - for (_, content) in std::mem::replace(&mut self.seek_pending, keep) { + for (key, (content, budget)) in std::mem::replace(&mut self.seek_pending, keep) { self.stale.add(content); + // Given up for good now, so it is as reported as a write-off is: a key-order + // reader tells its caller the group will not come. + if self.drops.is_some() + && let Some(end) = key.checked_add(1) + { + self.record.pending.insert(key..end, Pending::own(Hole::stale(budget))); + } } } } @@ -10255,7 +10263,7 @@ impl Subscriber { pub(super) fn late(&mut self, below: u64) -> Vec { match &mut self.inner { Inner::Plain(cursor) => cursor.late(below), - Inner::Resume(..) => Vec::new(), + Inner::Resume(resume, _) => resume.late(below), } } @@ -11061,11 +11069,7 @@ impl Ordered { if let Some((at, span)) = lowest && span.start == key { - let resume = key.saturating_add(1); - let (end, error) = self.gaps.remove(&at).expect("the lowest gap is held"); - if end > resume { - self.gaps.insert(resume, (end, error)); - } + self.cut_gap(at, span.start, key.saturating_add(1)); } self.at = self.at.max(key.saturating_add(1)); Poll::Ready(Ok(Some(Item::Group(group)))) @@ -11124,13 +11128,24 @@ impl Ordered { } /// Take `given` from the gap `lowest_gap` found, as an item. What lies from `resume` on stays - /// a gap, to be clipped and returned later. + /// a gap, to be clipped and returned later, as does what lies below `given`. fn take_gap(&mut self, at: u64, given: ops::Range, resume: u64) -> Item { + let error = self.cut_gap(at, given.start, resume); + self.give(given, error) + } + + /// Remove `from..resume` from the gap held at `at`, returning its error. What lies below + /// `from`, which the ranges leave out, and from `resume` on stay gaps, to be clipped and + /// returned later. + fn cut_gap(&mut self, at: u64, from: u64, resume: u64) -> Error { let (end, error) = self.gaps.remove(&at).expect("the lowest gap is held"); + if at < from { + self.gaps.insert(at, (from, error.clone())); + } if end > resume { self.gaps.insert(resume, (end, error.clone())); } - self.give(given, error) + error } /// Look for every drop recorded, in whatever order they come. @@ -11146,6 +11161,8 @@ impl Ordered { }; match hole { Hole::Drop { error, .. } => { + // A final drop replaces a stale one still waiting, rather than overlap it. + self.forget_gaps(range.clone()); self.gaps.insert(range.start, (range.end, error.into())); } // A skip was never a group: nothing was given up, and it replaces a drop @@ -16380,15 +16397,8 @@ mod test { let mut subscriber = producer.subscribe(Subscription::default().with_range(0..2)); assert_eq!(drain(&mut subscriber), vec![1]); let mut subscriber = producer.subscribe(Subscription::default().with_range(0..2)).ordered(); - let next = subscriber - .next_group() - .now_or_never() - .unwrap() - .unwrap() - .unwrap() - .group() - .unwrap(); - assert_eq!(next.start, 1); + // Group 0 is stale against it, which the read reports before the group. + assert_eq!(items(&mut subscriber), ["gap 0..1 (old)", "group 1"]); // A budget that covers it delivers the range, and nothing above it. let mut subscriber = producer.subscribe(replay().with_end(2)); @@ -19449,6 +19459,60 @@ mod test { /// A group landing after the read passed its key is given up as old, since the read never /// goes back; the group it was passed for is no gap. + #[test] + #[cfg(feature = "async")] + fn a_cached_group_the_seek_passes_as_stale_is_a_gap() { + let producer = received_producer(None); + put(&producer, 0, None); + put(&producer, 1, None); + elapse(&producer, Duration::from_millis(100)); + put(&producer, 2, None); + let budget = Duration::from_millis(50); + let mut ordered = producer + .subscribe(Subscription::default().with_delay(Delay::default().with_max(budget))) + .ordered(); + assert_eq!(items(&mut ordered), ["gap 0..1 (old)", "group 1", "group 2", "pending"]); + } + + /// A final drop replaces the part of a stale gap it covers while that gap still waits, so + /// the buffered gaps never overlap: the stale run keeps what lies either side of it. + #[test] + #[cfg(feature = "async")] + fn a_buffered_gap_gives_way_to_what_replaces_it() { + let producer = received_producer(None); + let mut ordered = producer.subscribe(replay()).ordered(); + ordered.gaps.insert(4, (8, StreamError::Old.into())); + ordered.forget_gaps(5..7); + ordered.gaps.insert(5, (7, StreamError::DeliveryTimeout.into())); + let held: Vec<_> = ordered.gaps.iter().map(|(start, (end, _))| (*start, *end)).collect(); + assert_eq!(held, [(4, 5), (5, 7), (7, 8)]); + ordered.forget_gaps(0..100); + assert!(ordered.gaps.is_empty()); + } + + /// What a range excludes from a gap that is partly covered stays a gap, so a range that + /// widens again over it reports it. + #[test] + #[cfg(feature = "async")] + fn a_gap_a_range_clips_keeps_what_the_range_excluded() { + let producer = received_producer(None); + let mut ordered = producer + .subscribe(Subscription::default().with_delay(Delay::default().with_max(None))) + .ordered(); + 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(); + 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"]); + ordered.set_range(..); + assert_eq!( + items(&mut ordered), + ["gap 3..4 (delivery timeout)", "gap 5..6 (delivery timeout)", "pending"] + ); + } + #[test] #[cfg(feature = "async")] fn a_late_arrival_is_a_gap() { From 3887bbf5069bd6d21d5276b5022ee6c0698bc6f2 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 00:17:24 -0800 Subject: [PATCH 8/9] fix(net): a held group waits for a range that moved off it, and the front test pins that nothing is reported Co-Authored-By: Claude Sonnet 5.5 --- rs/moq-net/src/model/resume.rs | 6 +++--- rs/moq-net/src/model/track.rs | 10 +++++++--- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 5952dcdbe7a..276a5726b61 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -5528,7 +5528,7 @@ mod test { } /// A late arrival the reader's ranges leave out is no gap of its own: it is neither reported - /// nor held, and widening the ranges offers it as the group it is. + /// nor held, and widening the ranges does not report it later, as the read never goes back. #[test] fn a_front_ignores_a_late_arrival_its_ranges_exclude() { let routes = Producer::new(); @@ -5557,8 +5557,8 @@ mod test { let mut sub = sub.with_range(..); let widened = read(&mut sub); assert!( - widened.iter().all(|item| item.starts_with("group")), - "widening offers groups, not gaps: {widened:?}" + widened.is_empty(), + "an ordered read never goes back, so widening reports no gap and returns no group: {widened:?}" ); } diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 748272f7176..76c2c3efc0f 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -11100,10 +11100,10 @@ impl Ordered { return Poll::Ready(Ok(Some(*group))); } // A range moved off it. With nothing in range above, it waits for the range to widen - // again, and the read ends as capped ranges do; otherwise the read passes it. + // again, and the read waits or ends as it does for capped ranges; otherwise the read + // passes it. if self.inner.runs_in_range(key, u64::MAX).is_empty() { self.held = Some(group); - return Poll::Ready(Ok(None)); } } let read = self.inner.poll_next_group(waiter); @@ -19580,7 +19580,11 @@ mod test { let first = ordered.next_group().now_or_never().expect("ready").unwrap().unwrap(); assert!(matches!(first, Item::Gap { range, .. } if range == (0..2))); ordered.set_range(..2); - assert_eq!(items(&mut ordered), Vec::::new(), "capped below the held group"); + assert_eq!( + items(&mut ordered), + ["pending"], + "capped below the held group, which waits for the range" + ); ordered.set_range(..4); assert_eq!( items(&mut ordered), From 1b3a1ec60e051cd8f9b84ef3b86cda9368648b0f Mon Sep 17 00:00:00 2001 From: quest fixer Date: Tue, 17 Nov 2026 00:48:30 -0800 Subject: [PATCH 9/9] test: preserve group-only reads across ordered gap migration --- rs/moq-ffi/src/media.rs | 6 +++++- rs/moq-json/src/snapshot/mod.rs | 9 +++++++-- rs/moq-json/src/window/mod.rs | 9 +++++++-- rs/moq-transcode/src/lib.rs | 6 +++++- 4 files changed, 24 insertions(+), 6 deletions(-) diff --git a/rs/moq-ffi/src/media.rs b/rs/moq-ffi/src/media.rs index 5172f48f2fa..a3f4de2cfc6 100644 --- a/rs/moq-ffi/src/media.rs +++ b/rs/moq-ffi/src/media.rs @@ -2244,7 +2244,11 @@ mod timebase_tests { .await .unwrap() .ordered(); - let mut group = catalogs.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = loop { + if let Some(group) = catalogs.next_group().await.unwrap().unwrap().group() { + break group; + } + }; 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-json/src/snapshot/mod.rs b/rs/moq-json/src/snapshot/mod.rs index de62c1da534..9bd2f5e893e 100644 --- a/rs/moq-json/src/snapshot/mod.rs +++ b/rs/moq-json/src/snapshot/mod.rs @@ -1073,8 +1073,13 @@ mod test { )); let waiter = kio::Waiter::noop(); - let Poll::Ready(Ok(Some(moq_net::track::Item::Group(mut group)))) = subscriber.poll_next_group(&waiter) else { - panic!("the group was published, so a subscriber sees it"); + 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; + } }; assert!( matches!(group.poll_read_frame(&waiter), Poll::Ready(Ok(None))), diff --git a/rs/moq-json/src/window/mod.rs b/rs/moq-json/src/window/mod.rs index f511002ff9f..530ea035a6b 100644 --- a/rs/moq-json/src/window/mod.rs +++ b/rs/moq-json/src/window/mod.rs @@ -877,8 +877,13 @@ mod test { assert!(producer.window().is_empty()); let waiter = kio::Waiter::noop(); - let Poll::Ready(Ok(Some(moq_net::track::Item::Group(mut group)))) = subscriber.poll_next_group(&waiter) else { - panic!("the rejected group's header was published"); + 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; + } }; assert!(matches!(group.poll_read_frame(&waiter), Poll::Ready(Ok(None)))); } diff --git a/rs/moq-transcode/src/lib.rs b/rs/moq-transcode/src/lib.rs index 126a5f12a6b..c378a74280e 100644 --- a/rs/moq-transcode/src/lib.rs +++ b/rs/moq-transcode/src/lib.rs @@ -1120,7 +1120,11 @@ mod tests { .await .unwrap() .ordered(); - let mut group = live.next_group().await.unwrap().unwrap().group().unwrap(); + let mut group = loop { + if let Some(group) = live.next_group().await.unwrap().unwrap().group() { + break group; + } + }; assert!(group.read_frame().await.unwrap().is_some()); transcoder.abort();