From 3c83cb5b732647c57ec492c40ffc752a153b9059 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 06:16:24 -0700 Subject: [PATCH 1/4] chore(quest): claim quest/m1/recover-reader-budget.md Quest-Claim: 87a4dad5edf5e6a3 From 9a60b82e96e65eca29ba50e28f930e4e3842595f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 06:22:49 -0700 Subject: [PATCH 2/4] test(net): a short-budget reader never settles a refused group for a longer one Two readers with 100 ms and one-hour budgets share the replacement copy after a failover; its route refuses the fetch of the group both were reading. The hour reader keeps waiting and finishes the group when it lands late, in either recovery order, while the short one gives up on its own budget. Each reader subscribes to the new route before judging, so the copy's combined budget always covers its own. The quest assumed the verdict could run before that subscription registered. It cannot in Rust, and the JS verdict wait that moq-dev/moq#6947 adds reads the reader's own copy subscription, so the quest is removed. Co-Authored-By: Claude Opus 5.5 --- quest/m1/README.md | 1 - quest/m1/recover-reader-budget.md | 17 -------- rs/moq-net/src/model/resume.rs | 64 +++++++++++++++++++++++++++++++ 3 files changed, 64 insertions(+), 18 deletions(-) delete mode 100644 quest/m1/recover-reader-budget.md diff --git a/quest/m1/README.md b/quest/m1/README.md index 3f93058e5c5..55686da1c9d 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -119,7 +119,6 @@ removed). ## Required - [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 diff --git a/quest/m1/recover-reader-budget.md b/quest/m1/recover-reader-budget.md deleted file mode 100644 index ed105b26eb5..00000000000 --- a/quest/m1/recover-reader-budget.md +++ /dev/null @@ -1,17 +0,0 @@ -# [S] Recover judges a miss by the reader's own budget - -## Goal - -When resume decides whether a missing group is still coming, it judges by -the reader's own budget, not the copy's combined one, in Rust and `@moq/net`. -Right after a failover, a short-budget reader no longer settles a group for -an hour-budget reader sharing the copy. - -## Plan - -Found by [moq-dev/moq#6947](https://github.com/moq-dev/moq/pull/6947)'s model -test, which never triggered it once routes answered fetches. Reproduce it -with a fixed case first, then extend the model test so a random sweep can -hit it. - -Public API: none. Wire: none. diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 5c5c324445e..3f15985fba2 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -2260,6 +2260,70 @@ mod test { } } + /// A short-budget reader sharing the replacement copy never settles a refused group for + /// an hour-budget one, whichever recovers first: each reader subscribes to the new route + /// before judging, so the copy's combined budget always covers its own. Nor does the + /// hour-budget reader keep the short one waiting past its own budget. + #[moq_clock::test] + async fn a_refused_group_waits_for_its_own_readers_grace() { + let waiter = kio::Waiter::noop(); + let short = Duration::from_millis(100); + let hour = Duration::from_secs(3600); + for short_first in [true, false] { + let routes = Producer::new(); + let logical = logical(&routes); + let a = copy(); + routes.serve(a.consume()); + let mut quick = subscribe(&logical, short); + let mut patient = subscribe(&logical, hour); + let mut open = a.create_group(group::Info { sequence: 0 }).unwrap(); + open.write_frame(ts(0), b"first".as_ref()).unwrap(); + let mut quick_held = recv(&mut quick); + let mut patient_held = recv(&mut patient); + assert_eq!(read(&mut quick_held), Some(b"first".to_vec())); + assert_eq!(read(&mut patient_held), Some(b"first".to_vec())); + + let b = copy(); + let dynamic = b.requests(); + let mut newer = b.create_group(group::Info { sequence: 1 }).unwrap(); + newer.write_frame(ts(1), b"newer".as_ref()).unwrap(); + newer.finish().unwrap(); + routes.serve(b.consume()); + open.abort(Error::Stream(StreamError::Session(SessionError::Cancel))) + .unwrap(); + a.abort(Error::Stream(StreamError::Session(SessionError::Cancel))) + .unwrap(); + let mut held = [&mut quick_held, &mut patient_held]; + if !short_first { + held.reverse(); + } + for group in held { + assert!(group.poll_read_frame(&waiter).is_pending()); + } + while let Poll::Ready(request) = dynamic.poll_requested_fill_group(&waiter) { + request.unwrap().reject(Error::NotFound); + } + + moq_clock::sleep(short).await; + let res = quick_held.poll_read_frame(&waiter); + assert!( + matches!(res, Poll::Ready(Err(Error::Old | Error::NotFound))), + "short_first={short_first}: {res:?}" + ); + assert!( + patient_held.poll_read_frame(&waiter).is_pending(), + "short_first={short_first}: still within the hour" + ); + drop(quick_held); + drop(quick); + let mut late = b.create_group(group::Info { sequence: 0 }).unwrap(); + late.write_frame(ts(0), b"first".as_ref()).unwrap(); + late.write_frame(ts(1), b"continued".as_ref()).unwrap(); + late.finish().unwrap(); + assert_eq!(read(&mut patient_held), Some(b"continued".to_vec()), "short_first={short_first}"); + } + } + #[test] fn a_route_preserves_a_mid_group_end() { let routes = Producer::new(); From 0ac362607a05bb5d16cd61044c211f50f404c5fd Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 06:23:32 -0700 Subject: [PATCH 3/4] style(net): format the reader-budget test Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/model/resume.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 3f15985fba2..4ccc64bbc16 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -2320,7 +2320,11 @@ mod test { late.write_frame(ts(0), b"first".as_ref()).unwrap(); late.write_frame(ts(1), b"continued".as_ref()).unwrap(); late.finish().unwrap(); - assert_eq!(read(&mut patient_held), Some(b"continued".to_vec()), "short_first={short_first}"); + assert_eq!( + read(&mut patient_held), + Some(b"continued".to_vec()), + "short_first={short_first}" + ); } } From f0a89e3811d20cea253ac8218eba284dc67766ae Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 08:50:58 -0700 Subject: [PATCH 4/4] test(net): assert the refused recovery fetch arrives Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/model/resume.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 4ccc64bbc16..c4b27461c8c 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -2300,9 +2300,12 @@ mod test { for group in held { assert!(group.poll_read_frame(&waiter).is_pending()); } + let mut refused = 0; while let Poll::Ready(request) = dynamic.poll_requested_fill_group(&waiter) { request.unwrap().reject(Error::NotFound); + refused += 1; } + assert!(refused > 0, "short_first={short_first}: the recovery fetch arrives"); moq_clock::sleep(short).await; let res = quick_held.poll_read_frame(&waiter);