From c09d7551894df9983b8bcf8d2a7aebc3ce1df672 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 03:32:23 -0700 Subject: [PATCH 1/4] chore(quest): claim quest/m1/slow-joiner-test.md Quest-Claim: 92a77cc27aa045bd From 96cebbdba47df6ceba01cc558a79cedeca40cbcf Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 03:36:38 -0700 Subject: [PATCH 2/4] test(moq-net): a stalled reader keeps every group its budget covers Co-Authored-By: Claude Opus 5.5 --- quest/m1/README.md | 1 - quest/m1/slow-joiner-test.md | 17 ---- rs/moq-net/tests/integration/main.rs | 1 + rs/moq-net/tests/integration/slow_joiner.rs | 105 ++++++++++++++++++++ 4 files changed, 106 insertions(+), 18 deletions(-) delete mode 100644 quest/m1/slow-joiner-test.md create mode 100644 rs/moq-net/tests/integration/slow_joiner.rs diff --git a/quest/m1/README.md b/quest/m1/README.md index 3f93058e5c5..41b2cf60e6c 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -121,7 +121,6 @@ removed). - [Resume checked against a model](/quest/m1/resume-model-test.md) - a randomized test checks every resumed reader against a one-track reference model in Rust and JS, and passes before the cut - [Recover by the reader's budget](/quest/m1/recover-reader-budget.md) - resume judges a missing group by each reader's own budget, not the copy's - [Rust resume release path](/quest/m1/resume-release-rust.md) - letting go of a replaced Rust copy never releases a group already moved to another -- [Slow joiner test](/quest/m1/slow-joiner-test.md) - a reader stalled before its first read loses no groups within its budget, under real stream backpressure - [Address groups by timestamp](/quest/m1/time-addressing/README.md) - group start timestamps replace sequence numbers in the moq-net API and lite-07 wire, while old subscribers, old publishers, and published JS clients keep working - [Release audit findings](/quest/m1/release-audit/README.md) - resolve newly identified resource, parser, playback, and interoperability risks before the cut - [Pre-cut audit findings](/quest/m1/cut-audit/README.md) - fix the crashes, hostile-input costs, and correctness bugs the 2026-10-24 audit of main found diff --git a/quest/m1/slow-joiner-test.md b/quest/m1/slow-joiner-test.md deleted file mode 100644 index f7b1f940868..00000000000 --- a/quest/m1/slow-joiner-test.md +++ /dev/null @@ -1,17 +0,0 @@ -# [S] A slow joiner loses no groups within its budget - -## Goal - -A test drives a reader that stalls before its first read, over a transport -with real stream-credit backpressure, and shows the relay drops none of the -groups its budget covers. - -## Plan - -Found by [moq-dev/moq#6990](https://github.com/moq-dev/moq/pull/6990): a -live-edge audio join subscribed with only its decoder warmup as its budget, -so a C reader starved before its first read lost its queued groups at the -relay. That PR's unit test checks the subscribe budget, not the relay path. -Use moq-net's mock harness with a capped stream count and mock time. - -Public API: none. diff --git a/rs/moq-net/tests/integration/main.rs b/rs/moq-net/tests/integration/main.rs index da3b6acc2b0..d952e25f1c4 100644 --- a/rs/moq-net/tests/integration/main.rs +++ b/rs/moq-net/tests/integration/main.rs @@ -53,6 +53,7 @@ mod session_close; mod session_panic; mod settled_end_survives_abort; mod setup_negotiation; +mod slow_joiner; mod source_errors; mod stream_credit; mod subscribe_priority; diff --git a/rs/moq-net/tests/integration/slow_joiner.rs b/rs/moq-net/tests/integration/slow_joiner.rs new file mode 100644 index 00000000000..a6495898e44 --- /dev/null +++ b/rs/moq-net/tests/integration/slow_joiner.rs @@ -0,0 +1,105 @@ +#![cfg(feature = "async")] + +//! A reader stalled before its first read, behind a relay serving it one stream at a time, +//! loses none of the groups its budget covers: they wait at the relay for stream credit. + +use std::collections::BTreeSet; +use std::time::Duration; + +use moq_net::{Hop, Timescale, Timestamp, Version, kio, origin, track}; + +use crate::support::harness::{MockConnectOptions, connect_mock, spawn, subscribed}; + +const TIMEOUT: Duration = Duration::from_secs(10); + +const VERSIONS: [&str; 3] = ["moq-lite-06", "moq-lite-07-wip", "moq-transport-22"]; + +/// Groups published one per second while the reader is stalled, which resumes a second +/// after the last: group N ends `GROUPS - N - 1` seconds behind the clock then. +const GROUPS: u64 = 5; + +fn origin(hop: u64) -> origin::Producer { + let (origin, driver) = origin::Producer::new(origin::Config::new(Hop::new(hop).unwrap())); + spawn(driver); + origin +} + +/// The groups a reader subscribed with `budget` receives once it resumes from a stall +/// spanning every group. +async fn stalled_read(version: Version, budget: Duration) -> BTreeSet { + let publisher = origin(1); + let relay = origin(2); + let viewer = origin(3); + let broadcast = publisher.create_broadcast("live").unwrap(); + let source = broadcast + .create_track("audio", track::Info::default().with_timescale(Timescale::MILLI)) + .unwrap(); + broadcast.announce(Default::default()).unwrap(); + + let mut upstream = MockConnectOptions::new(version); + upstream.client_publish = Some(publisher.consume()); + upstream.server_subscribe = Some(relay.clone()); + let _upstream = connect_mock(upstream).await; + + // Gating the viewer's driver stalls it like a starved process: its transport stops + // accepting streams, so the stream credit it grants runs out. + let gate = kio::Producer::new(true); + let mut downstream = MockConnectOptions::new(version); + // Draft 22 keeps its SETUP stream open, so it needs one more for groups. + downstream.transport.max_concurrent_uni_streams = Some(1 + usize::from(!version.is_lite())); + downstream.client_publish = Some(relay.consume()); + downstream.server_subscribe = Some(viewer.clone()); + downstream.server_gate = Some(gate.consume()); + let _downstream = connect_mock(downstream).await; + + let consumer = viewer.consume(); + consumer.routed("live").await.unwrap(); + let remote = consumer.request_broadcast("live", None).await.unwrap(); + let subscription = track::Subscription::default().with_max_delay(budget); + let mut reader = remote.track("audio").unwrap().subscribe(subscription).await.unwrap(); + moq_clock::timeout(TIMEOUT, subscribed(&source)).await.unwrap(); + + *gate.write().ok().unwrap() = false; + for sequence in 0..GROUPS { + let mut group = source.create_group(moq_net::group::Info { sequence }).unwrap(); + group + .write_frame(Timestamp::from_millis(sequence * 1000).unwrap(), &b"x"[..]) + .unwrap(); + group.finish().unwrap(); + moq_clock::sleep(Duration::from_secs(1)).await; + } + *gate.write().ok().unwrap() = true; + + let mut got = BTreeSet::new(); + while let Ok(group) = moq_clock::timeout(Duration::from_secs(1), reader.recv_group()).await { + let mut group = group.unwrap().expect("the track is live"); + let sequence = group.sequence; + let frame = group.read_frame().await; + assert!( + frame.is_ok_and(|frame| frame.is_some()), + "{version}: group {sequence} was cut short" + ); + assert!(got.insert(sequence), "{version}: group {sequence} delivered twice"); + } + got +} + +#[moq_clock::test] +async fn a_stalled_reader_keeps_every_group_its_budget_covers() { + for version in VERSIONS { + let version: Version = version.parse().unwrap(); + let got = stalled_read(version, Duration::from_secs(5)).await; + assert_eq!(got, (0..GROUPS).collect(), "{version}"); + } +} + +/// The stall backs up the relay: with a budget shorter than it, the groups that waited for +/// credit past the budget are skipped. Group 0 took the only credit before the stall. +#[moq_clock::test] +async fn a_budget_shorter_than_the_stall_skips_what_waited_past_it() { + for version in VERSIONS { + let version: Version = version.parse().unwrap(); + let got = stalled_read(version, Duration::from_millis(1500)).await; + assert_eq!(got, [0, 3, 4].into(), "{version}"); + } +} From 72d3de04cc82ef4ac0ff5c03b2ec0ab6ba9d1224 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 03:52:14 -0700 Subject: [PATCH 3/4] test(moq-net): name when group 0 took its credit Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/tests/integration/slow_joiner.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rs/moq-net/tests/integration/slow_joiner.rs b/rs/moq-net/tests/integration/slow_joiner.rs index a6495898e44..113a2be431c 100644 --- a/rs/moq-net/tests/integration/slow_joiner.rs +++ b/rs/moq-net/tests/integration/slow_joiner.rs @@ -94,7 +94,7 @@ async fn a_stalled_reader_keeps_every_group_its_budget_covers() { } /// The stall backs up the relay: with a budget shorter than it, the groups that waited for -/// credit past the budget are skipped. Group 0 took the only credit before the stall. +/// credit past the budget are skipped. Group 0 took the one free credit as the stall began. #[moq_clock::test] async fn a_budget_shorter_than_the_stall_skips_what_waited_past_it() { for version in VERSIONS { From ff521693cab302cb8ea4201db86eacc4e7d8e3ec Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 29 Oct 2026 09:01:35 -0700 Subject: [PATCH 4/4] test(moq-net): read the stalled reader until its track ends Adapt to the renamed origin API from main (announced/request), and finish the source so the read loop ends on the track's end rather than a 1 s idle timeout, which could miss a late group. Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/tests/integration/slow_joiner.rs | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/rs/moq-net/tests/integration/slow_joiner.rs b/rs/moq-net/tests/integration/slow_joiner.rs index 113a2be431c..9397eec2961 100644 --- a/rs/moq-net/tests/integration/slow_joiner.rs +++ b/rs/moq-net/tests/integration/slow_joiner.rs @@ -53,8 +53,8 @@ async fn stalled_read(version: Version, budget: Duration) -> BTreeSet { let _downstream = connect_mock(downstream).await; let consumer = viewer.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + crate::support::announced(&consumer, "live").await; + let remote = consumer.request("live", None).await.unwrap(); let subscription = track::Subscription::default().with_max_delay(budget); let mut reader = remote.track("audio").unwrap().subscribe(subscription).await.unwrap(); moq_clock::timeout(TIMEOUT, subscribed(&source)).await.unwrap(); @@ -68,11 +68,16 @@ async fn stalled_read(version: Version, budget: Duration) -> BTreeSet { group.finish().unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; } + source.finish().unwrap(); *gate.write().ok().unwrap() = true; + // Read until the track ends, so a skipped group can't be one that merely arrived late. let mut got = BTreeSet::new(); - while let Ok(group) = moq_clock::timeout(Duration::from_secs(1), reader.recv_group()).await { - let mut group = group.unwrap().expect("the track is live"); + while let Some(mut group) = moq_clock::timeout(TIMEOUT, reader.recv_group()) + .await + .unwrap_or_else(|_| panic!("{version}: the track never finished")) + .unwrap() + { let sequence = group.sequence; let frame = group.read_frame().await; assert!(