diff --git a/quest/m1/README.md b/quest/m1/README.md index 31aea286032..3f1b4cc4445 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 - [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 - [moq-bench scores only gaps at or after a subscription's start](/quest/m1/bench-join-gaps.md) - late-filled history is counted apart, never as loss - [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 d4493e4530b..76c62edffd4 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -2260,6 +2260,77 @@ 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()); + } + 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); + 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();