diff --git a/js/net/src/lite/publisher.test.ts b/js/net/src/lite/publisher.test.ts index 80cdfe958f0..f2aa0d241e9 100644 --- a/js/net/src/lite/publisher.test.ts +++ b/js/net/src/lite/publisher.test.ts @@ -714,6 +714,8 @@ async function servedSubscription( routed?: boolean; // Groups the track holds before the SUBSCRIBE arrives, stamped by sequence. prefill?: bigint[]; + // A newer largest group the track's source reported before the SUBSCRIBE arrives. + reported?: bigint; // Leave the track unresolved until `accept`, as an on-demand track the SUBSCRIBE beats. pending?: boolean; } = {}, @@ -749,6 +751,10 @@ async function servedSubscription( for (const frame of frames) group.writeFrame(textFrame(frame, Timestamp.fromMillis(Number(sequence)))); group.finish(); } + if (options.reported !== undefined) { + if (!track) throw new Error("a pending track has no source to report"); + hooks.reportedGroup(track, options.reported); + } // Pulled before the SUBSCRIBE arrives: a broadcast nobody pulls refuses an unknown track. const request = options.pending ? wireOf(broadcast).requested() : undefined; @@ -796,11 +802,19 @@ async function servedSubscription( serving, parked: gate.parked, release: gate.release, - // Resolve a pending track with the publisher's request for it. - async accept() { + // Resolve a pending track with the publisher's request for it, answering with `held` + // and, when `reported`, an upstream's report of a newer largest group. + async accept(held: bigint[] = [], reported?: bigint) { const pulled = await request; if (!pulled) throw new Error("the publisher never requested the track"); - track = pulled.accept(info); + const staged = hooks.stageRequest(pulled, info); + if (reported !== undefined) hooks.reportedGroup(staged.producer, reported); + for (const sequence of held) { + const group = staged.producer.createGroup(sequence); + for (const frame of frames) group.writeFrame(textFrame(frame, Timestamp.fromMillis(Number(sequence)))); + group.finish(); + } + track = staged.commit(); }, // Stamped by sequence, so a group served out of order still starts in order. serve(sequence: bigint) { @@ -1465,17 +1479,50 @@ test("lite draft-05: an update dropping the floor re-pins to the latest group", // A SUBSCRIBE can beat its track resolving, as one a relay serves from a copy still fetching // upstream. Groups the track holds once it does are older than the join, so an absent Group -// Start is still the latest group. -test.each([Version.DRAFT_01, Version.DRAFT_03, Version.DRAFT_05])( - "lite %s: a subscribe that beats its track resolving joins at the latest group", +// Start is still the latest group known then, including one the upstream reported. +// Routed, the join reads the front's serving copy. +test.each([ + [Version.DRAFT_03, undefined, false], + [Version.DRAFT_04, undefined, false], + [Version.DRAFT_04, 9n, false], + [Version.DRAFT_04, 9n, true], + [Version.DRAFT_05, undefined, false], + [Version.DRAFT_05, undefined, true], +])( + "lite %s (reported %s, routed %s): a subscribe that beats its track resolving joins at its newest group", + async (version, reported, routed) => { + const sub = await servedSubscription({ version, pending: true, routed }); + try { + await sub.accept([0n, 3n, 7n], reported); + if (reported !== undefined) { + // The SUBSCRIBE_OK follows the floor, so these arrive after the join took it. + expect("ok" in (await decodeSubscribeResponse(sub.client.reader, version))).toBe(true); + sub.serve(8n); + sub.serve(9n); + } + expect(await sub.servedHeader()).toBe(reported ?? 7n); + expect(await sub.servedSequence()).toBeUndefined(); + } finally { + await sub.close(); + } + }, +); + +// A track that already holds groups when the SUBSCRIBE arrives still joins at a newer largest +// its source reported, as a cold one would. +test.each([Version.DRAFT_04, Version.DRAFT_05])( + "lite %s: a join on a track already holding groups starts at a reported newer group", async (version) => { - const sub = await servedSubscription({ version, pending: true }); + const sub = await servedSubscription({ version, prefill: [0n, 3n], reported: 9n }); try { - await sub.accept(); - sub.serve(0n); - sub.serve(1n); - sub.serve(2n); - expect(await sub.servedHeader()).toBe(2n); + if (version === Version.DRAFT_04) { + expect("ok" in (await decodeSubscribeResponse(sub.client.reader, version))).toBe(true); + } else { + await flush(); + } + sub.serve(7n); + sub.serve(9n); + expect(await sub.servedHeader()).toBe(9n); expect(await sub.servedSequence()).toBeUndefined(); } finally { await sub.close(); @@ -1483,6 +1530,22 @@ test.each([Version.DRAFT_01, Version.DRAFT_03, Version.DRAFT_05])( }, ); +// Lite-01/02 retain the arrival-only floor even when the answer contains history. +test.each([Version.DRAFT_01, Version.DRAFT_02])( + "lite %s: a pending join retains its arrival-only floor", + async (version) => { + const sub = await servedSubscription({ version, pending: true }); + try { + await sub.accept([0n, 3n, 7n]); + expect(await sub.servedHeader()).toBe(0n); + expect(await sub.servedHeader()).toBe(3n); + expect(await sub.servedHeader()).toBe(7n); + } finally { + await sub.close(); + } + }, +); + // On an empty track the re-pin has no latest group to name, so the first group the // track produces is served, even below the dropped floor. test("lite draft-05: an update dropping the floor on an empty track serves the next group", async () => { diff --git a/js/net/src/lite/publisher.ts b/js/net/src/lite/publisher.ts index 8cefca22724..8210e0b0115 100644 --- a/js/net/src/lite/publisher.ts +++ b/js/net/src/lite/publisher.ts @@ -1040,13 +1040,20 @@ export class Publisher { } const publisher = info.priority; // A SUBSCRIBE can arrive before its track resolves, such as one a relay serves from a - // copy still fetching upstream, or on lite-05 one sent alongside its TRACK, when no - // group is known yet: the newest once it resolves stands in, as it would for one - // sent after. - const resolved = cursorFloor(this.version, msg.startGroup, hooks.latestSequence(track)); - if (latest === undefined && resolved !== floor) { - floor = resolved; - track.withRange({ start: { included: floor } }); + // copy still fetching upstream, or on lite-05 one sent alongside its TRACK: the newest + // group known once it resolves stands in, including a largest the upstream's answer + // reported, whether or not the copy already held a group. A newer group the answer + // brings later is not waited for. Lite-01/02 keep their arrival floor, as Rust does. + if (this.version !== Version.DRAFT_01 && this.version !== Version.DRAFT_02) { + let newest = latest; + for (const known of [hooks.latestSequence(track), hooks.peekLargest(track).largest?.group]) { + if (known !== undefined) newest = newest === undefined ? known : max(newest, known); + } + const resolved = cursorFloor(this.version, msg.startGroup, newest); + if (resolved !== floor) { + floor = resolved; + track.withRange({ start: { included: floor } }); + } } // Older drafts carry no timestamps. let stamp: Stamp | undefined; diff --git a/quest/m1/README.md b/quest/m1/README.md index f96e4ef9f14..54a6110ea71 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -181,7 +181,6 @@ their end report, so an embedder's drain alert pages on real cuts. - [Session policy lives in moq-net](/quest/m1/session-policy/README.md) - accept and connect deadlines, admission, window widening and reconnect live once in moq-net; moq-tokio and moq-relay's io_uring path call them - [moq auth serve scopes each client certificate by its chain](/quest/m1/auth-cert-rules.md) - per-certificate and per-intermediate rules in a reloaded TOML config, keyed by the chain hashes the relay sends - [A replacement that fails before delivering never ends a live track](/quest/m1/route-swap-keeps-incumbent.md) - a route change whose replacement aborts before its first group leaves readers on the source that was serving -- [A Rust relay never replays from group 0 to a lite-03/04 subscriber](/quest/m1/relay-inflight-replay.md) - A Rust relay or publisher serving a lite-03 or lite-04 SUBSCRIBE from a track copy that is still resolving starts at the newest group once the copy resolves - [Rename moq-rtc to moq-webrtc](/quest/m1/webrtc-rename.md) - one published `moq-webrtc` crate holds the gateway, the ICE driver, and the data-channel transport - [Vendor and trim the WebRTC stack](/quest/m1/webrtc-vendor.md) - str0m, dimpl, `is`, and sctp-proto live in moq-webrtc with unused code removed, so moq-rtc can take rind - [MoQ on rind](/quest/m1/rind/README.md) - every MoQ crate takes its crypto from rind, a pure-Rust graviola fork, so no build compiles C crypto diff --git a/quest/m1/relay-inflight-replay.md b/quest/m1/relay-inflight-replay.md deleted file mode 100644 index a46d7a5a1d5..00000000000 --- a/quest/m1/relay-inflight-replay.md +++ /dev/null @@ -1,33 +0,0 @@ -# [S] A Rust relay never replays from group 0 to a lite-03/04 subscriber - -## Goal - -A Rust relay or publisher serving a lite-03 or lite-04 SUBSCRIBE from a track -copy that is still resolving (an in-flight upstream request) starts at the -newest group once the copy resolves, as it does for lite-05+ and as JS does -for every version. It never replays the cache from group 0. - -## Plan - -Decided 2026-10-31 (user, /quest-plan of the follow-ups from the 2026-10-31 -/quest-complete run), from -[moq-dev/moq#7328](https://github.com/moq-dev/moq/pull/7328). - -Milestone: ✅ m1 (moved from m2). Not chosen: m2. There is no m1 -pipeline-requests epic, so this sits at the m1 top level. - -- `cursor_floor` (`rs/moq-net/src/lite/publisher.rs:127` at be39188000) - floors a pre-06 SUBSCRIBE at `latest`, the newest group when it arrived, - and at 0 when the copy has none yet. [moq-dev/moq#7328](https://github.com/moq-dev/moq/pull/7328) (merged) re-reads the newest group of an unresolved track - once it resolves, but only for lite-05+ (`SubscribeServe`, the - `has_track_stream()` match at `:2259`). JS no longer replays for any - version. -- Extend the re-read to lite-03/04, so a resolved copy floors them at its - newest group, never at a lower first group it reports; match what JS - does. -- Test with a lite-03 and a lite-04 subscriber on a relay whose upstream - answers after the SUBSCRIBE, with cached groups below the live edge. - [moq-dev/moq#7328](https://github.com/moq-dev/moq/pull/7328)'s interop was not rerun after its last changes; run the lite-03/04 - cells here. - -Public API: none. Wire: none. diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index 2a4fbdfcb07..dbabbd57ab9 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -135,10 +135,11 @@ fn serving_max_delay(version: Version, requested: Duration) -> Option /// an unbounded budget so nothing is dropped under them (see [`serving_max_delay`]), which /// must not read as a request to replay the whole cache on join. /// -/// `latest` is the newest group when the SUBSCRIBE arrived, not once the subscription -/// resolved: anything written in between is newer, so it is delivered. On lite-05, a -/// SUBSCRIBE sent alongside its TRACK can arrive before the track resolves, when no group -/// is known yet: the newest once it resolves stands in, as it would for one sent after. +/// `latest` is the newest group known once the track resolves, which a SUBSCRIBE can beat, as +/// one a relay serves from a copy still fetching upstream, or on lite-05 one sent alongside its +/// TRACK. It includes a largest the upstream's answer reported, whether or not the copy already +/// held a group, so a join starts at the same group warm or cold. A newer group the answer +/// brings later is not waited for. Lite01/02 keep the newest group on arrival, or a zero floor. fn cursor_floor(version: Version, start_group: Option, latest: Option) -> u64 { if version.resolves_start() || start_group.is_some() { return 0; @@ -2467,7 +2468,7 @@ impl Request for SubscribeServe { else { unreachable!() }; - let track = match track { + let mut track = match track { Ok(track) => track, Err(err) => { *self = Self::datagrams(Legacy::datagrams(legacy, err)?, &msg, update); @@ -2525,9 +2526,11 @@ impl Request for SubscribeServe { ietf, }; - let latest = match shared.version.has_track_stream() { - true => latest.or_else(|| track.latest_sequence()), - false => latest, + let latest = match shared.version { + Version::Lite01 | Version::Lite02 => latest, + _ => latest + .max(track.latest_sequence()) + .max(track.peek_largest().map(|largest| largest.group)), }; let floor = cursor_floor(shared.version, bounds.groups().start(), latest); let mut run = TrackRun::new(sub, track, bounds, floor, steer_tx); @@ -9468,6 +9471,189 @@ mod tests { } } + /// A pre-06 SUBSCRIBE that beats its track resolving starts at the newest group known once + /// it resolves: one cached, or one the answer reported but has yet to deliver. An answer + /// with nothing known serves every later group. Named starts, lite-01, lite-06, and joins + /// whose newest group was known on arrival keep their floors. + #[kio::test] + async fn a_pending_subscribe_joins_the_newest_group_once_resolved() { + use crate::lite::test_transport::{Log, Sent}; + + enum Answer { + /// Groups 0 and 3 written before the SUBSCRIBE arrives, 7 after. + Resolved, + /// Groups 0 and 3 written and group 9 reported before the SUBSCRIBE arrives, 7 and 9 after. + Warm, + /// The answer holds groups 0, 3, and 7. + Cached, + /// The answer holds group 3 and reports group 9 as its largest. + Reported, + /// The answer holds nothing; groups 0, 3, and 7 follow it. + Empty, + } + + fn write(track: &mut track::Producer, sequences: &[u64]) { + for &sequence in sequences { + let mut group = track.create_group(group::Info { sequence }).unwrap(); + group.write_frame(crate::Timestamp::ZERO, b"x".as_slice()).unwrap(); + group.finish().unwrap(); + } + } + + for version in [ + Version::Lite01, + Version::Lite03, + Version::Lite04, + Version::Lite05, + Version::Lite06, + ] { + for answer in [ + Answer::Resolved, + Answer::Warm, + Answer::Cached, + Answer::Reported, + Answer::Empty, + ] { + for start in [None, Some(0)] { + let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let broadcast = origin.create_broadcast("room").unwrap(); + let mut dynamic = broadcast.requests(); + broadcast.announce(Default::default()).unwrap(); + let copy = broadcast.consume().track("video").unwrap(); + let held = copy.info().into_inner(); + assert!(held.poll_ok(&kio::Waiter::noop()).is_pending()); + let request = dynamic.requested_track().await.unwrap(); + let mut staged = Some(request.stage(track::Info::timed())); + staged.as_ref().unwrap().received(); + let mut track = None; + if let Answer::Resolved | Answer::Warm = answer { + let mut resolved = staged.take().unwrap().commit(); + write(&mut resolved, &[0, 3]); + if let Answer::Warm = answer { + resolved.report_largest(track::Position::group(9)); + } + track = Some(resolved); + } + + let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); + peer_setup.set(crate::lite::Setup::default()); + let (_, goaway) = crate::goaway::Handle::new(true); + let log = Log::default(); + let publisher = Publisher::new(PublisherConfig { + runtime: crate::time::sim(), + session: crate::driver::Transport::new(SinkSession::new(log.clone())), + origin: origin.consume(), + version, + peer_setup, + goaway, + peer_hop: None, + auth: crate::auth::Link::new(false), + peer_grant: Default::default(), + client: false, + subscriptions: Default::default(), + estimate: kio::Producer::default().weak(), + }); + let msg = lite::Subscribe { + order: crate::track::Order::Ascending, + instance: None, + id: 0, + broadcast: crate::Path::from_static("room"), + track: "video".into(), + priority: 0, + max_delay: Duration::from_secs(60), + min_delay: None, + ranges: vec![lite::Range::span(start, 0, None, None)], + }; + let mut serve = + SubscribeServe::start(&publisher.shared, msg, "video", broadcast.consume()).unwrap(); + let mut writer = Writer::new( + crate::transport::boxed::SendStream::new(SinkSend::new(Log::default())), + version, + ); + // Serve for a moment: a live subscription never ends on its own. + let mut drive = async || { + let outcome = kio::clock::timeout( + Duration::from_millis(1), + kio::wait(|waiter| { + loop { + match ready!(serve.poll(&publisher.shared, &mut writer, waiter))? { + ControlFlow::Continue(()) => {} + ControlFlow::Break(()) => return Poll::Ready(Ok::<_, Error>(())), + } + } + }), + ) + .await; + assert!(outcome.is_err(), "the live subscription ended"); + }; + drive().await; + + let mut track = match answer { + Answer::Resolved | Answer::Warm => track.take().unwrap(), + Answer::Cached => { + let mut staged = staged.take().unwrap(); + write(&mut staged, &[0, 3, 7]); + staged.commit() + } + Answer::Reported => { + let mut staged = staged.take().unwrap(); + write(&mut staged, &[3]); + staged.report_largest(track::Position::group(9)); + staged.commit() + } + Answer::Empty => staged.take().unwrap().commit(), + }; + drive().await; + match answer { + Answer::Resolved => write(&mut track, &[7]), + Answer::Reported | Answer::Warm => write(&mut track, &[7, 9]), + Answer::Empty => write(&mut track, &[0, 3, 7]), + Answer::Cached => {} + } + drive().await; + + let mut streams = std::collections::BTreeMap::<_, Vec>::new(); + for (id, sent) in log.trail() { + if let Sent::Write(bytes) = sent { + streams.entry(id).or_default().extend(bytes); + } + } + let mut sequences = streams + .values() + .map(|bytes| { + crate::coding::decode_buf(&mut bytes.as_slice(), version, |r, v| { + assert_eq!(lite::DataType::decode(r, v)?, lite::DataType::Group); + Ok(lite::Group::decode(r, v)?.sequence) + }) + .unwrap() + }) + .collect::>(); + sequences.sort(); + let all: &[u64] = match answer { + Answer::Reported => &[3, 7, 9], + Answer::Warm => &[0, 3, 7, 9], + _ => &[0, 3, 7], + }; + let expected: &[u64] = if start.is_some() || version.resolves_start() { + all + } else { + match answer { + Answer::Resolved => &[3, 7], + Answer::Warm if version == Version::Lite01 => &[3, 7, 9], + _ if version == Version::Lite01 => all, + Answer::Warm => &[9], + Answer::Cached => &[7], + Answer::Reported => &[9], + Answer::Empty => &[0, 3, 7], + } + }; + assert_eq!(sequences, expected, "{version}, start={start:?}"); + track.abort(Error::Cancel).unwrap(); + } + } + } + } + /// SUBSCRIBE_UPDATE is not a close: an update arriving while the subscription /// resolves keeps it waiting, and the latest applies once it starts. Its wanted group /// is state each update restates: past the largest it joins, and once that group diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index 1034de14399..df70c1bc4fc 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -157,7 +157,7 @@ async fn every_wire_carries_the_live_and_oldest_starts() { let mut oldest = read(Some(version), Range::oldest()).await.unwrap(); oldest.sort_unstable(); let want: &[u64] = match *version { - "moq-lite-05" | "moq-transport-18" | "moq-transport-22" => &[4], + "moq-lite-03" | "moq-lite-04" | "moq-lite-05" | "moq-transport-18" | "moq-transport-22" => &[4], _ => &[0, 1, 2, 3, 4], }; assert_eq!(oldest, want, "{version}: oldest reads every group its start reaches"); diff --git a/rs/moq-net/tests/integration/widened_max_age.rs b/rs/moq-net/tests/integration/widened_max_age.rs index b313716f671..2e4d9711eca 100644 --- a/rs/moq-net/tests/integration/widened_max_age.rs +++ b/rs/moq-net/tests/integration/widened_max_age.rs @@ -144,8 +144,8 @@ async fn received(subscriber: &mut track::Subscriber) -> BTreeSet { #[kio::test] async fn a_fresh_reader_fills_nothing_below_its_start() { for (version, want) in [ - ("moq-lite-04", 6..GROUPS), // Starts at the live edge. + ("moq-lite-04", GROUPS - 1..GROUPS), ("moq-lite-05", GROUPS - 1..GROUPS), ("moq-lite-06", 6..GROUPS), ("moq-lite-07-wip", 6..GROUPS), @@ -350,3 +350,48 @@ async fn wider_newcomers_after_the_first_pull_nothing_upstream() { } assert_eq!(sent_groups(®istry), widened, "later newcomers pull nothing upstream"); } + +/// A lite-03/04 viewer that beats a relay's copy resolving starts at the largest group the +/// relay's lite-07 feed reports, though the feed delivers the history the budget reaches after +/// its answer: the SUBSCRIBE names no start, which those drafts define as the latest group. +#[kio::test] +async fn a_legacy_viewer_beating_a_relay_copy_joins_at_the_live_edge() { + for legacy in ["moq-lite-03", "moq-lite-04"] { + let publisher = origin(1); + let relay = origin(2); + let viewer = origin(3); + let mut options = MockConnectOptions::new(VERSION.parse().unwrap()); + options.server_publish = Some(publisher.consume()); + options.client_subscribe = Some(relay.clone()); + let upstream = connect_mock(options).await; + let _downstream = peer(legacy.parse().unwrap(), &relay, &viewer).await; + let broadcast = publisher.create_broadcast("live").unwrap(); + let source = broadcast.create_track("video", timed()).unwrap(); + broadcast.announce(Default::default()).unwrap(); + 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(); + } + + let consumer = viewer.consume(); + let remote = consumer + .follow("live", None) + .unwrap() + .available() + .await + .unwrap() + .expect("broadcast resolves"); + upstream.server_transport.hold_unis(); + let subscription = Subscription::default().with_delay(Delay::default().with_max(WIDE)); + let mut reader = kio::clock::timeout(TIMEOUT, remote.track("video").unwrap().subscribe(subscription)) + .await + .unwrap() + .unwrap(); + upstream.server_transport.release_unis(); + let got = kio::clock::timeout(TIMEOUT, received(&mut reader)).await.unwrap(); + assert_eq!(got, BTreeSet::from([GROUPS - 1]), "{legacy}"); + } +}