Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 0 additions & 1 deletion quest/m1/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,6 @@ transport, benchmark tooling); worktrees isolate commits, not semantics.

## Required

- [Late joiner history](/quest/m1/relay-late-joiner-history.md) - a subscriber joining a relay's track from group 0 later still receives the cached finished group below the live one
- [Cluster routing](/quest/m1/cluster-routing.md) - an announcement says where a broadcast originates, not how to reach it, and a relay hears only the prefixes its clients asked for
- [Exact scope](/quest/m1/exact-scope.md) - a reader never sees an exact broadcast outside its scope, in Rust or JS; prefix routes above it still present as the empty path
- [Track tail interop](/quest/m1/track-tail-interop.md) - a Rust publisher ending a track with a group in flight is read to its end by the JS subscriber, and the reverse, in `just test interop`
Expand Down
44 changes: 0 additions & 44 deletions quest/m1/relay-late-joiner-history.md

This file was deleted.

1 change: 0 additions & 1 deletion quest/m1/track-tail-interop.md
Original file line number Diff line number Diff line change
Expand Up @@ -41,7 +41,6 @@ delivered and clean. The ordering race itself stays in the unit tests.
## Required

- [SUBSCRIBE_DROP](/quest/m1/subscribe-drop.md) - publishers name every group they won't deliver, which the lite-07 case checks
- #4387 merges: a relayed subscription resolves its start from its source, so earlier in-flight groups are not lost (it adds quest/m1/relay-late-joiner-history.md)

## Related

Expand Down
10 changes: 10 additions & 0 deletions rs/moq-net/src/model/origin.rs
Original file line number Diff line number Diff line change
Expand Up @@ -2095,6 +2095,7 @@ fn warm_copy(source: &track::Consumer, head: Option<&WarmGroup>) -> Option<WarmC
.map(|(group, _)| group.sequence)
.max();
let mut edge = None;
let mut first = None;

// A spliced copy hides the group it continued (its halves sit in two segments), so
// carry the previous edge over when the copy has no version of it at all. First,
Expand All @@ -2105,11 +2106,13 @@ fn warm_copy(source: &track::Consumer, head: Option<&WarmGroup>) -> Option<WarmC
let is_latest = latest.is_none_or(|latest| head.sequence >= latest);
if head.is_finished() {
let _ = track.adopt_group(head.clone(), true);
first = Some(head.sequence);
if is_latest {
edge = Some(WarmGroup(head.clone()));
}
} else if is_latest {
edge = warm_rebuild(&track, head, None);
first = edge.as_ref().map(|_| head.sequence);
}
}

Expand All @@ -2131,10 +2134,17 @@ fn warm_copy(source: &track::Consumer, head: Option<&WarmGroup>) -> Option<WarmC
// Mid-transfer backlog, or a continuation with no head to complete it.
None
};
if visible && let Some(warm) = &warm {
first = Some(first.map_or(warm.0.sequence, |first: u64| first.min(warm.0.sequence)));
}
if is_latest {
edge = warm;
}
}
// Arrival order can put the live group before cached history. Declare the
// cache's oldest group so a new subscription cannot resolve its floor from
// whichever group arrived first and permanently skip that history.
track.start_at(first).ok()?;
let dynamic = track.dynamic();
Some(WarmCopy {
track,
Expand Down
91 changes: 91 additions & 0 deletions rs/moq-net/tests/history_groups.rs
Original file line number Diff line number Diff line change
Expand Up @@ -171,3 +171,94 @@ async fn a_fresh_subscriber_receives_the_finished_older_group() {
}
assert!(failures.is_empty(), "{failures:#?}");
}

/// Read known frame counts so the open live group never advances paused time to
/// the relay's linger deadline while waiting for a FIN that will not arrive.
async fn read_history(sub: &mut moq_net::track::Subscriber) {
let mut sequences = Vec::new();
for _ in 0..2 {
let mut group = sub.recv_group().await.unwrap().unwrap();
let frames = match group.sequence {
5 => 3,
6 => 2,
sequence => panic!("unexpected group {sequence}"),
};
for _ in 0..frames {
assert!(group.read_frame().await.unwrap().is_some());
}
sequences.push(group.sequence);
}
sequences.sort();
assert_eq!(sequences, [5, 6]);
}

#[tokio::test]
async fn a_late_subscriber_receives_the_relays_cached_history() {
tokio::time::pause();
// Older drafts canonicalize group 0 to the live edge instead of replay.
let version: Version = "moq-lite-07-wip".parse().unwrap();
let publisher = produce_origin(1);
let broadcast = publisher.create_broadcast("bcast").unwrap();
let track = broadcast
.create_track("history", Info::default().with_max_age(FOREVER))
.unwrap();
broadcast.announce(Default::default()).unwrap();
let relay = produce_origin(2);
let mut options = MockConnectOptions::new(version);
options.server_publish = Some(publisher.consume());
options.client_subscribe = Some(relay.clone());
let upstream = connect_mock(options).await;
let first = produce_origin(3);
let mut options = MockConnectOptions::new(version);
options.server_publish = Some(relay.consume());
options.client_subscribe = Some(first.clone());
let first_pair = connect_mock(options).await;
let consumer = first.consume();
consumer.routed("bcast").await.unwrap();
let remote = consumer.request_broadcast("bcast").await.unwrap();
let subscription = Subscription::default()
.with_max_age(FOREVER)
.with_start(Position::group(0));
let first_subscription = subscription.clone();
let first_reader = tokio::spawn(async move {
let mut sub = remote
.track("history")
.unwrap()
.subscribe(first_subscription)
.await
.unwrap();
read_history(&mut sub).await;
sub
});
track.used().await.unwrap();
upstream.server_transport.hold_unis();
let mut old = track.create_group(moq_net::group::Info { sequence: 5 }).unwrap();
for _ in 0..3 {
old.write_frame(Timestamp::now(), &b"old"[..]).unwrap();
}
old.finish().unwrap();
let mut live = track.create_group(moq_net::group::Info { sequence: 6 }).unwrap();
for _ in 0..2 {
live.write_frame(Timestamp::now(), &b"live"[..]).unwrap();
}
// Both streams open before paused time advances; 10ms stays below linger.
tokio::time::sleep(Duration::from_millis(10)).await;
upstream.server_transport.release_unis_reversed();
let first_sub = tokio::time::timeout(TIMEOUT, first_reader)
.await
.expect("first subscriber history")
.unwrap();
let late = produce_origin(4);
let mut options = MockConnectOptions::new(version);
options.server_publish = Some(relay.consume());
options.client_subscribe = Some(late.clone());
let late_pair = connect_mock(options).await;
let consumer = late.consume();
consumer.routed("bcast").await.unwrap();
let remote = consumer.request_broadcast("bcast").await.unwrap();
let mut late_sub = remote.track("history").unwrap().subscribe(subscription).await.unwrap();
tokio::time::timeout(TIMEOUT, read_history(&mut late_sub))
.await
.unwrap_or_else(|_| panic!("{version}: late subscriber history"));
drop((first_sub, late_sub, first_pair, late_pair, upstream, live));
}
Loading