From dd55b61fb16a165b408f631f82131f80a896fc7e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 16:48:03 -0700 Subject: [PATCH 1/5] chore(quest): claim quest/m1/api-audit/resolve/rust.md Quest-Claim: 67f4f0d94af34d99 From 0dc3665099ddf04a5c3c9501540b5d56b2c9beee Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 17:00:25 -0700 Subject: [PATCH 2/5] wip: rename moq-net resolutions to request and follow --- rs/moq-c/src/origin.rs | 4 +- rs/moq-c/src/publish.rs | 4 +- rs/moq-ffi/src/origin.rs | 6 +- rs/moq-ffi/src/test.rs | 4 +- rs/moq-mux/src/follow.rs | 6 +- rs/moq-net/benches/memory.rs | 3 +- rs/moq-net/benches/origin.rs | 188 +----- rs/moq-net/benches/path.rs | 8 +- rs/moq-net/benches/session/mod.rs | 29 +- rs/moq-net/benches/viewers.rs | 2 +- rs/moq-net/src/ietf/publisher.rs | 4 +- rs/moq-net/src/ietf/publisher/tracks.rs | 2 +- rs/moq-net/src/ietf/subscriber.rs | 12 +- rs/moq-net/src/lite/ietf.rs | 10 +- rs/moq-net/src/lite/publisher.rs | 22 +- rs/moq-net/src/lite/subscriber.rs | 10 +- rs/moq-net/src/model/broadcast.rs | 2 +- rs/moq-net/src/model/follow.rs | 58 +- rs/moq-net/src/model/mod.rs | 3 +- rs/moq-net/src/model/origin.rs | 571 +++++++----------- .../tests/integration/announce_to_serve.rs | 2 +- rs/moq-net/tests/integration/auth.rs | 98 ++- .../tests/integration/broadcast_close.rs | 11 +- .../tests/integration/catalog_acquisition.rs | 10 +- rs/moq-net/tests/integration/catalog_churn.rs | 4 +- .../tests/integration/catalog_handover.rs | 11 +- rs/moq-net/tests/integration/compress.rs | 15 +- rs/moq-net/tests/integration/control_stats.rs | 9 +- rs/moq-net/tests/integration/datagram.rs | 9 +- .../tests/integration/dial_split_horizon.rs | 2 +- rs/moq-net/tests/integration/drained_claim.rs | 4 +- rs/moq-net/tests/integration/empty_group.rs | 3 +- rs/moq-net/tests/integration/fetch_cancel.rs | 8 +- rs/moq-net/tests/integration/fetch_fanout.rs | 8 +- .../tests/integration/fetch_from_feed.rs | 6 +- rs/moq-net/tests/integration/fetch_only.rs | 6 +- .../integration/finished_broadcast_mock.rs | 6 +- rs/moq-net/tests/integration/finite_relay.rs | 6 +- rs/moq-net/tests/integration/goaway.rs | 10 +- rs/moq-net/tests/integration/group_order.rs | 8 +- .../tests/integration/history_groups.rs | 12 +- .../tests/integration/idle_cancel_refetch.rs | 6 +- .../tests/integration/late_lower_group.rs | 12 +- .../tests/integration/lazy_discovery.rs | 22 +- rs/moq-net/tests/integration/model.rs | 28 +- rs/moq-net/tests/integration/multi_cdn.rs | 2 +- rs/moq-net/tests/integration/partial_group.rs | 6 +- rs/moq-net/tests/integration/quiet_catalog.rs | 3 +- rs/moq-net/tests/integration/range_anchors.rs | 8 +- .../tests/integration/received_rewind.rs | 12 +- rs/moq-net/tests/integration/rejoin.rs | 33 +- .../tests/integration/relay_upstream_close.rs | 6 +- rs/moq-net/tests/integration/replacement.rs | 8 +- rs/moq-net/tests/integration/request_caps.rs | 13 +- rs/moq-net/tests/integration/route_change.rs | 26 +- .../tests/integration/segmented_frame.rs | 2 +- rs/moq-net/tests/integration/session_close.rs | 13 +- rs/moq-net/tests/integration/session_panic.rs | 2 +- .../tests/integration/setup_negotiation.rs | 2 +- rs/moq-net/tests/integration/source_errors.rs | 6 +- rs/moq-net/tests/integration/stream_credit.rs | 8 +- .../tests/integration/subscribe_priority.rs | 6 +- .../tests/integration/subscribe_ranges.rs | 24 +- .../tests/integration/subscribe_tracks.rs | 6 +- .../tests/integration/subscriber_max_age.rs | 3 +- .../integration/subscription_end_integrity.rs | 11 +- rs/moq-net/tests/integration/support/mod.rs | 20 +- .../integration/track_abort_over_session.rs | 5 +- .../tests/integration/track_info_cancel.rs | 14 +- .../tests/integration/track_stream_demand.rs | 12 +- rs/moq-net/tests/integration/track_tail.rs | 6 +- rs/moq-net/tests/integration/tracks.rs | 2 +- rs/moq-net/tests/integration/tracks_ietf.rs | 2 +- .../tests/integration/unannounce_release.rs | 8 +- rs/moq-net/tests/integration/untimed.rs | 6 +- rs/moq-net/tests/integration/warm_backfill.rs | 3 +- rs/moq-net/tests/integration/wide_hop.rs | 4 +- rs/moq-net/tests/integration/wide_sequence.rs | 24 +- .../tests/integration/widened_max_age.rs | 6 +- rs/moq-net/tests/integration/zero_copy.rs | 6 +- rs/moq-net/tests/loom.rs | 18 +- 81 files changed, 669 insertions(+), 931 deletions(-) diff --git a/rs/moq-c/src/origin.rs b/rs/moq-c/src/origin.rs index 5dd8745f213..357bc67dc26 100644 --- a/rs/moq-c/src/origin.rs +++ b/rs/moq-c/src/origin.rs @@ -240,7 +240,7 @@ impl Origin { mut close: oneshot::Receiver<()>, ) -> Result<(), Error> { // An unreachable path and a closed origin both mean no broadcast can ever arrive here. - let mut announced = match consumer.announced_broadcast(path.as_str(), None) { + let mut announced = match consumer.follow(path.as_str(), None) { Ok(announced) => announced, Err(moq_net::Error::Unauthorized) => return Err(Error::BroadcastNotFound), Err(err) => return Err(err.into()), @@ -299,7 +299,7 @@ impl Origin { mut close: oneshot::Receiver<()>, ) -> Result<(), Error> { // Resolves to an error when no announced route can serve the path. - let pending = consumer.request_broadcast(path.as_str(), None); + let pending = consumer.request(path.as_str(), None); // `biased` so a pending close always wins over a ready broadcast. let broadcast = tokio::select! { diff --git a/rs/moq-c/src/publish.rs b/rs/moq-c/src/publish.rs index a8c8b1e427a..ca2c3cae7e6 100644 --- a/rs/moq-c/src/publish.rs +++ b/rs/moq-c/src/publish.rs @@ -1491,7 +1491,7 @@ mod supervision_tests { async fn admission_must_match_the_broadcast_it_filled() { let origin = moq_tokio::origin::spawn(); let claim = origin.requests("room").unwrap(); - let pending = origin.consume().request_broadcast("room/first", None); + let pending = origin.consume().request("room/first", None); let prepared = claim .requested_broadcast() .await @@ -1520,7 +1520,7 @@ mod supervision_tests { pending.await.unwrap(); publish.unannounce(publication).unwrap(); - let pending = origin.consume().request_broadcast("room/second", None); + let pending = origin.consume().request("room/second", None); let prepared = claim .requested_broadcast() .await diff --git a/rs/moq-ffi/src/origin.rs b/rs/moq-ffi/src/origin.rs index 77944683067..67962b90f12 100644 --- a/rs/moq-ffi/src/origin.rs +++ b/rs/moq-ffi/src/origin.rs @@ -211,7 +211,7 @@ impl Announced { /// Follows one exact path, resolving each publisher instance that serves it. struct AnnouncedBroadcast { - inner: moq_net::origin::AnnouncedBroadcast, + inner: moq_net::origin::Following, origin: moq_net::origin::Consumer, driver: Background, } @@ -471,7 +471,7 @@ impl MoqOriginConsumer { self.driver.check()?; // Following checks the permission eagerly, so an unreachable path fails here rather // than surfacing later as a `Closed` the caller can't tell from the origin ending. - let inner = self.inner.announced_broadcast(path.as_str(), None)?; + let inner = self.inner.follow(path.as_str(), None)?; Ok(Arc::new(MoqAnnouncedBroadcast { task: Task::new(AnnouncedBroadcast { @@ -493,7 +493,7 @@ impl MoqOriginConsumer { pub async fn request_broadcast(&self, path: String) -> Result, MoqError> { let broadcast = self .driver - .watch(async { Ok(self.inner.request_broadcast(path.as_str(), None).await?) }) + .watch(async { Ok(self.inner.request(path.as_str(), None).await?) }) .await?; Ok(Arc::new(MoqBroadcastConsumer::routed( broadcast, diff --git a/rs/moq-ffi/src/test.rs b/rs/moq-ffi/src/test.rs index 66a463c41a1..58614cf37a3 100644 --- a/rs/moq-ffi/src/test.rs +++ b/rs/moq-ffi/src/test.rs @@ -4663,7 +4663,7 @@ async fn cancel_retracts_the_route_synchronously() { let dynamic = serve(&origin, ""); let inner = origin.inner().consume(); - let mut queued = inner.request_broadcast("x", None).into_inner(); + let mut queued = inner.request("x", None).into_inner(); assert!( queued.poll_ok(&kio::Waiter::noop()).is_pending(), "the route must serve while the handler lives" @@ -4671,7 +4671,7 @@ async fn cancel_retracts_the_route_synchronously() { drop(queued); dynamic.cancel(); - let mut verdict = inner.request_broadcast("y", None).into_inner(); + let mut verdict = inner.request("y", None).into_inner(); match verdict.poll_ok(&kio::Waiter::noop()) { std::task::Poll::Ready(Err(moq_net::Error::Unroutable)) => {} std::task::Poll::Ready(Err(err)) => panic!("unexpected error: {err}"), diff --git a/rs/moq-mux/src/follow.rs b/rs/moq-mux/src/follow.rs index f2e8decc63a..e1e73eb2b71 100644 --- a/rs/moq-mux/src/follow.rs +++ b/rs/moq-mux/src/follow.rs @@ -7,7 +7,7 @@ use std::task::Poll; /// The publisher instances serving a broadcast, as each comes online, takes over, and goes. /// -/// Built on [`announced_broadcast`](moq_net::origin::Consumer::announced_broadcast). Create one +/// Built on [`follow`](moq_net::origin::Consumer::follow). Create one /// with [`Source::follow`](crate::Source::follow) for a catalog reference, or [`Instances::new`] /// for a path. pub struct Instances { @@ -20,7 +20,7 @@ pub struct Instances { enum Feed { /// Every instance announced at a path. - Announced(Box), + Announced(Box), /// One instance, handed out once. Fixed(Option), } @@ -44,7 +44,7 @@ impl Instances { path: impl TryInto>, epoch: Option<&moq_net::Epoch>, ) -> crate::Result { - let announced = origin.announced_broadcast(path, None)?; + let announced = origin.follow(path, None)?; Ok(Self::with(Feed::Announced(Box::new(announced)), epoch)) } diff --git a/rs/moq-net/benches/memory.rs b/rs/moq-net/benches/memory.rs index ac45febd683..dbf6bac3788 100644 --- a/rs/moq-net/benches/memory.rs +++ b/rs/moq-net/benches/memory.rs @@ -154,8 +154,7 @@ impl Link { broadcast.announce(Default::default()).unwrap(); let consumer = subscriber.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let mut subscribers = Vec::new(); for index in 0..streams { let track = remote.track(&format!("{index}")).unwrap(); diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index e9a3de89237..a27e0019ed3 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -41,9 +41,7 @@ #[path = "../tests/integration/support/mod.rs"] mod support; -use std::pin::Pin; -use std::sync::{Arc, Mutex}; -use std::task::{Context, Poll, Wake, Waker}; +use std::task::Poll; use std::time::Duration; use criterion::{BatchSize, BenchmarkId, Criterion, Throughput, criterion_group, criterion_main}; @@ -569,7 +567,7 @@ fn bench_announce_fronts(c: &mut Criterion) { // Served but never answered: every request under it parks a front. let _served = producer.requests("room").unwrap(); let _requests: Vec<_> = (0..fronts) - .map(|i| consumer.request_broadcast(format!("room/{i}"), None)) + .map(|i| consumer.request(format!("room/{i}"), None)) .collect(); let waiter = kio::Waiter::noop(); // Run each front once so it parks on its upstream request. @@ -660,7 +658,7 @@ fn bench_request(c: &mut Criterion) { group.bench_function(BenchmarkId::new("local", &shape), |b| { b.iter(|| { let pending: Vec<_> = (0..requesters) - .map(|_| fleet.consumer.request_broadcast("room/0", None)) + .map(|_| fleet.consumer.request("room/0", None)) .collect(); fleet.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); for pending in pending { @@ -676,7 +674,7 @@ fn bench_request(c: &mut Criterion) { for _ in 0..requesters { let result = fleet .consumer - .request_broadcast("room/missing", None) + .request("room/missing", None) .now_or_never() .expect("fails synchronously"); assert!(matches!(result, Err(moq_net::Error::Unroutable))); @@ -688,153 +686,6 @@ fn bench_request(c: &mut Criterion) { group.finish(); } -/// Records which request a wake belongs to, so only woken requests are polled again. -struct Woken { - id: usize, - list: Arc>>, -} - -impl Wake for Woken { - fn wake(self: Arc) { - self.list.lock().unwrap().push(self.id); - } -} - -/// Waiting requests, polled only once woken, the way an executor polls tasks. -struct Waiting { - requests: Vec>>, - wakers: Vec, - woken: Arc>>, -} - -impl Waiting { - /// Every request starts woken, so the first drain polls each once. - fn new(requests: Vec) -> Self { - let woken = Arc::new(Mutex::new((0..requests.len()).collect())); - let wakers = (0..requests.len()) - .map(|id| { - Waker::from(Arc::new(Woken { - id, - list: woken.clone(), - })) - }) - .collect(); - Self { - requests: requests.into_iter().map(Box::pin).collect(), - wakers, - woken, - } - } - - fn is_woken(&self) -> bool { - !self.woken.lock().unwrap().is_empty() - } - - /// Polls the woken requests until none are, asserting each is still waiting. - fn drain(&mut self) { - loop { - let mut ids = std::mem::take(&mut *self.woken.lock().unwrap()); - if ids.is_empty() { - return; - } - ids.sort_unstable(); - ids.dedup(); - for id in ids { - let mut cx = Context::from_waker(&self.wakers[id]); - assert!(self.requests[id].as_mut().poll(&mut cx).is_pending()); - } - } - } -} - -/// Waiting requests have already received an unroutable verdict. Repricing a -/// covering route wakes them; repricing an unrelated route must leave them asleep. -/// Shared paths isolate requester fan-out from the cost of minting one front per path. -/// Only woken requests are polled, so harness polling does not scale with requesters. -fn bench_unroutable_churn(c: &mut Criterion) { - let mut group = c.benchmark_group("origin/unroutable_churn"); - group.sample_size(20); - for covering in [false, true] { - for requesters in [0, 1, 32, 256] { - for distinct in [false, true] { - if distinct && requesters <= 1 { - continue; - } - for changes in [1, 32] { - let scope = if covering { "covering" } else { "unrelated" }; - let paths = if distinct { "distinct" } else { "shared" }; - let id = BenchmarkId::new(scope, format!("{requesters}r_{changes}c_{paths}")); - group.throughput(Throughput::Elements(changes)); - group.bench_function(id, |b| { - let (producer, mut driver) = origin::Producer::new(origin::Config::default()); - let consumer = producer.consume(); - let server = moq_net::fuzz::requests_route( - &producer, - moq_net::Path::from_static("room"), - origin::Route::default(), - ) - .unwrap(); - let unrelated = moq_net::fuzz::requests_route( - &producer, - moq_net::Path::from_static("other"), - origin::Route::default(), - ) - .unwrap(); - let mut waiting = Waiting::new( - (0..requesters) - .map(|i| { - consumer.routed_broadcast(format!("room/job-{}", if distinct { i } else { 0 })) - }) - .collect(), - ); - let waiter = kio::Waiter::noop(); - let now = moq_net::time::Instant::now(); - // Drive the first requests to refusal before measuring any route churn. - waiting.drain(); - driver.poll(now, &waiter).unwrap(); - let expected = if distinct { - requesters - } else { - usize::from(requesters > 0) - }; - for _ in 0..expected { - let Poll::Ready(Ok(request)) = server.poll_requested_broadcast(&waiter) else { - panic!("every distinct path reaches the covering handler"); - }; - request.reject(moq_net::Error::Unroutable); - } - driver.poll(now, &waiter).unwrap(); - waiting.drain(); - assert!(server.poll_requested_broadcast(&waiter).is_pending()); - let changed = if covering { &server } else { &unrelated }; - let mut cost = 1; - b.iter(|| { - for _ in 0..changes { - cost = 3 - cost; - moq_net::fuzz::update_route(changed, origin::Route::default().with_cost(cost)).unwrap(); - assert!(covering || !waiting.is_woken(), "unrelated churn wakes no request"); - waiting.drain(); - driver.poll(now, &waiter).unwrap(); - for _ in 0..if covering { expected } else { 0 } { - let Poll::Ready(Ok(request)) = server.poll_requested_broadcast(&waiter) else { - panic!("covering churn re-asks every distinct path"); - }; - request.reject(moq_net::Error::Unroutable); - } - assert!(server.poll_requested_broadcast(&waiter).is_pending()); - driver.poll(now, &waiter).unwrap(); - assert!(covering || !waiting.is_woken(), "unrelated churn wakes no request"); - waiting.drain(); - } - }); - }); - } - } - } - } - group.finish(); -} - /// A front minted, resolved, and retired once its holder leaves, among `fronts` /// others held open. A retiring front leaves the table it shares with them, so a /// cost that grows with the table rather than with the one path shows up as a slope. @@ -845,7 +696,7 @@ fn bench_retire(c: &mut Criterion) { let mut fleet = fanout(fronts + 1, 0); let waiter = kio::Waiter::noop(); let held: Vec<_> = (0..fronts) - .map(|i| fleet.consumer.request_broadcast(format!("room/{i}"), None)) + .map(|i| fleet.consumer.request(format!("room/{i}"), None)) .collect(); fleet.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); let _held: Vec<_> = held @@ -854,7 +705,7 @@ fn bench_retire(c: &mut Criterion) { .collect(); let path = format!("room/{fronts}"); b.iter(|| { - let pending = fleet.consumer.request_broadcast(&path, None); + let pending = fleet.consumer.request(&path, None); fleet.driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); drop(pending.now_or_never().expect("resolved once driven").expect("local")); // Nothing holds it and a local source keeps no track, so it retires here. @@ -915,7 +766,7 @@ fn pool(members: usize, paths: usize, cursors: usize) -> Pool { let waiter = kio::Waiter::noop(); let requests: Vec<_> = (0..paths) - .map(|i| consumer.request_broadcast(format!("pool/job-{i}"), None)) + .map(|i| consumer.request(format!("pool/job-{i}"), None)) .collect(); driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); let mut producers = Vec::with_capacity(paths); @@ -970,7 +821,7 @@ fn bench_restart_fronts(c: &mut Criterion) { let consumer = pool.producer.consume(); paths .iter() - .map(|path| consumer.request_broadcast(path, None)) + .map(|path| consumer.request(path, None)) .collect::>() }, BatchSize::PerIteration, @@ -1083,7 +934,7 @@ fn bench_handoff(c: &mut Criterion) { first.write_frame(Timestamp::ZERO, b"one".as_ref()).unwrap(); first.finish().unwrap(); - let resolved = consumer.request_broadcast("room/live", None).await.unwrap(); + let resolved = consumer.request("room/live", None).await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); subscription.recv_group().await.unwrap().expect("first group"); @@ -1095,7 +946,7 @@ fn bench_handoff(c: &mut Criterion) { second.finish().unwrap(); // Announcing is what makes the standby a route the front can take. standby.announce(origin::Route::default()).unwrap(); - let replaced = consumer.request_broadcast("room/live", None).await.unwrap(); + let replaced = consumer.request("room/live", None).await.unwrap(); let mut replacement = replaced.track("video").unwrap().subscribe(None).await.unwrap(); let group = replacement.recv_group().await.unwrap().expect("standby group"); total += started.elapsed(); @@ -1164,7 +1015,13 @@ async fn watching(routes: usize, subscribers: usize) -> Watching { let mut subscriptions = Vec::new(); for index in 0..subscribers { - let remote = received.consume().routed_broadcast(watched_path(index)).await.unwrap(); + let remote = received + .consume() + .follow(watched_path(index), None) + .unwrap() + .available() + .await + .unwrap(); let subscription = remote.track("video").unwrap().subscribe(None).await.unwrap(); subscriptions.push(subscription); } @@ -1290,7 +1147,7 @@ fn bench_relay(c: &mut Criterion) { .map(|i| broadcast.create_track(format!("{i}"), timed()).unwrap()) .collect(); let mut subscriptions = runtime.block_on(async { - let resolved = producer.consume().request_broadcast("room/live", None).await.unwrap(); + let resolved = producer.consume().request("room/live", None).await.unwrap(); let mut subscriptions = Vec::new(); for i in 0..tracks { let track = resolved.track(&format!("{i}")).unwrap(); @@ -1348,7 +1205,7 @@ fn bench_passthrough(c: &mut Criterion) { let broadcast = producer.publish("room/live", origin::Route::default()).unwrap(); let source = broadcast.create_track("0", timed()).unwrap(); let mut subscriptions = runtime.block_on(async { - let resolved = producer.consume().request_broadcast("room/live", None).await.unwrap(); + let resolved = producer.consume().request("room/live", None).await.unwrap(); let track = resolved.track("0").unwrap(); let mut subscriptions = Vec::with_capacity(readers); for _ in 0..readers { @@ -1406,7 +1263,7 @@ fn bench_parked(c: &mut Criterion) { .collect(); let _writers: Vec<_> = sources.iter().map(|source| source.append_group().unwrap()).collect(); let (subscriptions, mut groups) = runtime.block_on(async { - let resolved = producer.consume().request_broadcast("room/live", None).await.unwrap(); + let resolved = producer.consume().request("room/live", None).await.unwrap(); let mut subscriptions = Vec::new(); let mut groups = Vec::new(); for i in 0..tracks { @@ -1514,7 +1371,7 @@ async fn copy_walk(tracks: usize, copies: usize) -> CopyWalk { let epoch = Epoch::mint(); let first = Generation::build(&producer, tracks); first.route(&epoch); - let resolved = moq_clock::timeout(COPY_WAIT, producer.consume().request_broadcast(COPY_PATH, None)) + let resolved = moq_clock::timeout(COPY_WAIT, producer.consume().request(COPY_PATH, None)) .await .expect("front did not resolve") .expect("front refused"); @@ -1675,7 +1532,7 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { (broadcast, track) }; let mut generations = vec![generation(&mut (0..retained))]; - let resolved = moq_clock::timeout(COPY_WAIT, producer.consume().request_broadcast(COPY_PATH, None)) + let resolved = moq_clock::timeout(COPY_WAIT, producer.consume().request(COPY_PATH, None)) .await .expect("front did not resolve") .expect("front refused"); @@ -1790,7 +1647,6 @@ criterion_group!( bench_serve_idle, bench_subscribe, bench_request, - bench_unroutable_churn, bench_retire, bench_restart_fronts, bench_pool_churn, diff --git a/rs/moq-net/benches/path.rs b/rs/moq-net/benches/path.rs index 566d08a3635..2b8f5bd2621 100644 --- a/rs/moq-net/benches/path.rs +++ b/rs/moq-net/benches/path.rs @@ -144,10 +144,10 @@ fn requests() { let target = format!("{s}/0"); let target_path = Path::new(&target).unwrap(); allocs(&format!("origin/request_str/{name}"), 2_000, 1, || { - local(&|| consumer.request_broadcast(target.as_str(), None)) + local(&|| consumer.request(target.as_str(), None)) }); allocs(&format!("origin/request_path/{name}"), 2_000, 1, || { - local(&|| consumer.request_broadcast(&target_path, None)) + local(&|| consumer.request(&target_path, None)) }); // A rooted handle joins its root onto every path it is given. @@ -155,12 +155,12 @@ fn requests() { let rooted = consumer.scope(root, &Patterns::from(Pattern::all())).unwrap(); let rooted_target = format!("{rest}/0"); allocs(&format!("origin/request_rooted_str/{name}"), 2_000, 1, || { - local(&|| rooted.request_broadcast(rooted_target.as_str(), None)) + local(&|| rooted.request(rooted_target.as_str(), None)) }); let missing = format!("{s}/missing"); allocs(&format!("origin/unroutable_str/{name}"), 2_000, 1, || { - let result = consumer.request_broadcast(missing.as_str(), None).now_or_never(); + let result = consumer.request(missing.as_str(), None).now_or_never(); assert!(matches!(result, Some(Err(moq_net::Error::Unroutable)))); }); } diff --git a/rs/moq-net/benches/session/mod.rs b/rs/moq-net/benches/session/mod.rs index 603833d728e..3858423210c 100644 --- a/rs/moq-net/benches/session/mod.rs +++ b/rs/moq-net/benches/session/mod.rs @@ -534,7 +534,14 @@ struct Viewer { impl Viewer { /// Resolve `path` and subscribe to each of its `tracks`. async fn watch(&mut self, path: &str, tracks: &[impl AsRef], subscription: Option) { - let broadcast = self.origin.consume().routed_broadcast(path).await.unwrap(); + let broadcast = self + .origin + .consume() + .follow(path, None) + .unwrap() + .available() + .await + .unwrap(); for track in tracks { self.subscribers.push( broadcast @@ -594,7 +601,14 @@ impl Room { let mut viewer = cluster.join((viewer + 1) % shape.relays, false).await; for broadcast in broadcasts { if shape.fetch { - let source = viewer.origin.consume().routed_broadcast(path(broadcast)).await.unwrap(); + let source = viewer + .origin + .consume() + .follow(path(broadcast), None) + .unwrap() + .available() + .await + .unwrap(); viewer.fetches.push((broadcast, source.track(TRACK).unwrap())); } else { viewer.watch(&path(broadcast), &[TRACK], shape.subscription()).await; @@ -1267,7 +1281,16 @@ impl ChurnRoom { for _ in 0..shape.sessions { let mut viewer = cluster.join(0, false).await; viewer.watch(&path(0), &held, None).await; - broadcasts.push(viewer.origin.consume().routed_broadcast(path(0)).await.unwrap()); + broadcasts.push( + viewer + .origin + .consume() + .follow(path(0), None) + .unwrap() + .available() + .await + .unwrap(), + ); viewers.push(viewer); } Self { diff --git a/rs/moq-net/benches/viewers.rs b/rs/moq-net/benches/viewers.rs index adb8a73378a..e20ebd01a68 100644 --- a/rs/moq-net/benches/viewers.rs +++ b/rs/moq-net/benches/viewers.rs @@ -112,7 +112,7 @@ impl Room { fn join(&mut self, n: usize) -> moq_net::track::Subscriber { let session = moq_net::fuzz::excluding(self.producer.consume(), Hop::random()); let path = format!("room/{}", n % self.broadcasts); - let resolved = self.drive(session.request_broadcast(path, None)).unwrap(); + let resolved = self.drive(session.request(path, None)).unwrap(); let mut subscription = self.drive(resolved.track("video").unwrap().subscribe(None)).unwrap(); self.drive(subscription.recv_group()) .unwrap() diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 1a423f775e1..62e6c8aaada 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -991,7 +991,7 @@ impl Publisher { return Ok(None); }; // The immediate lookup: answering a peer never starts discovery of its own. - let requesting = origin.request(path.clone(), epoch.as_ref()); + let requesting = origin.lookup(path.clone(), epoch.as_ref()); self.until_withdrawn(stream, |waiter| requesting.poll_ok(waiter)) .await .transpose() @@ -10912,7 +10912,7 @@ mod serve_tests { let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); let _track = broadcast.create_track("video", info).unwrap(); let (downstream, _sessions) = crate::lite::ietf::test_hop(&upstream, "room", [true, true]).await; - let broadcast = downstream.consume().request_broadcast("room", None).await.unwrap(); + let broadcast = downstream.consume().request("room", None).await.unwrap(); broadcast.track("video").unwrap().info().await.unwrap() } diff --git a/rs/moq-net/src/ietf/publisher/tracks.rs b/rs/moq-net/src/ietf/publisher/tracks.rs index c24e63efaa4..066a563f983 100644 --- a/rs/moq-net/src/ietf/publisher/tracks.rs +++ b/rs/moq-net/src/ietf/publisher/tracks.rs @@ -601,7 +601,7 @@ impl Publisher { // Resolving may wait on a route for the broadcast, which its going ends. let resolved = { - let mut requesting = std::pin::pin!(request.origin.request_broadcast(&suffix, epoch)); + let mut requesting = std::pin::pin!(request.origin.request(&suffix, epoch)); kio::wait(|waiter| { if route.poll_closed(waiter).is_ready() || request.live.poll_closed(waiter).is_ready() { return Poll::Ready(None); diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 25331e67790..ed6fa325a39 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -8012,7 +8012,7 @@ mod tests { for version in [Version::Draft18, Version::Draft22] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let source = origin.publish("broadcast", Default::default()).unwrap(); - let resolved = origin.consume().request_broadcast("broadcast", None).await.unwrap(); + let resolved = origin.consume().request("broadcast", None).await.unwrap(); let peer = Arc::new(Peer { version, dynamic: Mutex::new(Some(source.requests())), @@ -8484,7 +8484,12 @@ mod tests { /// The current best route covering `path`, if any (synchronous peek). fn routed_now(consumer: &crate::origin::Consumer, path: &str) -> Option { use futures::FutureExt; - consumer.routed(path).now_or_never().flatten() + match consumer.routes(path).ok()?.next().now_or_never()?? { + crate::announce::Event::End(_) => None, + crate::announce::Event::Start(announce) + | crate::announce::Event::Update(announce) + | crate::announce::Event::Restart(announce) => Some(announce.route), + } } fn hop_path(ids: &[u64]) -> cluster::HopPath { @@ -10459,7 +10464,8 @@ mod tests { } let issued = issued.expect("the announce never presented its token"); - let mut routing = std::pin::pin!(consumer.routed_broadcast("room/alice")); + let mut following = consumer.follow("room/alice", None).unwrap(); + let mut routing = std::pin::pin!(following.available()); let mut broadcast = None; for _ in 0..500 { assert!(futures::poll!(run.as_mut()).is_pending(), "the announce ended early"); diff --git a/rs/moq-net/src/lite/ietf.rs b/rs/moq-net/src/lite/ietf.rs index d1a8f9da319..b59f5d376de 100644 --- a/rs/moq-net/src/lite/ietf.rs +++ b/rs/moq-net/src/lite/ietf.rs @@ -991,7 +991,9 @@ pub(crate) async fn test_hop( ); downstream .consume() - .routed(broadcast) + .routes(broadcast) + .unwrap() + .next() .await .expect("the hop announced the broadcast"); (downstream, [client, server]) @@ -1069,7 +1071,7 @@ mod hop_tests { } async fn subscribe(origin: &crate::origin::Producer) -> (track::Consumer, track::Subscriber) { - let broadcast = moq_clock::timeout(TIMEOUT, origin.consume().request_broadcast("room", None)) + let broadcast = moq_clock::timeout(TIMEOUT, origin.consume().request("room", None)) .await .expect("no broadcast") .unwrap(); @@ -1214,7 +1216,7 @@ mod hop_tests { let _track = broadcast.create_track("video", info).unwrap(); let (downstream, _sessions) = test_hop(&upstream, "room", [true, true]).await; - let broadcast = moq_clock::timeout(TIMEOUT, downstream.consume().request_broadcast("room", None)) + let broadcast = moq_clock::timeout(TIMEOUT, downstream.consume().request("room", None)) .await .expect("no broadcast") .unwrap(); @@ -1454,7 +1456,7 @@ mod hop_tests { head.write_frame(ts(100), b"frame".to_vec()).unwrap(); head.finish().unwrap(); let (downstream, sessions) = test_hop(&upstream, "room", offer).await; - let broadcast = downstream.consume().request_broadcast("room", None).await.unwrap(); + let broadcast = downstream.consume().request("room", None).await.unwrap(); // A listing cannot carry the provenance, so it lists the track untimed even when // negotiated: a relay re-listing it would otherwise advertise it as native lite. let mut tracks = broadcast.tracks().unwrap(); diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index c4d32173d53..126754c94b0 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -1682,7 +1682,7 @@ impl RequestServe { // errors when there is none. let origin = ready!(self.shared.poll_serving_origin(waiter)); let path = R::target(msg).0.clone(); - *requesting = Some(origin.request(path, R::epoch(msg)).into_inner()); + *requesting = Some(origin.lookup(path, R::epoch(msg)).into_inner()); } let broadcast = ready!(requesting.as_ref().expect("requesting").poll_ok(waiter))?; // Any placeholder but `Decode`, so a failed start is answered on the stream. @@ -5942,7 +5942,7 @@ mod serve_group_test { .tier(Default::default()) .session(crate::Path::from_static("egress")), ); - let served = tagged.request_broadcast("room", None).await.unwrap(); + let served = tagged.request("room", None).await.unwrap(); let copy = served.track("test").unwrap(); let subscriber = copy.subscribe(None).await.unwrap(); let session = SinkSession::new(Log::default()).with_datagrams(max); @@ -6583,7 +6583,7 @@ mod serve_group_test { broadcast.announce(Default::default()).unwrap(); let relay = origin(2); let _upstream = connect(version, &publisher, &relay).await; - let remote = relay.consume().routed_broadcast("room").await.unwrap(); + let remote = relay.consume().follow("room", None).unwrap().available().await.unwrap(); let mut keeper = match warm { true => Some( remote @@ -6608,7 +6608,13 @@ mod serve_group_test { moq_clock::sim::advance(Duration::from_secs(1)).await; let subscriber = origin(3); let _downstream = connect(version, &relay, &subscriber).await; - let remote = subscriber.consume().routed_broadcast("room").await.unwrap(); + let remote = subscriber + .consume() + .follow("room", None) + .unwrap() + .available() + .await + .unwrap(); let mut live = remote .track("test") .unwrap() @@ -7342,15 +7348,11 @@ mod tests { let serving = kio::wait(|waiter| publisher.shared.poll_serving_origin(waiter)).await; use futures::FutureExt; assert!( - serving - .request_broadcast("echoed/x", None) - .now_or_never() - .unwrap() - .is_err(), + serving.request("echoed/x", None).now_or_never().unwrap().is_err(), "served the peer its own route" ); assert!( - serving.request_broadcast("local/x", None).now_or_never().is_none(), + serving.request("local/x", None).now_or_never().is_none(), "withheld an independent route" ); } diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 164e88ef9e8..339ecb7c46f 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -5098,7 +5098,7 @@ mod tests { assert!(announced.ready.is_empty()); let consumer = origin.consume(); - let request = moq_clock::sim::spawn(async move { consumer.request_broadcast("room/7", None).await }); + let request = moq_clock::sim::spawn(async move { consumer.request("room/7", None).await }); let ready = kio::wait(|waiter| announced.ready.poll_pop(waiter)).await.unwrap(); assert_eq!(ready.as_str(), "room/7"); @@ -5150,7 +5150,7 @@ mod tests { announced: &mut Announced, ) -> (crate::broadcast::Consumer, SourceServe) { let consumer = origin.consume(); - let request = moq_clock::sim::spawn(async move { consumer.request_broadcast("pool/p", None).await }); + let request = moq_clock::sim::spawn(async move { consumer.request("pool/p", None).await }); let ready = kio::wait(|waiter| announced.ready.poll_pop(waiter)).await.unwrap(); announced.ready.try_push(ready).unwrap(); announced.poll_serve(subscriber, &kio::Waiter::noop()); @@ -5212,7 +5212,7 @@ mod tests { announced.poll_serve(&subscriber, &kio::Waiter::noop()); let consumer = origin.consume(); - let request = moq_clock::sim::spawn(async move { consumer.request_broadcast("pool/p", None).await }); + let request = moq_clock::sim::spawn(async move { consumer.request("pool/p", None).await }); let ready = kio::wait(|waiter| announced.ready.poll_pop(waiter)).await.unwrap(); announced.ready.try_push(ready).unwrap(); announced.poll_serve(&subscriber, &kio::Waiter::noop()); @@ -5413,7 +5413,7 @@ mod tests { // The peer's own subscription, excluding the hop the server minted for // it, is served from the local front before anything is announced back. let peer = origin.consume().excluding(assigned); - let resolved = peer.request_broadcast("room/host", None).await.expect("resolves"); + let resolved = peer.request("room/host", None).await.expect("resolves"); let mut sub = resolved .track("video") .unwrap() @@ -5459,7 +5459,7 @@ mod tests { // The local front is still the one at the path, and still serving: the // peer's next request joins it rather than minting another. let still = peer - .request_broadcast("room/host", None) + .request("room/host", None) .await .expect("the local front keeps serving"); assert!( diff --git a/rs/moq-net/src/model/broadcast.rs b/rs/moq-net/src/model/broadcast.rs index 6f4a24c2cbc..2d1b0a42680 100644 --- a/rs/moq-net/src/model/broadcast.rs +++ b/rs/moq-net/src/model/broadcast.rs @@ -957,7 +957,7 @@ impl Consumer { let current = { let mut state = self.state.lock(); // An ended broadcast serves nothing new, not even a track it still has: - // the lookup answers what a fresh `request_broadcast` for the path would. + // the lookup answers what a fresh `request` for the path would. // Tracks already handed out are untouched. if state.closing { return Err(Error::Unroutable); diff --git a/rs/moq-net/src/model/follow.rs b/rs/moq-net/src/model/follow.rs index c5ea1ee376a..1f91804f6f4 100644 --- a/rs/moq-net/src/model/follow.rs +++ b/rs/moq-net/src/model/follow.rs @@ -5,7 +5,7 @@ use super::origin_impl::{Announce, AnnounceConsumer, AnnounceEvent, Consumer, Re use crate::{Epoch, Error, Path, broadcast}; /// The announcements covering one path, as one broadcast coming online, being replaced, and -/// going offline. Created by [`Consumer::follow`](crate::origin::Consumer::follow). +/// going offline. Created by [`Consumer::routes`]. /// /// Several routes can cover the path at once, such as the path itself and a prefix above it, /// and a request resolves through the most specific one, so only that route's events come @@ -13,7 +13,7 @@ use crate::{Epoch, Error, Path, broadcast}; /// carry the same epoch: those serve the same bytes, so it is an /// [`Update`](AnnounceEvent::Update). Routes beneath the path serve other broadcasts and are /// ignored. -pub struct Follow { +pub(crate) struct Follow { announced: AnnounceConsumer, path: Path, /// Every route standing over the path. @@ -52,7 +52,7 @@ impl Follow { } /// The next change to the route serving the path, or `None` once the origin closes. - #[cfg(feature = "async")] + #[cfg(all(test, feature = "async"))] pub async fn next(&mut self) -> Option { kio::wait(|waiter| self.poll_next(waiter)).await } @@ -101,17 +101,11 @@ impl Follow { /// Poll until every source feeding this follower has synced, registering `waiter` until /// then. A path [`poll_next`](Self::poll_next) has not started by then is not announced, - /// rather than not heard yet. See [`announce::Consumer::poll_synced`](crate::announce::Consumer::poll_synced). + /// rather than not heard yet. See [`AnnounceConsumer::poll_synced`]. pub fn poll_synced(&self, waiter: &kio::Waiter) -> Poll<()> { self.announced.poll_synced(waiter) } - /// Wait until every source feeding this follower has synced; see [`Self::poll_synced`]. - #[cfg(feature = "async")] - pub async fn synced(&self) { - kio::wait(|waiter| self.poll_synced(waiter)).await - } - /// The cursor's next event, counting what it delivers and when it runs dry. fn poll_announced(&mut self, waiter: &kio::Waiter) -> Poll> { let poll = self.announced.poll_next(waiter); @@ -192,8 +186,8 @@ impl Follow { } /// Each publisher instance serving one path, handed out as it takes over. Created by -/// [`Consumer::announced_broadcast`](crate::origin::Consumer::announced_broadcast). -pub struct AnnouncedBroadcast { +/// [`Consumer::follow`](crate::origin::Consumer::follow). +pub struct Following { consumer: Consumer, path: Path, /// The only instance handed out, if pinned. @@ -208,7 +202,7 @@ pub struct AnnouncedBroadcast { last: Option, } -impl AnnouncedBroadcast { +impl Following { pub(super) fn new(consumer: Consumer, path: Path, epoch: Option, follow: Follow) -> Self { Self { consumer, @@ -222,7 +216,7 @@ impl AnnouncedBroadcast { } /// Wait for the next publisher instance serving the path; see - /// [`Consumer::announced_broadcast`](crate::origin::Consumer::announced_broadcast). + /// [`Consumer::follow`](crate::origin::Consumer::follow). /// /// Returns [`Error::Closed`] once the origin closes, and any other resolution failure /// as-is. Dropping the future keeps the wait's progress for the next call. @@ -331,7 +325,7 @@ mod tests { #[moq_clock::test] async fn follow_reports_the_route_serving_the_path() { let origin = Hop::new(1).unwrap().produce(); - let mut follow = origin.consume().follow("pool/job").unwrap(); + let mut follow = origin.consume().routes("pool/job").unwrap(); let epoch = Epoch::mint(); // A prefix above the path covers it. @@ -373,7 +367,7 @@ mod tests { let _pool = origin.requests_route("pool", Route::default()).unwrap(); let _exact = origin.publish("pool/job", Route::default()).unwrap(); - let mut follow = origin.consume().follow("pool/job").unwrap(); + let mut follow = origin.consume().routes("pool/job").unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); quiet(&mut follow).await; } @@ -385,7 +379,7 @@ mod tests { let origin = Hop::new(1).unwrap().produce(); let epoch = Epoch::mint(); let exact = origin.publish("pool/job", route(&epoch)).unwrap(); - let mut follow = origin.consume().follow("pool/job").unwrap(); + let mut follow = origin.consume().routes("pool/job").unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); // Both land before the follower reads again, and the cursor delivers the prefix's start @@ -408,7 +402,7 @@ mod tests { async fn follow_hands_over_to_a_prefix_that_started_before_the_last_change() { let origin = Hop::new(1).unwrap().produce(); let exact = origin.publish("pool/job", route(&Epoch::mint())).unwrap(); - let mut follow = origin.consume().follow("pool/job").unwrap(); + let mut follow = origin.consume().routes("pool/job").unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); let epoch = Epoch::mint(); @@ -424,7 +418,7 @@ mod tests { #[moq_clock::test] async fn follow_restarts_onto_a_more_specific_route_without_an_epoch() { let origin = Hop::new(1).unwrap().produce(); - let mut follow = origin.consume().follow("pool/job").unwrap(); + let mut follow = origin.consume().routes("pool/job").unwrap(); let _pool = origin.requests_route("pool", Route::default()).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool".into())); @@ -444,7 +438,7 @@ mod tests { .unwrap() .requests_route("room/alice", Route::default()) .unwrap(); - let mut follow = origin.consume().follow("room/alice").unwrap(); + let mut follow = origin.consume().routes("room/alice").unwrap(); let first = origin.publish("room/alice", Route::default().with_cost(5)).unwrap(); let event = moq_clock::timeout(Duration::from_secs(1), follow.next()) @@ -470,7 +464,7 @@ mod tests { } /// The next instance handed out, which must arrive within the origin's update hold. - async fn available(announced: &mut AnnouncedBroadcast) -> broadcast::Consumer { + async fn available(announced: &mut Following) -> broadcast::Consumer { moq_clock::timeout(Duration::from_secs(1), announced.available()) .await .expect("no instance") @@ -478,7 +472,7 @@ mod tests { } /// Nothing more is handed out past the origin's update hold. - async fn none(announced: &mut AnnouncedBroadcast) { + async fn none(announced: &mut Following) { let hold = super::super::origin_impl::DEFAULT_UPDATE_HOLD * 2; if let Ok(result) = moq_clock::timeout(hold, announced.available()).await { panic!( @@ -502,7 +496,7 @@ mod tests { async fn announced_hands_out_a_held_takeover_once() { let origin = Hop::new(1).unwrap().produce(); let dynamic = origin.requests("live").unwrap(); - let mut announced = origin.consume().announced_broadcast("live", None).unwrap(); + let mut announced = origin.consume().follow("live", None).unwrap(); // The wait is on the dynamic route's answer when the exact path takes over without an epoch. let (_takeover, _publish) = futures::join!(available(&mut announced), async { @@ -518,7 +512,7 @@ mod tests { async fn announced_hands_out_a_dropped_takeover_again() { let origin = Hop::new(1).unwrap().produce(); let dynamic = origin.requests("live").unwrap(); - let mut announced = origin.consume().announced_broadcast("live", None).unwrap(); + let mut announced = origin.consume().follow("live", None).unwrap(); let (dropped, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; @@ -538,7 +532,7 @@ mod tests { async fn announced_hands_out_a_gap_while_resolving_once() { let origin = Hop::new(1).unwrap().produce(); let dynamic = origin.requests("").unwrap(); - let mut announced = origin.consume().announced_broadcast("live", None).unwrap(); + let mut announced = origin.consume().follow("live", None).unwrap(); let (_arrival, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; @@ -556,7 +550,7 @@ mod tests { async fn announced_hands_out_the_instance_again_after_an_end() { let origin = Hop::new(1).unwrap().produce(); let epoch = Epoch::mint(); - let mut announced = origin.consume().announced_broadcast("live", None).unwrap(); + let mut announced = origin.consume().follow("live", None).unwrap(); let exact = origin.publish("live", route(&epoch)).unwrap(); let first = available(&mut announced).await; @@ -576,7 +570,7 @@ mod tests { let origin = Hop::new(1).unwrap().produce(); let epoch = Epoch::mint(); let _first = origin.publish("live", route(&epoch)).unwrap(); - let mut announced = origin.consume().announced_broadcast("live", epoch.clone()).unwrap(); + let mut announced = origin.consume().follow("live", epoch.clone()).unwrap(); let pinned = available(&mut announced).await; assert_eq!(pinned.info().epoch.as_ref(), Some(&epoch)); @@ -584,7 +578,7 @@ mod tests { none(&mut announced).await; // Unpinned, the same takeover is followed. - let mut unpinned = origin.consume().announced_broadcast("live", None).unwrap(); + let mut unpinned = origin.consume().follow("live", None).unwrap(); let current = available(&mut unpinned).await; assert_ne!(current.info().epoch.as_ref(), Some(&epoch)); } @@ -594,7 +588,7 @@ mod tests { let origin = Hop::new(1).unwrap().produce(); let epoch = Epoch::mint(); let first = origin.publish("live", route(&epoch)).unwrap(); - let mut announced = origin.consume().announced_broadcast("live", epoch.clone()).unwrap(); + let mut announced = origin.consume().follow("live", epoch.clone()).unwrap(); assert_eq!(available(&mut announced).await.info().epoch.as_ref(), Some(&epoch)); first.unannounce(); none(&mut announced).await; @@ -606,7 +600,7 @@ mod tests { async fn announced_reports_a_dropped_prepared_answer() { let origin = Hop::new(1).unwrap().produce(); let claim = origin.requests("live").unwrap(); - let mut announced = origin.consume().announced_broadcast("live", None).unwrap(); + let mut announced = origin.consume().follow("live", None).unwrap(); let (result, ()) = futures::join!( moq_clock::timeout(Duration::from_secs(1), announced.available()), async { @@ -626,7 +620,7 @@ mod tests { fn follow_refuses_a_path_no_pattern_can_spell() { let origin = Hop::new(1).unwrap().produce(); assert!(matches!( - origin.consume().follow("camera*main"), + origin.consume().routes("camera*main"), Err(Error::InvalidPath(_)) )); } @@ -637,6 +631,6 @@ mod tests { let origin = Hop::new(1).unwrap().produce(); let scope = Patterns::from(Pattern::subtree("pool/job/cam").unwrap()); let scoped = origin.consume().scope("", &scope).unwrap(); - assert!(matches!(scoped.follow("pool/job"), Err(Error::Unauthorized))); + assert!(matches!(scoped.routes("pool/job"), Err(Error::Unauthorized))); } } diff --git a/rs/moq-net/src/model/mod.rs b/rs/moq-net/src/model/mod.rs index caf9fc7d0d6..b961c3a6e9a 100644 --- a/rs/moq-net/src/model/mod.rs +++ b/rs/moq-net/src/model/mod.rs @@ -48,7 +48,7 @@ pub use timed::Timed; /// Publishing broadcasts, announcing routes, and consuming both through an origin. pub mod origin { - pub use super::follow::AnnouncedBroadcast; + pub use super::follow::Following; #[cfg(feature = "async")] // private: capability gap pub(crate) use super::origin_impl::Lookup; @@ -60,7 +60,6 @@ pub mod origin { /// Subscribing to route (un)announcements from an origin. pub mod announce { - pub use super::follow::Follow; pub use super::origin_impl::{Announce, AnnounceConsumer as Consumer, AnnounceEvent as Event}; } diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 74084355d9c..f3601232a45 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -14,7 +14,7 @@ use rand::RngExt; use super::{ RequestQueue, WeakCache, WeakEntry, - follow::AnnouncedBroadcast, + follow::{Follow, Following}, front::{Action, Candidate, Event, Front, Refusal}, }; use crate::{ @@ -1380,7 +1380,7 @@ fn prefix_claim(prefix: &Path) -> Result { #[derive(Default)] struct ServeState { // Result channels for pending requests, keyed by absolute path so concurrent - // `request_broadcast` calls for the same path coalesce onto one channel. + // `request` calls for the same path coalesce onto one channel. requests: RequestQueue>, // Broadcasts the handler has already served, kept weakly so a repeat request for the @@ -1939,7 +1939,7 @@ pub enum AnnounceEvent { /// An announcement is always a prefix, never a broadcast: it advertises that /// [`prefix`](Self::prefix) and every path beneath it are servable. A broadcast /// announces its own path, so the prefix usually names one, but resolve it with -/// [`Consumer::request_broadcast`]; the application decides which paths name +/// [`Consumer::request`]; the application decides which paths name /// broadcasts, and filters with a [`Pattern`] locally when it wants a subset. #[derive(Clone, Debug)] pub struct Announce { @@ -3069,7 +3069,7 @@ impl Drop for DriverState { } } -/// Everything [`run_front`] owns, queued by [`Consumer::request_broadcast`]. +/// Everything [`run_front`] owns, queued by [`Consumer::request`]. struct FrontTask { /// The route table the front selects from. shared: SendCell>, @@ -5465,7 +5465,7 @@ impl Resolution { } /// A served route, from [`Producer::requests`]: advertises a path prefix and -/// answers the [`Consumer::request_broadcast`] calls beneath it. +/// answers the [`Consumer::request`] calls beneath it. /// /// The origin-level analogue of [`broadcast::Requests`]: where that serves tracks /// on demand within a broadcast, this serves whole broadcasts on demand within @@ -5629,7 +5629,7 @@ impl ServeState { /// rejection stands) or this write lands first and the teardown finds the /// entry already gone. The queue lock is released before the channel guard /// drops, so the requester wakes outside it: an inline executor re-entering - /// `request_broadcast` from the wake must not find the non-reentrant lock + /// `request` from the wake must not find the non-reentrant lock /// still held. fn resolve( shared: &kio::Shared, @@ -5709,7 +5709,7 @@ impl ServeState { /// A pending request for a broadcast to be served on demand. /// /// Yielded by [`Requests::poll_requested_broadcast`]. The requester is awaiting inside -/// [`Consumer::request_broadcast`]; [`prepare`](Self::prepare) then [`Prepared::publish`] +/// [`Consumer::request`]; [`prepare`](Self::prepare) then [`Prepared::publish`] /// resolves it with a new exact-path broadcast, and [`reject`](Self::reject) resolves it /// with an error. Dropping the request without either rejects it. /// @@ -5850,7 +5850,7 @@ pub(crate) struct Lookup { enum RequestState { // Unroutable at request time: resolves immediately with this error. Baked in so - // `request_broadcast` itself stays infallible. + // `request` itself stays infallible. Failed(Error), // Joined a front: resolves with the front's broadcast once its verdict is in, held // from the moment of joining so the front cannot retire under the requester. @@ -5948,10 +5948,8 @@ pub struct Requesting { // The publisher instance every ask is pinned to, if any. epoch: Option, // A finite request owns discovery and can conclude absence once its initial set lands. - discovery: Option, + discovery: Option, routed: bool, - // Legacy route-wait callers retry refusals only after the covering routes move. - terminal_refusal: bool, } impl Requesting { @@ -5994,7 +5992,7 @@ impl Requesting { RequestState::Pending { front, .. } => front.read().refused, RequestState::Failed(_) => false, }; - if self.terminal_refusal && refused { + if refused { return Poll::Ready(Err(Error::Unroutable)); } self.request = None; @@ -6035,7 +6033,7 @@ impl Requesting { self.watch = Some((watch, seen)); self.request = Some( self.consumer - .request(self.path.clone(), self.epoch.as_ref()) + .lookup(self.path.clone(), self.epoch.as_ref()) .into_inner(), ); } @@ -6113,7 +6111,7 @@ impl Consume for track::Consumer { /// /// Clones share the underlying state without allocating any per-cursor /// resources. To receive route announcements, call [`Self::announced`]; to -/// resolve a path into a broadcast, call [`Self::request_broadcast`]. +/// resolve a path into a broadcast, call [`Self::request`]. #[derive(Clone)] pub struct Consumer { // Identity of the origin this consumer was derived from. @@ -6135,7 +6133,7 @@ pub struct Consumer { // Split horizon: routes whose hop chain or announcing session (`via`) is the // excluded peer are invisible to `announced` and skipped by - // `request_broadcast`, so a peer is never served (or advertised) its own + // `request`, so a peer is never served (or advertised) its own // content back. A local view (`Self::local`) hides peer routes the same way, // and a view taken from an upstream handle hides upstream routes. horizon: Horizon, @@ -6154,7 +6152,7 @@ pub struct Consumer { cache_duration: Duration, // Non-owning submission handle to the origin's [`Driver`], for the front - // watcher a routed `request_broadcast` spawns. Non-owning so a lingering + // watcher a routed `request` spawns. Non-owning so a lingering // read handle never keeps the driver from finishing. tasks: TasksWeak, @@ -6214,7 +6212,7 @@ impl Consumer { /// A view of the routes that entered here: every route a handle marked /// [`Link::Peer`] or [`Link::Upstream`] handle announced is hidden from [`Self::announced`] and never - /// resolved by [`Self::request_broadcast`]. + /// resolved by [`Self::request`]. /// /// On a relay, this is what the relay ingests itself, from clients and /// in-process producers, as opposed to what its cluster peers forward. @@ -6440,36 +6438,13 @@ impl Consumer { .and_then(|entry| entry.source.clone()) } - /// Block until an announced route covers `path`, and return it. - /// - /// Covering means the route's prefix is a (segment-wise) prefix of `path`, - /// including the exact path itself. Returns `None` if the path is outside this - /// consumer's scope or the consumer is closed first. - /// - /// To resolve a broadcast rather than inspect the route, use - /// [`Self::routed_broadcast`]: pairing this with [`Self::request_broadcast`] - /// leaves a gap where the covering route can retract. - #[cfg(feature = "async")] - pub async fn routed(&self, path: impl TryInto>) -> Option { - // A follower's first event is always a start. - match self.follow(path).ok()?.next().await? { - AnnounceEvent::Start(announce) | AnnounceEvent::Update(announce) | AnnounceEvent::Restart(announce) => { - Some(announce.route) - } - AnnounceEvent::End(_) => None, - } - } - /// Follow the announcements of the routes covering `path`, reduced to the one serving it. /// - /// [`Self::announced_broadcast`] resolves each instance this reports. Following by hand: play on a - /// [`Start`](AnnounceEvent::Start), drop everything and request the path afresh on a - /// [`Restart`](AnnounceEvent::Restart), and stop on an [`End`](AnnounceEvent::End). An - /// [`Update`](AnnounceEvent::Update) is the same publisher instance re-priced or failed - /// over, which subscriptions already ride out. Fails with [`Error::Unauthorized`] when - /// this consumer's scope can never cover the path, and with [`Error::InvalidPath`] when no - /// pattern can spell it (a segment containing `*`). - pub fn follow(&self, path: impl TryInto>) -> Result { + /// [`Self::follow`] resolves each instance this reports, and [`Self::request`] concludes + /// absence from its sync. Fails with [`Error::Unauthorized`] when this consumer's scope can + /// never cover the path, and with [`Error::InvalidPath`] when no pattern can spell it (a + /// segment containing `*`). + pub(crate) fn routes(&self, path: impl TryInto>) -> Result { let path = path::convert(path)?; // Scope down to the path itself, which still sees every route whose claim covers it: @@ -6488,29 +6463,7 @@ impl Consumer { // the announce guards. Hiding narrows discovery, not lookup, so a hidden path // follows like any other. let announced = consumer.untagged().with_hidden(true).announced(); - Ok(crate::announce::Follow::new(announced, path)) - } - - /// Resolve `path` to a broadcast: [`Self::request_broadcast`], retried - /// whenever the routes covering the path change. - /// - /// A request answers for the routes as they stand, so it can miss an - /// announcement that has not arrived yet, lose its covering route to - /// failover churn, find a route that covers the path while nothing serves it - /// yet (an advertise-only announce racing its handler), or be turned down by - /// a handler. This rides all of that out by watching the covering routes - /// and asking again each time they move, which is what makes it the right - /// call for resolving a path right after connecting. Returns - /// [`Error::Unauthorized`] for a path outside this consumer's scope, - /// [`Error::Closed`] once the origin closes, and any other resolution - /// failure as-is. Await it, or poll it through [`kio::Task`]. - pub fn routed_broadcast(&self, path: impl TryInto>) -> kio::Pending { - let mut request = match path::convert(path) { - Ok(path) => self.routing(path, None), - Err(err) => self.failed(err), - }; - request.terminal_refusal = false; - kio::Pending::new(request) + Ok(Follow::new(announced, path)) } /// A resolution that already failed with `err`. @@ -6538,16 +6491,14 @@ impl Consumer { epoch, discovery: None, routed: false, - terminal_refusal: true, } } - /// Follow the broadcast at `path`, resolving each publisher instance that serves it. + /// Follow the broadcast at `path` across the publisher instances that serve it. /// - /// The Rust form of JS `request(path, { announced: true })`. The first - /// [`available`](AnnouncedBroadcast::poll_available) resolves the instance serving the path - /// once one is announced, retrying route churn but returning a selected handler's refusal. Each - /// later call waits for another instance to take over (an + /// The first [`available`](Following::poll_available) resolves the instance serving the + /// path once one is announced, retrying route churn but returning a selected handler's + /// refusal. Each later call waits for another instance to take over (an /// [`AnnounceEvent::Restart`]), or for the path to be served again after an /// [`AnnounceEvent::End`], even by the same instance. Drop what was read from the /// previous instance then: its tracks end with an error once its routes go. @@ -6556,14 +6507,14 @@ impl Consumer { /// over is never handed out, and the instance is handed out again if it returns after /// an end. Fails with [`Error::Unauthorized`] when this consumer's scope can never /// cover the path, and with [`Error::InvalidPath`] when no pattern can spell it. - pub fn announced_broadcast( + pub fn follow( &self, path: impl TryInto>, epoch: impl Into>, - ) -> Result { + ) -> Result { let path = path::convert(path)?; - let follow = self.follow(&path)?; - Ok(AnnouncedBroadcast::new(self.clone(), path, epoch.into(), follow)) + let routes = self.routes(&path)?; + Ok(Following::new(self.clone(), path, epoch.into(), routes)) } /// Returns a consumer rooted at `root` and restricted to matching `patterns`. @@ -6622,7 +6573,7 @@ impl Consumer { /// A route claims capability, not inventory: resolving a covered path /// succeeds optimistically, and a path that names nothing surfaces as /// [`Error::NotFound`] on its tracks instead. - pub fn request_broadcast( + pub fn request( &self, path: impl TryInto>, epoch: impl Into>, @@ -6632,7 +6583,7 @@ impl Consumer { Err(err) => return kio::Pending::new(self.failed(err)), }; let mut routing = self.routing(path.clone(), epoch.into()); - match self.follow(&path) { + match self.routes(&path) { Ok(discovery) => { routing.discovery = Some(discovery); if let Some(resolved) = self.root.join(&path).ok().and_then(|named| self.scope.resolve(&named)) { @@ -6643,17 +6594,17 @@ impl Consumer { routing.watch = Some((watch, seen)); } // A requests handler hears an already-routed request at creation time. - routing.request = Some(self.request(path, routing.epoch.as_ref()).into_inner()); + routing.request = Some(self.lookup(path, routing.epoch.as_ref()).into_inner()); } Err(err) => routing.request = Some(Lookup::failed(err)), } kio::Pending::new(routing) } - /// [`Self::request_broadcast`], refused with [`Error::Unroutable`] unless the - /// winning route serves `epoch`: a peer asking for one publisher instance must - /// not be handed another. - pub(crate) fn request(&self, path: Path, epoch: Option<&crate::Epoch>) -> kio::Pending { + /// The routes as they stand now, without discovery or retry: what a session answers a + /// peer's request with. Refused with [`Error::Unroutable`] unless the winning route serves + /// `epoch`: a peer asking for one publisher instance must not be handed another. + pub(crate) fn lookup(&self, path: Path, epoch: Option<&crate::Epoch>) -> kio::Pending { // The path as this handle names it, absolute: what its scope authorizes and // what its egress is counted under, so a read through a mount bills where // the reader asked. @@ -7823,7 +7774,7 @@ mod tests { broadcast.announce(Route::default()).unwrap(); consumer.announced().assert_next_wait(); - let resolved = consumer.request_broadcast(".stats/node", None).await.expect("resolves"); + let resolved = consumer.request(".stats/node", None).await.expect("resolves"); assert_eq!(resolved.info().path.as_str(), ".stats/node"); } @@ -7851,16 +7802,14 @@ mod tests { announced.expect_next_active("cam").await; announced.assert_next_wait(); - consumer.request_broadcast("cam", None).await.expect("resolves"); + consumer.request("cam", None).await.expect("resolves"); for path in [".pro", ".pro/cam", ".pro/cam/.pro/transcode.hang"] { - let refused = consumer - .request_broadcast(path, None) - .now_or_never() - .expect("refused at once"); - assert!(matches!(refused, Err(Error::Unauthorized)), "{path}"); - let refused = consumer.routed_broadcast(path).now_or_never().expect("refused at once"); + let refused = consumer.request(path, None).now_or_never().expect("refused at once"); assert!(matches!(refused, Err(Error::Unauthorized)), "{path}"); - assert!(matches!(consumer.follow(path), Err(Error::Unauthorized)), "{path}"); + assert!( + matches!(consumer.follow(path, None), Err(Error::Unauthorized)), + "{path}" + ); } // Only whole segments: a sibling sharing the prefix text is untouched. let _sibling = producer.publish("p1/.prod", Route::default()).unwrap(); @@ -7917,8 +7866,8 @@ mod tests { let server = producer.requests_route(".svc", Route::default()).unwrap(); let project = mounted(&producer, "p1", &["**"]); - let through = project.request_broadcast(".svc/foo", None); - let direct = producer.consume().request_broadcast(".svc/p1/foo", None); + let through = project.request(".svc/foo", None); + let direct = producer.consume().request(".svc/p1/foo", None); let request = queued(&server).await; assert_eq!(request.path().as_str(), ".svc/p1/foo"); @@ -7972,7 +7921,7 @@ mod tests { announced.assert_next_wait(); // The shadowed path never resolves: the mount answers for it. - let err = project.request_broadcast(".svc/forged", None).await.err().unwrap(); + let err = project.request(".svc/forged", None).await.err().unwrap(); assert!(matches!(err, Error::NotFound | Error::Unroutable), "{err:?}"); } @@ -7986,9 +7935,9 @@ mod tests { let _bar = producer.publish(".svc/p1/bar", Route::default()).unwrap(); let granted = mounted(&producer, "p1", &["foo", ".svc/foo"]); - granted.request_broadcast(".svc/foo", None).await.expect("granted"); + granted.request(".svc/foo", None).await.expect("granted"); let refused = granted - .request_broadcast(".svc/bar", None) + .request(".svc/bar", None) .now_or_never() .expect("refused at once"); assert!(matches!(refused, Err(Error::Unauthorized))); @@ -7998,7 +7947,7 @@ mod tests { let narrower = mounted(&producer, "p1", &["foo"]); let refused = narrower - .request_broadcast(".svc/foo", None) + .request(".svc/foo", None) .now_or_never() .expect("refused at once"); assert!(matches!(refused, Err(Error::Unauthorized))); @@ -8007,7 +7956,7 @@ mod tests { // Another project's mount reaches its own target, never this one's. let other = mounted(&producer, "p2", &["**"]); other.clone().with_hidden(true).announced().assert_next_wait(); - let err = other.request_broadcast(".svc/foo", None).await.err().unwrap(); + let err = other.request(".svc/foo", None).await.err().unwrap(); assert!(matches!(err, Error::Unroutable)); } @@ -8054,7 +8003,7 @@ mod tests { announced.assert_next_wait(); // Beneath the mount the target has no room: refused, never handed to a route. - let err = project.request_broadcast(".svc/x", None).await.err().unwrap(); + let err = project.request(".svc/x", None).await.err().unwrap(); assert!(matches!(err, Error::BoundsExceeded(_)), "{err:?}"); let inside = project.scope(".svc/x", &Patterns::from(Pattern::all())).unwrap(); inside.announced().assert_next_wait(); @@ -8165,7 +8114,7 @@ mod tests { let mut announced = project.announced(); announced.expect_next_active(".svc/foo").await; - project.request_broadcast(".svc/foo", None).await.expect("resolves"); + project.request(".svc/foo", None).await.expect("resolves"); let mut report = stats::Report::default(); registry.report(&mut report); @@ -8231,7 +8180,7 @@ mod tests { peer.expect_next_ended("room/alice").await; broadcast.unannounce(); announced.assert_next_wait(); - let err = consumer.request_broadcast("room/alice", None).await.err().unwrap(); + let err = consumer.request("room/alice", None).await.err().unwrap(); assert!(matches!(err, Error::Unroutable)); // Back on the air, then the end of the broadcast retracts for good. @@ -8512,7 +8461,7 @@ mod tests { .unwrap(); announced.assert_next_wait(); - let pending = consumer.request_broadcast("pool/job-0", None); + let pending = consumer.request("pool/job-0", None); let request = queued(&old).await; let first = broadcast::Info::new().produce(); request.accept(&first); @@ -8522,7 +8471,7 @@ mod tests { drop(old); assert_eq!(announced.expect_next_restarted("pool/job-0").await.hops, hops(&[10])); - let pending = consumer.request_broadcast("pool/job-0", None); + let pending = consumer.request("pool/job-0", None); let request = queued(&new).await; let second = broadcast::Info::new().produce(); request.accept(&second); @@ -8557,7 +8506,7 @@ mod tests { hops(&[new_hop]) ); - let pending = consumer.request_broadcast("pool/job-0", None); + let pending = consumer.request("pool/job-0", None); queued(&new).await.accept(broadcast::Info::new().produce()); pending.await.expect("the replacement resolves"); } @@ -8587,7 +8536,7 @@ mod tests { /// the requester's broadcast. #[cfg(feature = "async")] async fn hold(consumer: &Consumer, path: &str, server: &Requests) -> (broadcast::Producer, broadcast::Consumer) { - let pending = consumer.request_broadcast(path, None); + let pending = consumer.request(path, None); let answer = broadcast::Info::new().produce(); queued(server).await.accept(&answer); (answer, pending.await.expect("the request resolves")) @@ -8653,7 +8602,7 @@ mod tests { assert_eq!(announced.expect_next_restarted("pool").await.cost, Cost::new(1)); quiet(&mut announced).await; // The path still resolves through the front's route, so the re-request joins it. - let joined = consumer.request_broadcast("pool/job", None).await.unwrap(); + let joined = consumer.request("pool/job", None).await.unwrap(); assert!(joined.is_clone(&sticky)); let _z = claim("pool", "pool/job", 13, 3); @@ -8814,7 +8763,7 @@ mod tests { .requests_route("room", Route::default().with_hops(hops(&[10])).with_cost(5)) .unwrap(); - let _pending = consumer.request_broadcast("room/alice", None); + let _pending = consumer.request("room/alice", None); let request = queued(&identified).await; assert_eq!(request.path().as_str(), "room/alice"); assert!( @@ -8838,7 +8787,7 @@ mod tests { .requests_route("room", Route::default().with_hops(hops(&[11])).with_cost(5)) .unwrap(); - let _pending = consumer.request_broadcast("room/alice", None); + let _pending = consumer.request("room/alice", None); let request = queued(&unranked).await; assert_eq!(request.path().as_str(), "room/alice"); assert!( @@ -8958,12 +8907,13 @@ mod tests { #[moq_clock::test] #[cfg(feature = "async")] - async fn routed_broadcast_resolves_once_announced() { + async fn follow_resolves_once_announced() { let producer = origin(1).produce(); let consumer = producer.consume(); // Asking before anything is announced parks instead of failing Unroutable. - let mut resolving = Box::pin(consumer.routed_broadcast("room/alice")); + let mut following = consumer.follow("room/alice", None).unwrap(); + let mut resolving = Box::pin(following.available()); assert!((&mut resolving).now_or_never().is_none()); // Creating is not announcing: still parked. @@ -9004,7 +8954,7 @@ mod tests { assert_eq!(route.hops, hops(&[10])); // The request goes upstream rather than to the local broadcast. - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&server).await; let upstream = broadcast::Info::new().produce(); request.accept(&upstream); @@ -9024,9 +8974,9 @@ mod tests { .unwrap(); let _plain = producer.publish("room/bob", Route::default()).unwrap(); - let alice = consumer.request_broadcast("room/alice", None).await.unwrap(); + let alice = consumer.request("room/alice", None).await.unwrap(); assert_eq!(alice.info().epoch, Some(epoch())); - let bob = consumer.request_broadcast("room/bob", None).await.unwrap(); + let bob = consumer.request("room/bob", None).await.unwrap(); assert_eq!(bob.info().epoch, None); } @@ -9041,10 +8991,7 @@ mod tests { let _local = producer .publish("room/alice", Route::default().with_epoch(epoch()).with_cost(5)) .unwrap(); - let first = consumer - .request_broadcast("room/alice", None) - .await - .expect("resolves locally"); + let first = consumer.request("room/alice", None).await.expect("resolves locally"); let server = producer .requests_route( @@ -9056,7 +9003,7 @@ mod tests { let upstream = broadcast::Info::new().produce(); request.accept(&upstream); - let second = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let second = consumer.request("room/alice", None).await.expect("resolves"); assert!(first.is_clone(&second), "the newcomer joins the front"); } @@ -9081,7 +9028,7 @@ mod tests { let source = producer.publish("room/alice", Route::default()).unwrap(); let video = source.create_track("video", None).unwrap(); - let front = consumer.request_broadcast("room/alice", None).await.unwrap(); + let front = consumer.request("room/alice", None).await.unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+video"); assert_eq!(listed(&mut tracks).await, "synced"); @@ -9107,7 +9054,7 @@ mod tests { let held = source.create_track("held", None).unwrap(); let _live = source.create_track("live", None).unwrap(); - let front = consumer.request_broadcast("room/alice", None).await.unwrap(); + let front = consumer.request("room/alice", None).await.unwrap(); let mut tracks = front.tracks().unwrap(); for event in ["+dropped", "+held", "+live", "synced"] { assert_eq!(listed(&mut tracks).await, event); @@ -9134,7 +9081,7 @@ mod tests { lister.add("video", crate::track::Info::default()).unwrap(); lister.synced(); - let front = consumer.request_broadcast("room/alice", None).await.unwrap(); + let front = consumer.request("room/alice", None).await.unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+video"); assert_eq!(listed(&mut tracks).await, "synced"); @@ -9157,7 +9104,7 @@ mod tests { let _a = local.create_track("a", None).unwrap(); let _b = local.create_track("b", None).unwrap(); - let front = consumer.request_broadcast("room/alice", None).await.unwrap(); + let front = consumer.request("room/alice", None).await.unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+a"); assert_eq!(listed(&mut tracks).await, "+b"); @@ -9186,7 +9133,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer.requests_route("room", Route::default()).unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let _video = upstream.create_track("video", None).unwrap(); queued(&server).await.accept(&upstream); @@ -9209,7 +9156,7 @@ mod tests { let server = producer.requests_route("room/alice", Route::default()).unwrap(); // Were the claim to win, the request would park on its handler forever. - let resolved = moq_clock::timeout(Duration::from_secs(1), consumer.request_broadcast("room/alice", None)) + let resolved = moq_clock::timeout(Duration::from_secs(1), consumer.request("room/alice", None)) .await .expect("the newer hopless route won the tie") .expect("resolves"); @@ -9274,7 +9221,7 @@ mod tests { .unwrap(); assert!(announced.expect_next_active("room/alice").await.hops.is_empty()); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); assert_eq!(resolved.info().path.as_str(), "room/alice"); for _ in 0..20 { moq_clock::sim::yield_now().await; @@ -9291,20 +9238,17 @@ mod tests { let consumer = producer.consume(); let broadcast = producer.publish("room/alice", Route::default()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); broadcast.unannounce(); - let err = consumer.request_broadcast("room/alice", None).await.err().unwrap(); + let err = consumer.request("room/alice", None).await.err().unwrap(); assert!(matches!(err, Error::Unroutable), "joined a retracted front: {err}"); settle(|| resolved.is_closed()).await; assert!(!broadcast.consume().is_closed(), "the broadcast itself lives on"); // Announcing again serves a fresh front. broadcast.announce(Route::default()).unwrap(); - let again = consumer - .request_broadcast("room/alice", None) - .await - .expect("resolves again"); + let again = consumer.request("room/alice", None).await.expect("resolves again"); assert!(!again.is_clone(&resolved)); } @@ -9319,7 +9263,7 @@ mod tests { let broadcast = producer.publish("room/alice", Route::default()).unwrap(); let mut dynamic = broadcast.requests(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let track = resolved.track("video").unwrap(); let subscribing = moq_clock::sim::spawn(async move { track.subscribe(None).await }); let request = moq_clock::timeout(Duration::from_secs(1), dynamic.requested_track()) @@ -9351,7 +9295,7 @@ mod tests { let server = producer .requests_route("room/alice", Route::default().with_hops(hops(&[10]))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let dynamic = upstream.requests(); queued(&server).await.accept(&upstream); @@ -9453,7 +9397,7 @@ mod tests { for viewer in 0..1000 { kio::wait(|waiter| budget.poll_yield(waiter)).await; let session = producer.consume().excluding(Hop::random()); - let pending = session.request_broadcast("room/alice", None); + let pending = session.request("room/alice", None); if viewer == 0 { queued(&server).await.accept(&upstream); } @@ -9487,20 +9431,17 @@ mod tests { let fronts = || producer.shared.lock().fronts.len(); let peer = producer.consume().excluding(origin(7)); - let _local = producer.consume().request_broadcast("room/alice", None); - let _peer = peer.request_broadcast("room/alice", None); + let _local = producer.consume().request("room/alice", None); + let _peer = peer.request("room/alice", None); assert_eq!(fronts(), 1, "a hop no chain names excludes nothing"); // The same publisher, now also reached through the peer. let _echo = producer .requests_route("room", Route::default().with_hops(hops(&[10, 7]))) .unwrap(); - let _filtered = peer.request_broadcast("room/alice", None); + let _filtered = peer.request("room/alice", None); assert_eq!(fronts(), 2, "the peer still shares the plain front"); - let _viewer = producer - .consume() - .excluding(origin(8)) - .request_broadcast("room/alice", None); + let _viewer = producer.consume().excluding(origin(8)).request("room/alice", None); assert_eq!(fronts(), 2, "a viewer left the plain front"); } @@ -9520,7 +9461,7 @@ mod tests { group.write_frame(crate::Timestamp::ZERO, b"live".as_ref()).unwrap(); let fronts = || producer.shared.lock().fronts.len(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); queued(&server).await.accept(&upstream); let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -9550,22 +9491,16 @@ mod tests { let _broadcast = producer.publish("room/alice", Route::default()).unwrap(); let fronts = || producer.shared.lock().fronts.len(); - let first = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let first = consumer.request("room/alice", None).await.expect("resolves"); let front = first.weak(); drop(first); - let again = consumer - .request_broadcast("room/alice", None) - .await - .expect("joins in time"); + let again = consumer.request("room/alice", None).await.expect("joins in time"); assert!(again.is_clone(&front.consume()), "a request in time keeps the front"); drop(again); settle(|| front.is_closed()).await; assert_eq!(fronts(), 0, "a retired front left the table"); - let fresh = consumer - .request_broadcast("room/alice", None) - .await - .expect("a fresh front"); + let fresh = consumer.request("room/alice", None).await.expect("a fresh front"); assert!(!fresh.is_closed()); assert_eq!(fronts(), 1); } @@ -9585,7 +9520,7 @@ mod tests { let source = upstream.create_track("video", None).unwrap(); let fronts = || producer.shared.lock().fronts.len(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); queued(&server).await.accept(&upstream); let resolved = pending.await.expect("resolves"); let reader = resolved.track("video").unwrap().subscribe(None); @@ -9659,12 +9594,12 @@ mod tests { group.write_frame(crate::Timestamp::ZERO, b"live".as_ref()).unwrap(); let fronts = || producer.shared.lock().fronts.len(); - let pending = producer.consume().request_broadcast("room/alice", None); + let pending = producer.consume().request("room/alice", None); queued(&server).await.accept(&upstream); let _viewer = pending.await.expect("the plain front resolves"); let peer = producer.consume().excluding(origin(7)); - let peered = peer.request_broadcast("room/alice", None).await.expect("resolves"); + let peered = peer.request("room/alice", None).await.expect("resolves"); assert_eq!(fronts(), 2, "the peer has a front of its own"); let mut subscription = peered.track("video").unwrap().subscribe(None).await.unwrap(); next_group(&mut subscription).await.unwrap().expect("the live group"); @@ -9691,7 +9626,7 @@ mod tests { .unwrap(); view.expect_next_active("room").await; - let pending = peer.request_broadcast("room/alice", None); + let pending = peer.request("room/alice", None); let source = broadcast::Info::new().produce(); queued(&incumbent).await.accept(&source); let resolved = pending.await.expect("resolves through the incumbent"); @@ -9732,7 +9667,7 @@ mod tests { Route::default().with_epoch(epoch()).with_hops(hops(&[10])).with_cost(5), ) .unwrap(); - let pending = producer.consume().request_broadcast("room/alice", None); + let pending = producer.consume().request("room/alice", None); let upstream = broadcast::Info::new().produce(); let mut dynamic = upstream.requests(); queued(&first_server).await.accept(&upstream); @@ -9897,7 +9832,7 @@ mod tests { let broadcast = producer.publish("room/alice", Route::default()).unwrap(); let mut dynamic = broadcast.requests(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let track = resolved.track("video").unwrap(); let subscribing = moq_clock::sim::spawn(async move { track.subscribe(None).await }); let request = moq_clock::timeout(Duration::from_secs(1), dynamic.requested_track()) @@ -9953,7 +9888,7 @@ mod tests { let consumer = producer.consume(); let broadcast = producer.publish("room/alice", Route::default()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); broadcast.unannounce(); broadcast.announce(Route::default()).unwrap(); @@ -9961,7 +9896,7 @@ mod tests { moq_clock::sim::yield_now().await; } assert!(!resolved.is_closed(), "the front ended across a reannouncement"); - let again = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let again = consumer.request("room/alice", None).await.expect("resolves"); assert!(again.is_clone(&resolved)); } @@ -9974,7 +9909,7 @@ mod tests { // Created but not announced: nobody can reach it, locally included. let broadcast = producer.create_broadcast("room/alice").unwrap(); let err = consumer - .request_broadcast("room/alice", None) + .request("room/alice", None) .now_or_never() .expect("unroutable is synchronous") .err() @@ -9982,13 +9917,13 @@ mod tests { assert!(matches!(err, Error::Unroutable)); broadcast.announce(Route::default()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); assert_eq!(resolved.info().path.as_str(), "room/alice"); drop(broadcast); // Nothing covers an unknown path and no handler exists. let err = consumer - .request_broadcast("room/bob", None) + .request("room/bob", None) .now_or_never() .expect("unroutable is synchronous") .err() @@ -10084,13 +10019,13 @@ mod tests { let refused = producer .consume() - .request_broadcast("room/video", None) + .request("room/video", None) .now_or_never() .expect("an out-of-scope request must be refused synchronously"); assert!(matches!(refused, Err(Error::Unroutable))); assert!(dynamic.requested_broadcast().now_or_never().is_none()); - let _pending = producer.consume().request_broadcast("room/chat", None); + let _pending = producer.consume().request("room/chat", None); let request = queued(&dynamic).await; assert_eq!(request.path().as_str(), "room/chat"); } @@ -10207,7 +10142,7 @@ mod tests { .expect("max depth is allowed"); announced.expect_next_active(&path).await; - let _pending = producer.consume().request_broadcast(&path, None); + let _pending = producer.consume().request(&path, None); let request = queued(&dynamic).await; assert_eq!(request.path().as_str(), path); } @@ -10281,7 +10216,7 @@ mod tests { let server = producer.requests_route("room", Route::default()).unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&server).await; assert_eq!(request.path().as_str(), "room/alice"); @@ -10293,7 +10228,7 @@ mod tests { assert_eq!(resolved.info().path.as_str(), "room/alice"); // A repeat request shares the served broadcast instead of re-asking. - let again = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let again = consumer.request("room/alice", None).await.expect("resolves"); assert!(again.is_clone(&resolved)); } @@ -10304,8 +10239,8 @@ mod tests { let consumer = producer.consume(); let server = producer.requests_route("room", Route::default()).unwrap(); - let first = consumer.request_broadcast("room/alice", None); - let second = consumer.request_broadcast("room/alice", None); + let first = consumer.request("room/alice", None); + let second = consumer.request("room/alice", None); let request = queued(&server).await; // Only one request reaches the server. @@ -10326,7 +10261,7 @@ mod tests { let consumer = producer.consume(); let server = producer.requests_route("room", Route::default()).unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); drop(server); let err = pending.await.err().unwrap(); @@ -10334,7 +10269,7 @@ mod tests { // With the route gone, later requests are unroutable immediately. let err = consumer - .request_broadcast("room/alice", None) + .request("room/alice", None) .now_or_never() .expect("unroutable") .err() @@ -10344,7 +10279,7 @@ mod tests { #[moq_clock::test] #[cfg(feature = "async")] - async fn routed_broadcast_survives_serving_route_retraction() { + async fn follow_survives_serving_route_retraction() { let producer = origin(1).produce(); let consumer = producer.consume(); @@ -10354,7 +10289,8 @@ mod tests { let second_server = producer.requests_route("room", Route::default()).unwrap(); let incumbent_server = producer.requests_route("room", Route::default()).unwrap(); - let mut resolving = Box::pin(consumer.routed_broadcast("room/alice")); + let mut following = consumer.follow("room/alice", None).unwrap(); + let mut resolving = Box::pin(following.available()); assert!((&mut resolving).now_or_never().is_none()); // Each incumbent dies with the front's request in flight on it: the @@ -10385,7 +10321,7 @@ mod tests { // The requester's own bytes must not be served back to it. let excluded = producer.consume().excluding(origin(7)); let err = excluded - .request_broadcast("room/alice", None) + .request("room/alice", None) .now_or_never() .expect("unroutable") .err() @@ -10394,7 +10330,7 @@ mod tests { // A clean requester resolves through the route (the request queues). let clean = producer.consume().excluding(origin(8)); - let pending = clean.request_broadcast("room/alice", None); + let pending = clean.request("room/alice", None); assert!(pending.now_or_never().is_none()); } @@ -10778,7 +10714,7 @@ mod tests { let err = producer .consume() .local() - .request_broadcast("remote/alice", None) + .request("remote/alice", None) .now_or_never() .expect("unroutable") .err() @@ -10787,7 +10723,7 @@ mod tests { assert!( producer .consume() - .request_broadcast("remote/alice", None) + .request("remote/alice", None) .now_or_never() .is_none() ); @@ -10843,19 +10779,13 @@ mod tests { // toward an upstream, while the full view queues it on the core's route. let err = core .consume() - .request_broadcast("core/alice", None) + .request("core/alice", None) .now_or_never() .expect("unroutable") .err() .unwrap(); assert!(matches!(err, Error::Unroutable)); - assert!( - producer - .consume() - .request_broadcast("core/alice", None) - .now_or_never() - .is_none() - ); + assert!(producer.consume().request("core/alice", None).now_or_never().is_none()); } /// A handler that rejects a path with `Unroutable` while its route stands @@ -10868,7 +10798,7 @@ mod tests { let consumer = producer.consume(); let server = producer.requests_route("room", Route::default()).unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&server).await; request.reject(Error::Unroutable); let err = moq_clock::timeout(Duration::from_secs(5), pending) @@ -10879,7 +10809,7 @@ mod tests { assert!(matches!(err, Error::Unroutable)); // The route still stands and serves the next path. - let pending = consumer.request_broadcast("room/bob", None); + let pending = consumer.request("room/bob", None); let request = queued(&server).await; assert_eq!(request.path().as_str(), "room/bob"); let served = broadcast::Info::new().produce(); @@ -10894,7 +10824,7 @@ mod tests { let consumer = producer.consume(); let claim = producer.requests("room").unwrap(); let epoch = crate::Epoch::mint(); - let mut pending = Box::pin(consumer.request_broadcast("room/alice", None)); + let mut pending = Box::pin(consumer.request("room/alice", None)); assert!((&mut pending).now_or_never().is_none()); let prepared = queued(&claim).await.prepare(epoch.clone()).unwrap(); @@ -10918,7 +10848,7 @@ mod tests { let mut announced = producer.consume().announced(); let claim = producer.requests("room").unwrap(); announced.assert_next_active("room"); - let pending = producer.consume().request_broadcast("room/alice", None); + let pending = producer.consume().request("room/alice", None); let epoch = crate::Epoch::mint(); let prepared = queued(&claim).await.prepare(epoch.clone()).unwrap(); let answer = prepared.broadcast().clone(); @@ -10953,7 +10883,7 @@ mod tests { drop(control); drop(publication); events.assert_next_wait(); - consumer.request_broadcast("room/alice", None).await.unwrap(); + consumer.request("room/alice", None).await.unwrap(); drop(fill); events.expect_next_ended("room/alice").await; } @@ -10974,10 +10904,7 @@ mod tests { old.unannounce(); old.close(); assert_eq!(replacement.route().unwrap().epoch, Some(replacement_epoch.clone())); - let resolved = consumer - .request_broadcast("room/alice", replacement_epoch.clone()) - .await - .unwrap(); + let resolved = consumer.request("room/alice", replacement_epoch.clone()).await.unwrap(); assert_eq!(resolved.info().epoch.as_ref(), Some(&replacement_epoch)); } @@ -10987,7 +10914,7 @@ mod tests { async fn a_refused_prepared_answer_cannot_announce_later() { let producer = origin(1).produce(); let claim = producer.requests("room").unwrap(); - let _pending = producer.consume().request_broadcast("room/alice", None); + let _pending = producer.consume().request("room/alice", None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); let answer = prepared.broadcast().clone(); @@ -11002,7 +10929,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let claim = producer.requests("room").unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); drop(prepared); assert!(matches!(pending.await, Err(Error::Unroutable))); @@ -11016,7 +10943,7 @@ mod tests { let mut announced = producer.consume().announced(); let claim = producer.requests("room").unwrap(); announced.assert_next_active("room"); - let _pending = producer.consume().request_broadcast("room/alice", None); + let _pending = producer.consume().request("room/alice", None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); drop(claim); @@ -11033,7 +10960,7 @@ mod tests { let mut announced = producer.consume().announced(); let claim = producer.requests("room").unwrap(); announced.assert_next_active("room"); - let _pending = producer.consume().request_broadcast("room/alice", None); + let _pending = producer.consume().request("room/alice", None); let prepared = queued(&claim).await.prepare(crate::Epoch::mint()).unwrap(); claim @@ -11053,16 +10980,16 @@ mod tests { let consumer = producer.consume(); let claim = producer.requests("room").unwrap(); let epoch = crate::Epoch::mint(); - let unknown = consumer.request_broadcast("room/alice", crate::Epoch::mint()); + let unknown = consumer.request("room/alice", crate::Epoch::mint()); assert!(matches!(unknown.await, Err(Error::Unroutable))); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let _published = queued(&claim).await.prepare(epoch.clone()).unwrap().publish().unwrap(); pending.await.expect("resolves"); - let pinned = consumer.request_broadcast("room/alice", epoch.clone()).await; + let pinned = consumer.request("room/alice", epoch.clone()).await; assert_eq!(pinned.expect("resolves").info().epoch.as_ref(), Some(&epoch)); - let stale = consumer.request_broadcast("room/alice", crate::Epoch::mint()); + let stale = consumer.request("room/alice", crate::Epoch::mint()); assert!(matches!(stale.await, Err(Error::Unroutable))); } @@ -11077,7 +11004,7 @@ mod tests { let winner = producer.requests_route("room", Route::default()).unwrap(); let sibling = producer.requests_route("room", Route::default().with_cost(2)).unwrap(); - let mut pending = Box::pin(consumer.request_broadcast("room/alice", None)); + let mut pending = Box::pin(consumer.request("room/alice", None)); assert!((&mut pending).now_or_never().is_none()); queued(&winner).await.reject(Error::NotFound); let mut result = None; @@ -11103,7 +11030,7 @@ mod tests { let consumer = producer.consume(); let stale = producer.requests_route("room", Route::default()).unwrap(); - let mut pending = Box::pin(consumer.request_broadcast("room/alice", None)); + let mut pending = Box::pin(consumer.request("room/alice", None)); assert!((&mut pending).now_or_never().is_none()); let request = queued(&stale).await; @@ -11130,7 +11057,7 @@ mod tests { let consumer = producer.consume(); let stale = producer.requests_route("room", Route::default()).unwrap(); - let mut pending = Box::pin(consumer.request_broadcast("room/alice", None)); + let mut pending = Box::pin(consumer.request("room/alice", None)); assert!((&mut pending).now_or_never().is_none()); let request = queued(&stale).await; @@ -11148,46 +11075,17 @@ mod tests { assert!(result.unwrap().is_ok(), "the beaten route's refusal ended the request"); } - /// `routed_broadcast` treats a handler's rejection as the table's verdict: - /// it waits for the table to move instead of re-asking the same route. - #[moq_clock::test] - #[cfg(feature = "async")] - async fn routed_broadcast_waits_out_a_rejection() { - let producer = origin(1).produce(); - let consumer = producer.consume(); - let server = producer.requests_route("room", Route::default()).unwrap(); - - let mut resolving = Box::pin(consumer.routed_broadcast("room/alice")); - assert!((&mut resolving).now_or_never().is_none()); - let request = queued(&server).await; - request.reject(Error::Unroutable); - - // Parked: the route stands, so nothing changed that a retry could use. - for _ in 0..20 { - moq_clock::sim::yield_now().await; - } - assert!((&mut resolving).now_or_never().is_none()); - assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); - - // A re-price moves the table: the retry reaches the handler, which serves it. - server.update_route(Route::default().with_cost(2)).unwrap(); - assert!((&mut resolving).now_or_never().is_none()); - let request = queued(&server).await; - let served = broadcast::Info::new().produce(); - request.accept(&served); - resolving.await.expect("resolves"); - } - /// Teardown rejects the parked request with the origin's own terminal cause. #[moq_clock::test] #[cfg(feature = "async")] - async fn routed_broadcast_reports_teardown_as_closed() { + async fn follow_reports_teardown_as_closed() { let (producer, driver) = Producer::new(Config::new(origin(1))); let consumer = producer.consume(); let _server = producer.requests_route("room", Route::default()).unwrap(); // Park on the covering route, past the loop's closed check. - let mut resolving = Box::pin(consumer.routed_broadcast("room/alice")); + let mut following = consumer.follow("room/alice", None).unwrap(); + let mut resolving = Box::pin(following.available()); assert!((&mut resolving).now_or_never().is_none()); drop(driver); @@ -11200,30 +11098,6 @@ mod tests { assert!(matches!(err, Error::Closed), "unexpected end: {err}"); } - /// A local broadcast announcing at the exact path is a table change too: a - /// requester parked on a handler's rejection resolves to it. - #[moq_clock::test] - #[cfg(feature = "async")] - async fn routed_broadcast_wakes_for_a_local_broadcast() { - let producer = origin(1).produce(); - let consumer = producer.consume(); - let server = producer.requests_route("room", Route::default()).unwrap(); - - let mut resolving = Box::pin(consumer.routed_broadcast("room/alice")); - assert!((&mut resolving).now_or_never().is_none()); - queued(&server).await.reject(Error::Unroutable); - for _ in 0..20 { - moq_clock::sim::yield_now().await; - } - assert!((&mut resolving).now_or_never().is_none()); - - // The more specific route wins outright over the handler's prefix. - let _local = producer.publish("room/alice", Route::default()).unwrap(); - let resolved = resolving.await.expect("resolves locally"); - assert_eq!(resolved.info().path.as_str(), "room/alice"); - assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); - } - /// A track first subscribed after the front is already serving another still /// replays what its source holds, like the first track did. #[moq_clock::test] @@ -11243,7 +11117,7 @@ mod tests { std::mem::forget(track); } - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); queued(&server).await.accept(&source); let resolved = pending.await.expect("resolves"); @@ -11277,7 +11151,7 @@ mod tests { let _narrow = producer.announce(".dash", Route::default()).unwrap(); let err = consumer - .request_broadcast(".dash/pid", None) + .request(".dash/pid", None) .now_or_never() .expect("unroutable") .err() @@ -11285,7 +11159,7 @@ mod tests { assert!(matches!(err, Error::Unroutable)); // Everything else still routes to the broad server. - let _pending = consumer.request_broadcast("room/alice", None); + let _pending = consumer.request("room/alice", None); let request = queued(&broad_server).await; assert_eq!(request.path().as_str(), "room/alice"); } @@ -11300,7 +11174,7 @@ mod tests { // The root claim is advertised like any other prefix. announced.expect_next_active("").await; - let pending = consumer.request_broadcast("anything/at/all", None); + let pending = consumer.request("anything/at/all", None); let request = queued(&dynamic).await; assert_eq!(request.path().as_str(), "anything/at/all"); @@ -11313,7 +11187,7 @@ mod tests { drop(dynamic); announced.expect_next_ended("").await; let err = consumer - .request_broadcast("something/else", None) + .request("something/else", None) .now_or_never() .expect("unroutable") .err() @@ -11337,7 +11211,7 @@ mod tests { // also pins that the check is segment-aware rather than textual. for path in ["tenant-b/live", "tenant-a-other/live"] { let refused = scoped - .request_broadcast(path, None) + .request(path, None) .now_or_never() .expect("an out-of-scope request must be refused synchronously, not queued"); assert!(matches!(refused, Err(Error::Unauthorized))); @@ -11348,46 +11222,54 @@ mod tests { } } + /// The route a follower's first event starts on. + #[cfg(feature = "async")] + fn started(event: Option) -> Route { + match event.expect("routed") { + AnnounceEvent::Start(announce) => announce.route, + other => panic!("should start: got {other:?}"), + } + } + #[moq_clock::test] #[cfg(feature = "async")] - async fn routed_waits_for_coverage() { + async fn routes_wait_for_coverage() { let producer = origin(1).produce(); let consumer = producer.consume(); - let mut fut = consumer.routed("room/alice").boxed(); + let mut routes = consumer.routes("room/alice").unwrap(); + let mut fut = routes.next().boxed(); assert!((&mut fut).now_or_never().is_none()); // A covering prefix resolves the wait. let _a = producer.announce("room", Route::default().with_cost(3)).unwrap(); - let route = fut.now_or_never().expect("covered").expect("routed"); + let route = started(fut.now_or_never().expect("covered")); assert_eq!(route.cost, Cost::new(3)); // Already covered: resolves immediately. - consumer - .routed("room/alice/cam") - .now_or_never() - .expect("covered") - .expect("routed"); + let mut routes = consumer.routes("room/alice/cam").unwrap(); + started(routes.next().now_or_never().expect("covered")); } #[moq_clock::test] #[cfg(feature = "async")] - async fn routed_ignores_deeper_routes() { + async fn routes_ignore_deeper_routes() { let producer = origin(1).produce(); let consumer = producer.consume(); // A deeper route does not cover the shorter path. let _deep = producer.announce("room/alice/cam", Route::default()).unwrap(); - let mut fut = consumer.routed("room/alice").boxed(); + let mut routes = consumer.routes("room/alice").unwrap(); + let mut fut = routes.next().boxed(); assert!((&mut fut).now_or_never().is_none()); let _exact = producer.announce("room/alice", Route::default()).unwrap(); - fut.now_or_never().expect("covered").expect("routed"); + started(fut.now_or_never().expect("covered")); } #[moq_clock::test] #[cfg(feature = "async")] - async fn routed_accepts_a_max_depth_path() { + async fn routes_accept_a_max_depth_path() { let producer = origin(1).produce(); let consumer = producer.consume(); let path = (0..Path::MAX_PARTS) @@ -11398,12 +11280,13 @@ mod tests { assert!(consumer.allowed().matches(&path)); - let mut fut = consumer.routed(&path).boxed(); + let mut routes = consumer.routes(&path).unwrap(); + let mut fut = routes.next().boxed(); assert!((&mut fut).now_or_never().is_none()); // A covering root still resolves: the lookup must not require `path/**`. let _a = producer.announce("", Route::default()).unwrap(); - fut.now_or_never().expect("covered").expect("routed"); + started(fut.now_or_never().expect("covered")); } #[moq_clock::test] @@ -11416,7 +11299,7 @@ mod tests { announced.expect_next_active("room").await; let _server = producer.requests_route("served", Route::default()).unwrap(); - let pending = consumer.request_broadcast("served/path", None); + let pending = consumer.request("served/path", None); drop(driver); @@ -11429,7 +11312,7 @@ mod tests { assert!(matches!(producer.announce("x", Route::default()), Err(Error::Closed))); assert!(matches!(producer.create_broadcast("x"), Err(Error::Closed))); let err = consumer - .request_broadcast("y", None) + .request("y", None) .now_or_never() .expect("closed") .err() @@ -11461,7 +11344,7 @@ mod tests { fn internal_route_requests_are_closed_on_teardown() { let (producer, mut driver) = Producer::new(Config::new(origin(1))); let server = producer.requests_route("room", Route::default()).unwrap(); - let _pending = producer.consume().request_broadcast("room/alice", None); + let _pending = producer.consume().request("room/alice", None); driver.poll(Instant::now(), &kio::Waiter::noop()).unwrap(); let Poll::Ready(Ok(request)) = server.poll_requested_broadcast(&kio::Waiter::noop()) else { panic!("front requested its route"); @@ -11490,7 +11373,7 @@ mod tests { for teardown in [false, true] { let (producer, mut driver) = Producer::new(Config::new(origin(1))); let server = producer.requests_route("room", Route::default()).unwrap(); - let _pending = producer.consume().request_broadcast("room/alice", None); + let _pending = producer.consume().request("room/alice", None); driver.poll(Instant::ZERO, &kio::Waiter::noop()).unwrap(); let channel = server .state @@ -11547,7 +11430,7 @@ mod tests { .requests_route("room", Route::default().with_epoch(epoch()).with_hops(hops(first))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&server).await; let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); @@ -11643,7 +11526,7 @@ mod tests { let first = producer .requests_route("room", Route::default().with_hops(hops(&[10])).with_cost(5)) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); queued(&first).await.accept(&source); @@ -11684,7 +11567,7 @@ mod tests { ) .unwrap(); let old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); deliver(&old_track, &mut subscription, b"old").await; @@ -11697,7 +11580,7 @@ mod tests { let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); deliver(&old_track, &mut subscription, b"sticky").await; - let replaced = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let replaced = consumer.request("room/alice", None).await.expect("resolves"); assert!(!replaced.is_clone(&resolved)); let mut fresh = replaced.track("video").unwrap().subscribe(None).await.unwrap(); deliver(&new_track, &mut fresh, b"new").await; @@ -11726,7 +11609,7 @@ mod tests { .publish("room/alice", Route::default().with_epoch(first.clone())) .unwrap(); let _old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); assert_eq!( resolved.info().epoch.as_ref(), Some(&first), @@ -11738,8 +11621,8 @@ mod tests { .publish("room/alice", Route::default().with_epoch(epoch.clone())) .unwrap(); let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); - let named = consumer.request_broadcast("room/alice", epoch.clone()); - let bare = consumer.request_broadcast("room/alice", None); + let named = consumer.request("room/alice", epoch.clone()); + let bare = consumer.request("room/alice", None); let named = named.await.expect("the new epoch resolves"); let bare = bare.await.expect("the new epoch resolves"); @@ -11768,7 +11651,7 @@ mod tests { let old = producer .requests_route("room", Route::default().with_epoch(crate::Epoch::mint())) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&old).await; // The answer and the newer epoch land in the same tick. @@ -11798,8 +11681,8 @@ mod tests { let dynamic = producer .requests_route("room", Route::default().with_epoch(old.clone())) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); - let pinned = consumer.request_broadcast("room/alice", old); + let pending = consumer.request("room/alice", None); + let pinned = consumer.request("room/alice", old); let request = queued(&dynamic).await; let stale = broadcast::Info::new().produce(); @@ -11854,7 +11737,7 @@ mod tests { let dynamic = producer .requests_route("room", Route::default().with_epoch(crate::Epoch::mint())) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); queued(&dynamic).await.reject(Error::NotFound); let epoch = crate::Epoch::mint(); dynamic.update_route(dynamic.route().with_epoch(epoch.clone())).unwrap(); @@ -11879,7 +11762,7 @@ mod tests { let dynamic = producer .requests_route("room", Route::default().with_epoch(old.clone())) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&dynamic).await; dynamic @@ -11908,7 +11791,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let dynamic = producer.requests_route("room", Route::default()).unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let old = broadcast::Info::new().produce(); let _old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); queued(&dynamic).await.accept(&old); @@ -11921,7 +11804,7 @@ mod tests { route.epoch = None; dynamic.update_route(route).unwrap(); - let retry = consumer.request_broadcast("room/alice", None); + let retry = consumer.request("room/alice", None); let fresh = broadcast::Info::new().produce(); let _fresh_track = fresh.create_track("video", crate::track::Info::timed()).unwrap(); queued(&dynamic).await.accept(&fresh); @@ -11977,10 +11860,10 @@ mod tests { .unwrap(); let other: crate::Epoch = "01900000-0000-7000-8000-000000000002".parse().unwrap(); - let refused = consumer.request_broadcast("room/alice", other).await; + let refused = consumer.request("room/alice", other).await; assert!(matches!(refused, Err(Error::Unroutable))); let named = consumer - .request_broadcast("room/alice", epoch()) + .request("room/alice", epoch()) .await .expect("the named epoch resolves"); assert_eq!(named.info().epoch.as_ref(), Some(&epoch())); @@ -11992,11 +11875,7 @@ mod tests { async fn a_route_without_an_epoch_resolves_without_one() { let producer = origin(1).produce(); let _broadcast = producer.publish("room/alice", Route::default()).unwrap(); - let resolved = producer - .consume() - .request_broadcast("room/alice", None) - .await - .expect("resolves"); + let resolved = producer.consume().request("room/alice", None).await.expect("resolves"); assert_eq!(resolved.info().epoch, None); } @@ -12127,12 +12006,7 @@ mod tests { let frame = group.read_frame().await.expect("read frame").expect("frame"); assert_eq!(&frame.payload[..], b"after", "first hop {first:?}"); - let resolved = rig - .producer - .consume() - .request_broadcast("room/alice", None) - .await - .unwrap(); + let resolved = rig.producer.consume().request("room/alice", None).await.unwrap(); assert!(resolved.is_clone(&rig.resolved), "first hop {first:?} left the front"); assert!( standby.poll_requested_broadcast(&kio::Waiter::noop()).is_pending(), @@ -12161,7 +12035,7 @@ mod tests { .requests_route("room", Route::default().with_epoch(epoch()).with_hops(hops(&[10, 7]))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&incumbent).await; let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); @@ -12227,7 +12101,7 @@ mod tests { // Session C: a third anonymous session, excluding the hop the server // minted for it, the same split-horizon a live session applies. let consumer = producer.consume().excluding(origin(30)); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&server_a).await; let source_a = broadcast::Info::new().produce(); let track_a = source_a.create_track("video", crate::track::Info::timed()).unwrap(); @@ -12269,7 +12143,7 @@ mod tests { settle(|| consumer.get_broadcast("room/alice").is_none()).await; settle(|| { matches!( - consumer.request_broadcast("room/alice", None).now_or_never(), + consumer.request("room/alice", None).now_or_never(), Some(Err(Error::Unroutable)) ) }) @@ -12279,7 +12153,7 @@ mod tests { let server_b = producer .requests_route("room", Route::default().with_hops(hops(&[20]))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&server_b).await; let source_b = broadcast::Info::new().produce(); let track_b = source_b.create_track("video", crate::track::Info::timed()).unwrap(); @@ -12377,10 +12251,10 @@ mod tests { let consumer = producer.consume(); let first = producer.publish("room/alice", Route::default()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let second = producer.publish("room/alice", Route::default()).unwrap(); - let again = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let again = consumer.request("room/alice", None).await.expect("resolves"); assert!(!again.is_clone(&resolved)); // Losing one source leaves the path served; losing both frees it. @@ -12407,12 +12281,12 @@ mod tests { .unwrap(); // The front selected the covering route and waits on its answer. - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let _request = queued(&server).await; // The exact path beats the covering route before the front resolves. let _winner = producer.publish("room/alice", Route::default()).unwrap(); - let again = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let again = consumer.request("room/alice", None).await.expect("resolves"); let first = pending.await.expect("the first front moves to the winner"); assert!(!again.is_clone(&first), "joined a front resolving the beaten route"); } @@ -12427,7 +12301,7 @@ mod tests { let covering = producer .requests_route("room", Route::default().with_hops(hops(&[10]))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let _beaten = queued(&covering).await; // The exact path wins, and the front asks it in turn. @@ -12435,7 +12309,7 @@ mod tests { .requests_route("room/alice", Route::default().with_hops(hops(&[10]))) .unwrap(); let request = queued(&exact).await; - let again = consumer.request_broadcast("room/alice", None); + let again = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); request.accept(&upstream); @@ -12463,7 +12337,7 @@ mod tests { let broadcast = producer.publish("room/alice", Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved .track("video") .unwrap() @@ -12506,7 +12380,7 @@ mod tests { .requests_route("room", Route::default().with_hops(hops(&[10]))) .unwrap(); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&server).await; let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); @@ -12553,7 +12427,7 @@ mod tests { let server = producer .requests_route("room", Route::default().with_hops(hops(&[10]))) .unwrap(); - let pending = producer.consume().request_broadcast("room/alice", None); + let pending = producer.consume().request("room/alice", None); let source = broadcast::Info::new().produce(); queued(&server).await.accept(&source); let resolved = pending.await.unwrap(); @@ -12582,7 +12456,7 @@ mod tests { group.write_frame(crate::Timestamp::ZERO, b"cached".as_ref()).unwrap(); group.finish().unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved .track("video") .unwrap() @@ -12640,7 +12514,7 @@ mod tests { let server = producer .requests_route("live", Route::default().with_hops(hops(&[10]))) .unwrap(); - let pending = producer.consume().request_broadcast("live", None); + let pending = producer.consume().request("live", None); let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); queued(&server).await.accept(&source); @@ -12680,7 +12554,7 @@ mod tests { let producer = origin(1).produce(); let broadcast = producer.publish("live", Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = producer.consume().request_broadcast("live", None).await.unwrap(); + let resolved = producer.consume().request("live", None).await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut aborted = track.append_group().unwrap(); @@ -12720,16 +12594,13 @@ mod tests { group.finish().unwrap(); // The leaf's front view, which the next front serves from. - let leaf_front = leaf_consumer - .request_broadcast("room/alice", None) - .await - .expect("resolves"); + let leaf_front = leaf_consumer.request("room/alice", None).await.expect("resolves"); let mid = origin(2).produce(); let mid_server = mid .requests_route("room", Route::default().with_hops(hops(&[10]))) .unwrap(); - let mid_pending = mid.consume().request_broadcast("room/alice", None); + let mid_pending = mid.consume().request("room/alice", None); queued(&mid_server).await.accept(&leaf_front); let mid_resolved = mid_pending.await.expect("mid resolves"); @@ -12737,7 +12608,7 @@ mod tests { let edge_server = edge .requests_route("room", Route::default().with_hops(hops(&[20]))) .unwrap(); - let edge_pending = edge.consume().request_broadcast("room/alice", None); + let edge_pending = edge.consume().request("room/alice", None); queued(&edge_server).await.accept(&mid_resolved); let edge_resolved = edge_pending.await.expect("edge resolves"); @@ -12816,7 +12687,7 @@ mod tests { .publish("room/alice", Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved .track("video") .unwrap() @@ -12867,7 +12738,7 @@ mod tests { let server = producer .requests_route("room", Route::default().with_epoch(epoch()).with_hops(hops(&[10]))) .unwrap(); - let pending = producer.consume().request_broadcast("room/alice", None); + let pending = producer.consume().request("room/alice", None); let upstream = broadcast::Info::new().produce(); let old = upstream.create_track("video", crate::track::Info::timed()).unwrap(); queued(&server).await.accept(&upstream); @@ -12912,7 +12783,7 @@ mod tests { #[cfg(feature = "async")] async fn a_returning_reader_is_not_stranded_on_a_dropped_copy() { let (producer, _server, upstream, old, mut subscription) = remote_front().await; - let resolved = producer.consume().request_broadcast("room/alice", None).await.unwrap(); + let resolved = producer.consume().request("room/alice", None).await.unwrap(); // No handler and no track: refuses "video" with NotFound. let _second = producer @@ -12970,7 +12841,7 @@ mod tests { #[cfg(feature = "async")] async fn a_parked_track_serves_whole_groups_from_its_copy() { let (producer, _server, _upstream, old, subscription) = remote_front().await; - let resolved = producer.consume().request_broadcast("room/alice", None).await.unwrap(); + let resolved = producer.consume().request("room/alice", None).await.unwrap(); let mut open = old.append_group().unwrap(); open.write_frame(crate::Timestamp::ZERO, b"open".as_ref()).unwrap(); drop(subscription); @@ -13003,7 +12874,7 @@ mod tests { #[cfg(feature = "async")] async fn a_new_source_unparks_the_old_copy() { let (producer, _server, _upstream, old, subscription) = remote_front().await; - let resolved = producer.consume().request_broadcast("room/alice", None).await.unwrap(); + let resolved = producer.consume().request("room/alice", None).await.unwrap(); drop(subscription); moq_clock::timeout(Duration::from_secs(1), old.demand().until(|wanted| wanted.is_none())) .await @@ -13037,7 +12908,7 @@ mod tests { .publish("room/alice", Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); @@ -13074,7 +12945,7 @@ mod tests { .publish("room/alice", Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); @@ -13130,7 +13001,7 @@ mod tests { .publish("room/alice", Route::default().with_epoch(epoch())) .unwrap(); let track = first.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); @@ -13276,7 +13147,7 @@ mod tests { let server = producer.requests_route("room", Route::default()).unwrap(); drop(producer); - let pending = consumer.request_broadcast("room/alice", None); + let pending = consumer.request("room/alice", None); let request = queued(&server).await; let source = broadcast::Info::new().produce(); request.accept(&source); @@ -13302,7 +13173,7 @@ mod tests { let consumer = producer.consume(); let broadcast = producer.publish("room/alice", Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); broadcast.unannounce(); @@ -13327,7 +13198,7 @@ mod tests { let consumer = producer.consume(); let broadcast = producer.publish("room/alice", Route::default()).unwrap(); let mut track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let pending = resolved.track("video").unwrap().subscribe(None); @@ -13355,7 +13226,7 @@ mod tests { let consumer = producer.consume(); let broadcast = producer.publish("room/alice", Route::default()).unwrap(); let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - let resolved = consumer.request_broadcast("room/alice", None).await.expect("resolves"); + let resolved = consumer.request("room/alice", None).await.expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); moq_clock::timeout(Duration::from_secs(1), track.demand().until(|wanted| wanted.is_some())) .await @@ -13512,7 +13383,7 @@ mod tests { // dropped on the spot, taking its `Watch` with it: the request must not // still be holding the table lock the watch unregisters under. drop(producer); - let _pending = consumer.request_broadcast("room/a", None); + let _pending = consumer.request("room/a", None); } #[moq_clock::test] diff --git a/rs/moq-net/tests/integration/announce_to_serve.rs b/rs/moq-net/tests/integration/announce_to_serve.rs index ef48d02197f..030d4e61e32 100644 --- a/rs/moq-net/tests/integration/announce_to_serve.rs +++ b/rs/moq-net/tests/integration/announce_to_serve.rs @@ -61,7 +61,7 @@ fn drain(announced: &mut moq_net::announce::Consumer) -> Vec { /// How a request for the path answers. async fn request(consumer: &origin::Consumer) -> Result { - consumer.request_broadcast(PATH, None).await.map_err(|err| match err { + consumer.request(PATH, None).await.map_err(|err| match err { Error::Unroutable => "unroutable".to_string(), err => err.to_string(), }) diff --git a/rs/moq-net/tests/integration/auth.rs b/rs/moq-net/tests/integration/auth.rs index e18d797106d..9be6e1137a8 100644 --- a/rs/moq-net/tests/integration/auth.rs +++ b/rs/moq-net/tests/integration/auth.rs @@ -840,7 +840,7 @@ async fn a_revoked_grant_withdraws_and_can_be_restored(version: &'static str) { wait_for(pair.client.auth().grant(), |g| g == &Some(Grant::default())).await; wait_announced(&served, "a/x", false).await; // Still published locally, and the session survives the empty union. - assert!(publisher.consume().routed("a/x").await.is_some()); + crate::support::announced(&publisher.consume(), "a/x").await; assert_eq!(pair.client_transport.close_reason(), None); let (_again, _) = pair.client.auth().add("again").await.expect("re-authorized"); @@ -1097,7 +1097,13 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { group .write_frame(moq_net::Timestamp::from_millis(0).unwrap(), b"frame".as_ref()) .unwrap(); - let remote = received.consume().routed_broadcast("ch1").await.unwrap(); + let remote = received + .consume() + .follow("ch1", None) + .unwrap() + .available() + .await + .unwrap(); let prefs = moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(10)); let mut sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); sub.recv_group().await.unwrap().expect("a group"); @@ -1152,7 +1158,13 @@ async fn a_live_subscription_survives_union_renewal(version: &'static str) { requests.next().await.unwrap().accept(grant(&[], &["room"])) }); let first = first.unwrap(); - let remote = received.consume().routed_broadcast("room/x").await.unwrap(); + let remote = received + .consume() + .follow("room/x", None) + .unwrap() + .available() + .await + .unwrap(); let mut group = published.append_group().unwrap(); group .write_frame(moq_net::Timestamp::from_millis(0).unwrap(), b"first".as_ref()) @@ -1223,11 +1235,23 @@ async fn a_revoked_grant_cancels_its_subscriptions(version: &'static str) { let mut group = up_track.append_group().unwrap(); group.write_frame(ts(0), b"up".as_ref()).unwrap(); - let remote = received.consume().routed_broadcast("room/x").await.unwrap(); + let remote = received + .consume() + .follow("room/x", None) + .unwrap() + .available() + .await + .unwrap(); let mut down_sub = remote.track("video").unwrap().subscribe(prefs()).await.unwrap(); down_sub.recv_group().await.unwrap().unwrap(); - let remote = server_origin.consume().routed_broadcast("up/y").await.unwrap(); + let remote = server_origin + .consume() + .follow("up/y", None) + .unwrap() + .available() + .await + .unwrap(); let mut up_sub = remote.track("video").unwrap().subscribe(prefs()).await.unwrap(); up_sub.recv_group().await.unwrap().unwrap(); @@ -1600,10 +1624,22 @@ async fn a_narrowing_deafens_one_path(version: &'static str) { let mut group = video_track.append_group().unwrap(); group.write_frame(ts(0), b"v".as_ref()).unwrap(); - let remote = received.consume().routed_broadcast("room/alice/audio").await.unwrap(); + let remote = received + .consume() + .follow("room/alice/audio", None) + .unwrap() + .available() + .await + .unwrap(); let mut audio_sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); audio_sub.recv_group().await.unwrap().unwrap(); - let remote = received.consume().routed_broadcast("room/alice/video").await.unwrap(); + let remote = received + .consume() + .follow("room/alice/video", None) + .unwrap() + .available() + .await + .unwrap(); let mut video_sub = remote.track("h264").unwrap().subscribe(prefs()).await.unwrap(); video_sub.recv_group().await.unwrap().unwrap(); @@ -1673,10 +1709,22 @@ async fn a_narrowing_aborts_what_the_peer_published(version: &'static str) { let mut group = cam_track.append_group().unwrap(); group.write_frame(ts(0), b"c".as_ref()).unwrap(); - let remote = relay.consume().routed_broadcast("room/bob/mic").await.unwrap(); + let remote = relay + .consume() + .follow("room/bob/mic", None) + .unwrap() + .available() + .await + .unwrap(); let mut mic_sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); mic_sub.recv_group().await.unwrap().unwrap(); - let remote = relay.consume().routed_broadcast("room/bob/cam").await.unwrap(); + let remote = relay + .consume() + .follow("room/bob/cam", None) + .unwrap() + .available() + .await + .unwrap(); let mut cam_sub = remote.track("h264").unwrap().subscribe(prefs()).await.unwrap(); cam_sub.recv_group().await.unwrap().unwrap(); @@ -1721,7 +1769,13 @@ async fn a_narrowing_resets_a_fetch_in_flight(version: &'static str) { }) .await; - let remote = received.consume().routed_broadcast("room/x").await.unwrap(); + let remote = received + .consume() + .follow("room/x", None) + .unwrap() + .available() + .await + .unwrap(); let mut fetched = remote.track("video").unwrap().fetch_group(0, None).await.unwrap(); let frame = fetched.read_frame().await.unwrap().expect("first frame"); assert_eq!(frame.payload.as_ref(), b"first"); @@ -1783,7 +1837,13 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { let mut group = audio_track.append_group().unwrap(); group.write_frame(ts(0), b"a".as_ref()).unwrap(); - let remote = received.consume().routed_broadcast("room/alice/audio").await.unwrap(); + let remote = received + .consume() + .follow("room/alice/audio", None) + .unwrap() + .available() + .await + .unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); sub.recv_group().await.unwrap().unwrap(); @@ -1795,7 +1855,13 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { pair.server.auth().authorize(&grant(&[], &["room"])); wait_announced(&received.consume(), "room/alice/audio", true).await; - let remote = received.consume().routed_broadcast("room/alice/audio").await.unwrap(); + let remote = received + .consume() + .follow("room/alice/audio", None) + .unwrap() + .available() + .await + .unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); let mut group = audio_track.append_group().unwrap(); group.write_frame(ts(1), b"a".as_ref()).unwrap(); @@ -1844,7 +1910,13 @@ async fn a_widening_brings_back_what_the_peer_published(version: &'static str) { pair.server.auth().authorize(&grant(&["room"], &[])); wait_announced(&relay.consume(), "room/bob/mic", true).await; - let remote = relay.consume().routed_broadcast("room/bob/mic").await.unwrap(); + let remote = relay + .consume() + .follow("room/bob/mic", None) + .unwrap() + .available() + .await + .unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); let mut group = mic_track.append_group().unwrap(); group.write_frame(ts(0), b"m".as_ref()).unwrap(); diff --git a/rs/moq-net/tests/integration/broadcast_close.rs b/rs/moq-net/tests/integration/broadcast_close.rs index eae57feab10..c8711b5c234 100644 --- a/rs/moq-net/tests/integration/broadcast_close.rs +++ b/rs/moq-net/tests/integration/broadcast_close.rs @@ -27,11 +27,7 @@ async fn close_then_lookup(publisher: moq_net::origin::Producer, reader: moq_net broadcast.announce(Default::default()).unwrap(); let consumer = reader.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let handle = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let handle = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -44,10 +40,7 @@ async fn close_then_lookup(publisher: moq_net::origin::Producer, reader: moq_net .expect("the handle never closed"); assert!(matches!(handle.track("video"), Err(Error::Unroutable))); assert!(matches!(handle.track("audio"), Err(Error::Unroutable))); - assert!(matches!( - consumer.request_broadcast("bcast", None).await, - Err(Error::Unroutable) - )); + assert!(matches!(consumer.request("bcast", None).await, Err(Error::Unroutable))); assert!(matches!(broadcast.announce(Default::default()), Err(Error::Closed))); } diff --git a/rs/moq-net/tests/integration/catalog_acquisition.rs b/rs/moq-net/tests/integration/catalog_acquisition.rs index 8111b27b9f9..78b3430fc64 100644 --- a/rs/moq-net/tests/integration/catalog_acquisition.rs +++ b/rs/moq-net/tests/integration/catalog_acquisition.rs @@ -33,8 +33,14 @@ async fn acquisition(version: &str, carries_epoch: bool) { .announce(origin::Route::default().with_epoch(moq_net::Epoch::mint())) .unwrap(); let _old = link(version, &publisher, &subscriber, 100).await; - let remote = subscriber.consume().routed_broadcast("live").await.unwrap(); - let mut announced = subscriber.consume().follow("live").unwrap(); + let remote = subscriber + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); + let mut announced = subscriber.consume().announced(); let old_cost = match announced.next().await { Some(moq_net::announce::Event::Start(announce)) => announce.route.cost, other => panic!("expected the first route, got {other:?}"), diff --git a/rs/moq-net/tests/integration/catalog_churn.rs b/rs/moq-net/tests/integration/catalog_churn.rs index 31c944f87c2..f7223fe1abd 100644 --- a/rs/moq-net/tests/integration/catalog_churn.rs +++ b/rs/moq-net/tests/integration/catalog_churn.rs @@ -265,7 +265,7 @@ impl Topology { /// A fresh request for the broadcast; `None` when refused, as with no route right now. async fn request(&self, step: usize) -> Result, Failure> { - let request = self.subscriber.consume().request_broadcast("live", None); + let request = self.subscriber.consume().request("live", None); match moq_clock::timeout(READ_TIMEOUT, request).await { Ok(result) => Ok(result.ok()), Err(_) => Err(stuck(format!("{step}: request hung"))), @@ -291,7 +291,7 @@ async fn execute(version: Version, ops: &[Op]) -> Result<(), Failure> { link(version, &publisher, &relay_b).await, ]; let a_to_r = link(version, &relay_a, &subscriber).await; - subscriber.consume().routed("live").await.unwrap(); + crate::support::announced(&subscriber.consume(), "live").await; let mut topology = Topology { version, publisher, diff --git a/rs/moq-net/tests/integration/catalog_handover.rs b/rs/moq-net/tests/integration/catalog_handover.rs index 39cfbc80ae4..ad833752fe9 100644 --- a/rs/moq-net/tests/integration/catalog_handover.rs +++ b/rs/moq-net/tests/integration/catalog_handover.rs @@ -114,7 +114,7 @@ impl Topology { let p_to_a = link(version, &publisher, &relay_a, None).await; let p_to_b = link(version, &publisher, &relay_b, None).await; let a_to_r = link(version, &relay_a, &subscriber, None).await; - subscriber.consume().routed("live").await.unwrap(); + crate::support::announced(&subscriber.consume(), "live").await; let mut topology = Self { version, @@ -167,7 +167,7 @@ impl Topology { /// A new reader on `R`: a fresh broadcast request and a floorless subscription. async fn reader(&self) -> Reader { - let remote = moq_clock::timeout(READ_TIMEOUT, self.subscriber.consume().request_broadcast("live", None)) + let remote = moq_clock::timeout(READ_TIMEOUT, self.subscriber.consume().request("live", None)) .await .expect("request hung") .expect("request refused"); @@ -391,12 +391,7 @@ async fn fetch_after_leave(version: &str, pause: Duration) { drop(reader); moq_clock::sleep(pause).await; - let remote = topology - .subscriber - .consume() - .request_broadcast("live", None) - .await - .unwrap(); + let remote = topology.subscriber.consume().request("live", None).await.unwrap(); let fetch = remote.track("catalog.json").unwrap().fetch_group(0, None); let mut group = moq_clock::timeout(READ_TIMEOUT, fetch) .await diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index a7d8acd47ee..8188e50d4d7 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -101,8 +101,7 @@ async fn relay(published: Published, hops: [&str; 2], subscription: moq_net::tra let downstream = connect_mock(options).await; let consumer = origin.consume(); - consumer.routed("bcast").await.unwrap(); - let remote = consumer.request_broadcast("bcast", None).await.unwrap(); + let remote = consumer.follow("bcast", None).unwrap().available().await.unwrap(); let subscriber = remote.track("data").unwrap().subscribe(subscription).await.unwrap(); support::harness::subscribed(&track).await; @@ -293,8 +292,7 @@ async fn datagrams_meter_the_bytes_on_the_wire() { let downstream = connect_mock(options).await; let consumer = origin.consume(); - consumer.routed("bcast").await.unwrap(); - let remote = consumer.request_broadcast("bcast", None).await.unwrap(); + let remote = consumer.follow("bcast", None).unwrap().available().await.unwrap(); let mut subscriber = remote.track("data").unwrap().subscribe(None).await.unwrap(); support::harness::subscribed(&track).await; @@ -392,8 +390,13 @@ async fn ietf_fetch_keeps_the_stored_form() { options.server_publish = Some(publisher.consume()); options.client_subscribe = Some(origin.clone()); let _pair = connect_mock(options).await; - origin.consume().routed("bcast").await.unwrap(); - let remote = origin.consume().request_broadcast("bcast", None).await.unwrap(); + let remote = origin + .consume() + .follow("bcast", None) + .unwrap() + .available() + .await + .unwrap(); let consumer = remote.track("data").unwrap(); assert!(consumer.info().await.unwrap().compress, "{version}"); let mut fetched = consumer.fetch_group(0, moq_net::group::Fetch::default()).await.unwrap(); diff --git a/rs/moq-net/tests/integration/control_stats.rs b/rs/moq-net/tests/integration/control_stats.rs index 4e83721804f..71f9e5ea177 100644 --- a/rs/moq-net/tests/integration/control_stats.rs +++ b/rs/moq-net/tests/integration/control_stats.rs @@ -37,8 +37,13 @@ async fn control_classes_cross_lite_and_ietf_sessions_without_counting_payload() ) .unwrap(); broadcast.announce(Default::default()).unwrap(); - subscriber.consume().routed("room").await.unwrap(); - let remote = subscriber.consume().request_broadcast("room", None).await.unwrap(); + let remote = subscriber + .consume() + .follow("room", None) + .unwrap() + .available() + .await + .unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); subscribed(&track).await; let mut group = track.append_group().unwrap(); diff --git a/rs/moq-net/tests/integration/datagram.rs b/rs/moq-net/tests/integration/datagram.rs index 08b7219addb..9f70d54e84e 100644 --- a/rs/moq-net/tests/integration/datagram.rs +++ b/rs/moq-net/tests/integration/datagram.rs @@ -55,8 +55,7 @@ async fn connect_datagram_track() -> Fixture { let pair = connect_mock(options).await; let consumer = consumer_origin.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let subscriber = remote.track("datagrams").unwrap().subscribe(None).await.unwrap(); // The subscriber is handed over once TRACK_INFO answers, before its SUBSCRIBE reaches // the publisher, and a datagram only goes to a subscription already there. @@ -145,8 +144,7 @@ async fn ietf_delivers_datagrams_on(version: &str) { let _pair = connect_mock(options).await; let consumer = consumer_origin.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let mut subscriber = remote.track("datagrams").unwrap().subscribe(None).await.unwrap(); // A group first, so the subscription's alias is bound before any datagram lands. @@ -249,8 +247,7 @@ async fn a_fetched_datagram_is_refused_per_version() { let sequence = producer.append_datagram(Timestamp::ZERO, &b"x"[..]).unwrap(); let consumer = nodes.last().unwrap().consume(); - consumer.routed("room").await.unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + let remote = consumer.follow("room", None).unwrap().available().await.unwrap(); let err = match remote.track("datagrams").unwrap().fetch_group(sequence, None).await { Ok(_) => panic!("{versions:?}: a datagram was fetched"), Err(err) => err, diff --git a/rs/moq-net/tests/integration/dial_split_horizon.rs b/rs/moq-net/tests/integration/dial_split_horizon.rs index 46498de80d0..c2a0ea9ae5e 100644 --- a/rs/moq-net/tests/integration/dial_split_horizon.rs +++ b/rs/moq-net/tests/integration/dial_split_horizon.rs @@ -193,7 +193,7 @@ async fn split_horizon(version: &str, [publisher_hop, subscriber_hop]: [Hop; 2]) // session it arrived on. let viewed = subscriber .consume() - .request_broadcast("room", None) + .request("room", None) .await .expect("subscriber resolves the namespace"); let subscription = moq_net::track::Subscription::default(); diff --git a/rs/moq-net/tests/integration/drained_claim.rs b/rs/moq-net/tests/integration/drained_claim.rs index 3e4f7de7f6e..ecb75e770ed 100644 --- a/rs/moq-net/tests/integration/drained_claim.rs +++ b/rs/moq-net/tests/integration/drained_claim.rs @@ -85,10 +85,10 @@ impl Worker { /// through a claim is reset once the answer's exact route arrives, the cold-start reset /// accepted until announce takeover lands, so the read retries once. async fn watch(relay: &origin::Producer) -> String { - let cold = relay.consume().request_broadcast("pool/p", None).await.unwrap(); + let cold = relay.consume().request("pool/p", None).await.unwrap(); drop(cold.track("video").unwrap().subscribe(None).await); settle().await; - let broadcast = relay.consume().request_broadcast("pool/p", None).await.unwrap(); + let broadcast = relay.consume().request("pool/p", None).await.unwrap(); let mut subscription = broadcast.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = subscription.recv_group().await.unwrap().expect("a group"); let frame = group.read_frame().await.unwrap().expect("a frame"); diff --git a/rs/moq-net/tests/integration/empty_group.rs b/rs/moq-net/tests/integration/empty_group.rs index 3b853a60a96..c83e5d46557 100644 --- a/rs/moq-net/tests/integration/empty_group.rs +++ b/rs/moq-net/tests/integration/empty_group.rs @@ -36,8 +36,7 @@ async fn an_empty_group_arrives_empty() { broadcast.announce(Default::default()).unwrap(); let consumer = subscriber.consume(); - consumer.routed("room").await.unwrap(); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("room", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/fetch_cancel.rs b/rs/moq-net/tests/integration/fetch_cancel.rs index 3aaff468c8d..a41d254d922 100644 --- a/rs/moq-net/tests/integration/fetch_cancel.rs +++ b/rs/moq-net/tests/integration/fetch_cancel.rs @@ -52,11 +52,7 @@ async fn abandoned_fetch_reaches_the_publisher(version: &str, relays: u64, stage broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = nodes[relays as usize] - .consume() - .request_broadcast("room", None) - .await - .unwrap(); + let consumer = nodes[relays as usize].consume().request("room", None).await.unwrap(); let track = consumer.track("video").unwrap(); let mut waiting = Box::pin(track.fetch_group(0, None)); @@ -179,7 +175,7 @@ async fn a_refetch_within_the_linger_stays_on_the_relay(version: &str) { broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = relay.consume().request_broadcast("room", None).await.unwrap(); + let consumer = relay.consume().request("room", None).await.unwrap(); let mut waiting = Box::pin(consumer.track("video").unwrap().fetch_group(0, None)); let request = match futures::future::select(std::pin::pin!(dynamic.requested_track()), &mut waiting).await { futures::future::Either::Left((request, _)) => request.expect("the track request reaches the publisher"), diff --git a/rs/moq-net/tests/integration/fetch_fanout.rs b/rs/moq-net/tests/integration/fetch_fanout.rs index 3b09be36bf8..ff257cadfcf 100644 --- a/rs/moq-net/tests/integration/fetch_fanout.rs +++ b/rs/moq-net/tests/integration/fetch_fanout.rs @@ -38,7 +38,13 @@ async fn sequential_viewers_share_the_relays_fetched_groups() { options.server_publish = Some(relay.consume()); options.client_subscribe = Some(viewer.clone()); let pair = connect_mock(options).await; - let remote = viewer.consume().routed_broadcast("room").await.unwrap(); + let remote = viewer + .consume() + .follow("room", None) + .unwrap() + .available() + .await + .unwrap(); viewers.push((viewer, pair, remote)); } for round in 0..3 { diff --git a/rs/moq-net/tests/integration/fetch_from_feed.rs b/rs/moq-net/tests/integration/fetch_from_feed.rs index 2431a93f096..c3a765b9ab8 100644 --- a/rs/moq-net/tests/integration/fetch_from_feed.rs +++ b/rs/moq-net/tests/integration/fetch_from_feed.rs @@ -46,11 +46,7 @@ async fn relay(version: &str) -> Relay { let pair = connect_mock(options).await; let consumer = client.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index 71e318198b3..837135889d2 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -30,11 +30,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Consumer { let consumer = origin.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves") diff --git a/rs/moq-net/tests/integration/finished_broadcast_mock.rs b/rs/moq-net/tests/integration/finished_broadcast_mock.rs index 7c8701f3e6d..a6116955999 100644 --- a/rs/moq-net/tests/integration/finished_broadcast_mock.rs +++ b/rs/moq-net/tests/integration/finished_broadcast_mock.rs @@ -50,11 +50,7 @@ async fn round(finish_broadcast: bool) -> (Vec>, Option) let pair: MockPair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/finite_relay.rs b/rs/moq-net/tests/integration/finite_relay.rs index 8d16ffad4f9..98e1eb77b7c 100644 --- a/rs/moq-net/tests/integration/finite_relay.rs +++ b/rs/moq-net/tests/integration/finite_relay.rs @@ -76,11 +76,7 @@ async fn round(name: &str, arrival: Arrival) -> (Vec, Result<(), moq_net::E let downstream = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/goaway.rs b/rs/moq-net/tests/integration/goaway.rs index 0c14c298d73..75936bcff60 100644 --- a/rs/moq-net/tests/integration/goaway.rs +++ b/rs/moq-net/tests/integration/goaway.rs @@ -390,8 +390,12 @@ async fn goaway_keeps_new_subscribes(version: Version) { // Subscribe BEFORE the GOAWAY and receive a first group. let sub = sub_origin.consume(); - sub.routed("test").await.expect("route announced"); - let bc = sub.request_broadcast("test", None).await.expect("broadcast resolves"); + let bc = sub + .follow("test", None) + .unwrap() + .available() + .await + .expect("broadcast resolves"); let mut existing = bc.track("video").unwrap().subscribe(None).await.expect("subscribe"); let mut group = track.append_group().expect("append group"); @@ -490,7 +494,7 @@ async fn goaway_drains_routes(version: Version) { let MockPair { client, server, .. } = connect_mock(opts).await; let sub = sub_origin.consume(); - let route = sub.routed("test").await.expect("route announced"); + let route = crate::support::announced(&sub, "test").await; assert_ne!( route.cost, moq_net::origin::Cost::DRAIN, diff --git a/rs/moq-net/tests/integration/group_order.rs b/rs/moq-net/tests/integration/group_order.rs index 9b11f292572..e5c1caf4399 100644 --- a/rs/moq-net/tests/integration/group_order.rs +++ b/rs/moq-net/tests/integration/group_order.rs @@ -47,12 +47,10 @@ async fn connect( fn read_arrivals(origin: moq_net::origin::Producer, order: Order) -> moq_clock::sim::JoinHandle> { moq_clock::sim::spawn(async move { let consumer = origin.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); let remote = consumer - .request_broadcast("bcast", None) + .follow("bcast", None) + .unwrap() + .available() .await .expect("broadcast resolves"); let subscription = Subscription::default() diff --git a/rs/moq-net/tests/integration/history_groups.rs b/rs/moq-net/tests/integration/history_groups.rs index fd813fb17c2..2ad2684e7ac 100644 --- a/rs/moq-net/tests/integration/history_groups.rs +++ b/rs/moq-net/tests/integration/history_groups.rs @@ -71,11 +71,7 @@ async fn round(version: &str, relay: bool, newest_first: bool) -> Vec<(u64, usiz let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -220,8 +216,7 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { 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", None).await.unwrap(); + let remote = consumer.follow("bcast", None).unwrap().available().await.unwrap(); let subscription = Subscription::default().with_max_delay(FOREVER).with_range(0..); let first_subscription = subscription.clone(); let first_reader = moq_clock::sim::spawn(async move { @@ -258,8 +253,7 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { 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", None).await.unwrap(); + let remote = consumer.follow("bcast", None).unwrap().available().await.unwrap(); let mut late_sub = remote.track("history").unwrap().subscribe(subscription).await.unwrap(); moq_clock::timeout(TIMEOUT, read_history(&mut late_sub)) .await diff --git a/rs/moq-net/tests/integration/idle_cancel_refetch.rs b/rs/moq-net/tests/integration/idle_cancel_refetch.rs index 0705c09f658..8538fdbc286 100644 --- a/rs/moq-net/tests/integration/idle_cancel_refetch.rs +++ b/rs/moq-net/tests/integration/idle_cancel_refetch.rs @@ -40,11 +40,7 @@ async fn a_group_cut_by_an_idle_cancel_is_refetched_whole() { let _pair = connect_mock(options).await; let consumer = client.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .unwrap() - .unwrap(); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .unwrap() .unwrap(); diff --git a/rs/moq-net/tests/integration/late_lower_group.rs b/rs/moq-net/tests/integration/late_lower_group.rs index db34d444489..8c5ea8aff13 100644 --- a/rs/moq-net/tests/integration/late_lower_group.rs +++ b/rs/moq-net/tests/integration/late_lower_group.rs @@ -114,11 +114,7 @@ async fn session(version: &str, relay: bool, start: Option) -> Vec<(u64, us let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -235,11 +231,7 @@ async fn merged(version: &str) -> (Vec<(u64, usize)>, Vec<(u64, usize)>) { let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/lazy_discovery.rs b/rs/moq-net/tests/integration/lazy_discovery.rs index d7b6bba54d9..c6038191309 100644 --- a/rs/moq-net/tests/integration/lazy_discovery.rs +++ b/rs/moq-net/tests/integration/lazy_discovery.rs @@ -263,7 +263,7 @@ async fn a_resolved_broadcast_keeps_its_route() { let lazy = Lazy::new(version).await; let mut watch = lazy.watch("a"); synced(&mut watch).await; - let broadcast = lazy.subscriber.consume().request_broadcast("a/x", None).await.unwrap(); + let broadcast = lazy.subscriber.consume().request("a/x", None).await.unwrap(); drop(watch); moq_clock::sleep(LINGERED).await; @@ -280,11 +280,11 @@ async fn waiting_on_a_path_asks_about_it() { for version in VERSIONS { let lazy = Lazy::new(version).await; let consumer = lazy.subscriber.consume(); - moq_clock::timeout(SETTLE, consumer.routed_broadcast("a/x")) + moq_clock::timeout(SETTLE, consumer.follow("a/x", None).unwrap().available()) .await .expect("routed in time") .unwrap(); - let mut followed = consumer.announced_broadcast("b/y", None).unwrap(); + let mut followed = consumer.follow("b/y", None).unwrap(); moq_clock::timeout(SETTLE, followed.available()) .await .expect("announced in time") @@ -308,7 +308,7 @@ async fn a_relay_link_asks_for_everything() { assert_eq!(lazy.requests(), 1, "{version}"); // Read through a plain handle: one taken from an upstream link hides its routes. for path in ["a/x", "b/y"] { - relay.consume().request_broadcast(path, None).await.unwrap(); + relay.consume().request(path, None).await.unwrap(); } } } @@ -327,7 +327,7 @@ async fn a_server_asks_for_everything() { options.server_subscribe = Some(relay.clone()); let _pair = connect_mock(options).await; moq_clock::sleep(SETTLE).await; - relay.consume().request_broadcast("a/x", None).await.unwrap(); + relay.consume().request("a/x", None).await.unwrap(); } } @@ -358,7 +358,7 @@ async fn serving_the_peer_asks_nothing() { .count(); assert_eq!(requests, 0, "{version}"); // An application request is a reader, unlike the peer's serving view. - let _read = local.consume().request_broadcast("a/x", None).await.unwrap(); + let _read = local.consume().request("a/x", None).await.unwrap(); let requests = pair .client_transport .bidi_types() @@ -378,7 +378,7 @@ async fn requesting_an_unwatched_path_discovers_its_instance() { let broadcast = lazy .subscriber .consume() - .request_broadcast("a/x", None) + .request("a/x", None) .await .expect("request discovers the announced instance without a separate watcher"); assert_eq!(broadcast.info().path.as_str(), "a/x"); @@ -391,12 +391,12 @@ async fn requesting_an_unwatched_path_discovers_its_instance() { async fn an_unwatched_missing_path_is_unroutable_after_sync() { for version in VERSIONS { let lazy = Lazy::new(version).await; - let result = moq_clock::timeout(SETTLE, lazy.subscriber.consume().request_broadcast("missing", None)) + let result = moq_clock::timeout(SETTLE, lazy.subscriber.consume().request("missing", None)) .await .expect("the peer synced"); assert!(matches!(result, Err(Error::Unroutable)), "{version}"); assert_eq!(lazy.requests(), 1, "{version}"); - let broadcast = lazy.subscriber.consume().request_broadcast("a/x", None).await.unwrap(); + let broadcast = lazy.subscriber.consume().request("a/x", None).await.unwrap(); moq_clock::sleep(LINGERED).await; assert!( lazy.routes("a/x").await, @@ -523,7 +523,7 @@ async fn ietf_waiting_on_a_path_asks_about_it() { for version in IETF { let lazy = Lazy::new(version).await; let consumer = lazy.subscriber.consume(); - moq_clock::timeout(SETTLE, consumer.routed_broadcast("a/x")) + moq_clock::timeout(SETTLE, consumer.follow("a/x", None).unwrap().available()) .await .expect("routed in time") .unwrap(); @@ -538,7 +538,7 @@ async fn ietf_a_relay_link_asks_for_everything() { let relay = produce_origin(2); let _lazy = Lazy::with(version, relay.clone().with_link(moq_net::origin::Link::Peer)).await; for path in ["a/x", "b/y"] { - relay.consume().request_broadcast(path, None).await.unwrap(); + relay.consume().request(path, None).await.unwrap(); } } } diff --git a/rs/moq-net/tests/integration/model.rs b/rs/moq-net/tests/integration/model.rs index f3e656685ed..c4b1050a23e 100644 --- a/rs/moq-net/tests/integration/model.rs +++ b/rs/moq-net/tests/integration/model.rs @@ -29,7 +29,7 @@ fn origin_front_serves_media_with_only_explicit_polls() { broadcast.announce(origin::Route::default()).unwrap(); // Resolving and subscribing pass through the origin's core front tasks. - let mut requesting = origin.consume().request_broadcast("room/live", None); + let mut requesting = origin.consume().request("room/live", None); assert!(requesting.poll_ok(&waiter).is_pending()); driver.poll(now, &waiter).unwrap(); let receiving: broadcast::Consumer = ready(requesting.poll_ok(&waiter)).unwrap(); @@ -48,30 +48,28 @@ fn origin_front_serves_media_with_only_explicit_polls() { } #[test] -fn routed_broadcast_resolves_with_only_explicit_polls() { - use kio::Task; - +fn follow_resolves_with_only_explicit_polls() { let now = moq_net::time::Instant::now(); let waiter = kio::Waiter::noop(); let (origin, mut driver) = origin::Producer::new(origin::Config::new(Hop::new(1).unwrap())); driver.poll(now, &waiter).unwrap(); - // Nothing covers the path yet: the first ask fails `Unroutable` and parks on the routes. - let mut routing = origin.consume().routed_broadcast("room/live"); - assert!(routing.poll(&waiter).is_pending()); + // Nothing covers the path yet: the follower waits for an announcement. + let mut following = origin.consume().follow("room/live", None).unwrap(); + assert!(following.poll_available(&waiter).is_pending()); let broadcast = origin.create_broadcast("room/live").unwrap(); - assert!(routing.poll(&waiter).is_pending()); + assert!(following.poll_available(&waiter).is_pending()); - // Announcing moves the routes, so the next poll asks again and the driver serves it. + // Announcing starts the path, so the next poll asks and the driver serves it. broadcast.announce(origin::Route::default()).unwrap(); - assert!(routing.poll(&waiter).is_pending()); + assert!(following.poll_available(&waiter).is_pending()); driver.poll(now, &waiter).unwrap(); - let resolved = ready(routing.poll(&waiter)).unwrap(); + let resolved = ready(following.poll_available(&waiter)).unwrap(); assert_eq!(resolved.info().path.as_str(), "room/live"); - // A closed origin ends a parked resolution. - let mut routing = origin.consume().routed_broadcast("room/other"); - assert!(routing.poll(&waiter).is_pending()); + // A closed origin ends a parked follower. + let mut following = origin.consume().follow("room/other", None).unwrap(); + assert!(following.poll_available(&waiter).is_pending()); drop(driver); - assert!(matches!(ready(routing.poll(&waiter)), Err(Error::Closed))); + assert!(matches!(ready(following.poll_available(&waiter)), Err(Error::Closed))); } diff --git a/rs/moq-net/tests/integration/multi_cdn.rs b/rs/moq-net/tests/integration/multi_cdn.rs index 4da239fbcbb..14f67296342 100644 --- a/rs/moq-net/tests/integration/multi_cdn.rs +++ b/rs/moq-net/tests/integration/multi_cdn.rs @@ -187,7 +187,7 @@ impl Topology { } async fn subscribe(&self) -> mpsc::UnboundedReceiver { - let remote = self.subscriber.consume().request_broadcast("live", None).await.unwrap(); + let remote = self.subscriber.consume().request("live", None).await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()) } diff --git a/rs/moq-net/tests/integration/partial_group.rs b/rs/moq-net/tests/integration/partial_group.rs index 90136b30881..585c2808897 100644 --- a/rs/moq-net/tests/integration/partial_group.rs +++ b/rs/moq-net/tests/integration/partial_group.rs @@ -40,11 +40,7 @@ async fn round(version: &str) -> Option, moq_net::Error>> { broadcast.announce(Default::default()).unwrap(); let consumer = downstream.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("room", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/quiet_catalog.rs b/rs/moq-net/tests/integration/quiet_catalog.rs index bdb367f0805..d87cf564cb4 100644 --- a/rs/moq-net/tests/integration/quiet_catalog.rs +++ b/rs/moq-net/tests/integration/quiet_catalog.rs @@ -59,8 +59,7 @@ fn publish(origin: &origin::Producer) -> (moq_net::origin::Publication, track::P async fn request(origin: &origin::Producer) -> broadcast::Consumer { let consumer = origin.consume(); - consumer.routed("live").await.unwrap(); - consumer.request_broadcast("live", None).await.unwrap() + consumer.follow("live", None).unwrap().available().await.unwrap() } /// Subscribe without a floor and expect the snapshot as group 0. diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index 71850dd535b..f4c0fd35a3a 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -61,18 +61,14 @@ async fn read(version: Option<&str>, range: Range) -> Result, Error> { let _pair; let remote = match version { // Through the origin, as a reader of a local route. - None => moq_clock::timeout(TIMEOUT, publisher.consume().request_broadcast("room", None)) + None => moq_clock::timeout(TIMEOUT, publisher.consume().request("room", None)) .await .expect("resolve timeout") .expect("broadcast resolves"), Some(version) => { _pair = peer(version.parse::().unwrap(), &publisher, &subscriber).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) - .await - .expect("announce timeout") - .expect("routed"); - moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + moq_clock::timeout(TIMEOUT, consumer.follow("room", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves") diff --git a/rs/moq-net/tests/integration/received_rewind.rs b/rs/moq-net/tests/integration/received_rewind.rs index 6b8bd7cda19..43989957b87 100644 --- a/rs/moq-net/tests/integration/received_rewind.rs +++ b/rs/moq-net/tests/integration/received_rewind.rs @@ -65,11 +65,7 @@ async fn relay( let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -171,11 +167,7 @@ async fn fetch_only(version: &str) -> Vec> { let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/rejoin.rs b/rs/moq-net/tests/integration/rejoin.rs index 3efe02589fa..52ad9633df6 100644 --- a/rs/moq-net/tests/integration/rejoin.rs +++ b/rs/moq-net/tests/integration/rejoin.rs @@ -55,8 +55,7 @@ async fn rejoin_recovers_the_group_reset_on_leave() { let _pair = connect_mock(options).await; let consumer = relay.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); let prefs = || track::Subscription::default().with_max_delay(Duration::from_secs(10)); @@ -148,8 +147,7 @@ async fn rejoin_skips_a_cache_kept_by_another_handle() { let _pair = connect_mock(options).await; let consumer = relay.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); // Held for fetches only: it keeps the relay's copy without subscribing. @@ -220,8 +218,7 @@ async fn rejoin_mid_group_keeps_the_head_for_later_readers() { let _downstream = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload, b"a0".as_ref()); @@ -233,7 +230,7 @@ async fn rejoin_mid_group_keeps_the_head_for_later_readers() { assert_eq!(rejoined.read_frame().await.unwrap().unwrap().payload, b"a0".as_ref()); crate::support::wanted(track.demand()).await.unwrap(); - let later = relay.consume().request_broadcast("bench", None).await.unwrap(); + let later = relay.consume().request("bench", None).await.unwrap(); let mut sub = later.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.sequence, 0, "{version}"); @@ -292,8 +289,7 @@ async fn rejoin_goes_live_without_the_join_head() { let _downstream = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload, b"a0".as_ref()); @@ -320,7 +316,7 @@ async fn rejoin_goes_live_without_the_join_head() { .unwrap(); next.finish().unwrap(); - let local = relay.consume().request_broadcast("bench", None).await.unwrap(); + let local = relay.consume().request("bench", None).await.unwrap(); let mut sub = local.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.sequence, 1, "{version}"); @@ -356,8 +352,7 @@ async fn rejoin_during_the_cancel_skips_the_cache() { let _pair = connect_mock(options).await; let consumer = relay.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); let mut group = track.append_group().unwrap(); @@ -419,8 +414,7 @@ async fn rejoin_waits_for_the_answers_first_frame() { let pair = connect_mock(options).await; let consumer = relay.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); // Held for fetches only: it keeps the relay's copy without subscribing. @@ -504,8 +498,7 @@ async fn leaving_after_the_cache_window_keeps_the_latest_group() { options.client_subscribe = Some(client.clone()); let pair = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); (remote, pair) } }; @@ -567,8 +560,7 @@ async fn rejoin_keeps_source_timestamps() { let _pair = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); // Far from any arrival time, so a frame stamped on arrival cannot pass. let ts = |ms| Timestamp::from_millis(ms).unwrap(); @@ -670,8 +662,7 @@ async fn quiet_catalog_survives_cache_expiry(version: Version, takeover: bool) { options.client_subscribe = Some(client.clone()); let pair = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let sub = remote.track("catalog").unwrap().subscribe(None).await.unwrap(); (sub, remote, pair) } @@ -683,7 +674,7 @@ async fn quiet_catalog_survives_cache_expiry(version: Version, takeover: bool) { let (mut holder, remote, pair) = session(3).await; assert_eq!(holder.recv_group().await.unwrap().unwrap().sequence, 0, "{version}"); // The new connection is cheaper, so the relay reports its route taking over. - let mut follow = relay.consume().follow("bench").unwrap(); + let mut follow = relay.consume().announced(); assert!( matches!(follow.next().await, Some(announce::Event::Start(_))), "{version}" diff --git a/rs/moq-net/tests/integration/relay_upstream_close.rs b/rs/moq-net/tests/integration/relay_upstream_close.rs index 4c9eb212682..8bbbbddfe58 100644 --- a/rs/moq-net/tests/integration/relay_upstream_close.rs +++ b/rs/moq-net/tests/integration/relay_upstream_close.rs @@ -111,11 +111,7 @@ async fn round(name: &str, end: End) -> Vec { let downstream = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/replacement.rs b/rs/moq-net/tests/integration/replacement.rs index 313542a6219..2e94c937366 100644 --- a/rs/moq-net/tests/integration/replacement.rs +++ b/rs/moq-net/tests/integration/replacement.rs @@ -95,7 +95,7 @@ async fn replace(version: &str, epoch: Option) { other => panic!("{version}: expected the broadcast, got {other:?}"), } - let old = viewer.consume().request_broadcast("cam", None).await.unwrap(); + let old = viewer.consume().request("cam", None).await.unwrap(); let mut sticky = subscribe(&old, "video").await.unwrap(); write(&video, "video:0"); assert_eq!(read(&mut sticky).await, "video:0", "{version}"); @@ -137,7 +137,7 @@ async fn replace(version: &str, epoch: Option) { } // Following the restart resolves the path afresh, and the new handle serves. - let fresh = viewer.consume().request_broadcast("cam", None).await.unwrap(); + let fresh = viewer.consume().request("cam", None).await.unwrap(); assert!(!fresh.is_clone(&old), "{version}: joined the retired broadcast"); let mut followed = subscribe(&fresh, "meta").await.unwrap(); write(&meta, "meta:0"); @@ -215,7 +215,7 @@ async fn route_death(version: &str, relayed: bool, wait: Duration) { let mut announced = viewer.consume().announced(); next_event(&mut announced).await; - let old = viewer.consume().request_broadcast("cam", None).await.unwrap(); + let old = viewer.consume().request("cam", None).await.unwrap(); let mut sticky = subscribe(&old, "video").await.unwrap(); write(&video, "video:0"); assert_eq!(read(&mut sticky).await, "video:0", "{version}"); @@ -293,7 +293,7 @@ async fn restart_while_the_old_session_lingers(version: &str, old_hop: u64, new_ let _new_session = link(version, &new, &viewer).await; moq_clock::sleep(PAST_HOLD).await; - let cam = viewer.consume().request_broadcast("cam", None).await.unwrap(); + let cam = viewer.consume().request("cam", None).await.unwrap(); let mut video = subscribe(&cam, "video") .await .unwrap_or_else(|err| panic!("{version} ({old_hop} -> {new_hop}): {err}")); diff --git a/rs/moq-net/tests/integration/request_caps.rs b/rs/moq-net/tests/integration/request_caps.rs index 79f9586dcf5..4414e4e5385 100644 --- a/rs/moq-net/tests/integration/request_caps.rs +++ b/rs/moq-net/tests/integration/request_caps.rs @@ -72,10 +72,13 @@ async fn closed_requests_are_granted_back() { for version in VERSIONS { let setup = setup(version, limits(0), ROUNDS).await; - let broadcast = moq_clock::timeout(TIMEOUT, setup.client.consume().routed_broadcast("bcast")) - .await - .expect("announce timeout") - .unwrap(); + let broadcast = moq_clock::timeout( + TIMEOUT, + setup.client.consume().follow("bcast", None).unwrap().available(), + ) + .await + .expect("announce timeout") + .unwrap(); for round in 0..ROUNDS { let track = broadcast.track(&format!("t{round}")).unwrap(); @@ -122,7 +125,7 @@ async fn flow_control_bounds_the_subscriptions_a_peer_holds() { options.server_limits = Some(limits(0)); let pair = connect_mock(options).await; - let remote = moq_clock::timeout(TIMEOUT, client.consume().routed_broadcast("bcast")) + let remote = moq_clock::timeout(TIMEOUT, client.consume().follow("bcast", None).unwrap().available()) .await .expect("announce timeout") .unwrap(); diff --git a/rs/moq-net/tests/integration/route_change.rs b/rs/moq-net/tests/integration/route_change.rs index f7a7ca97ef9..d384e438774 100644 --- a/rs/moq-net/tests/integration/route_change.rs +++ b/rs/moq-net/tests/integration/route_change.rs @@ -124,8 +124,7 @@ impl Topology { let a_to_r = link(version, &relay_a, &subscriber).await; let consumer = subscriber.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); @@ -359,7 +358,7 @@ async fn route_dies_without_an_epoch(version: &str, trigger: Trigger) { let remote = topology .subscriber .consume() - .request_broadcast("live", None) + .request("live", None) .await .expect("B serves a re-request"); let sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); @@ -388,7 +387,7 @@ async fn better_route_restarts(version: &str) { let mut group = topology.track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, payload(0, 0)).unwrap(); assert_eq!(next(&mut rx).await, (0, payload(0, 0)), "{version}"); - let incumbent = consumer.request_broadcast("live", None).await.unwrap(); + let incumbent = consumer.request("live", None).await.unwrap(); topology.trigger(Trigger::BetterRoute).await; match announced.next().await.expect("announced") { @@ -404,7 +403,7 @@ async fn better_route_restarts(version: &str) { assert_eq!(next(&mut rx).await, (0, payload(0, 1)), "{version}"); // A re-request resolves the better route on a fresh broadcast. - let replaced = consumer.request_broadcast("live", None).await.unwrap(); + let replaced = consumer.request("live", None).await.unwrap(); assert!(!replaced.is_clone(&incumbent), "{version}: joined the replaced front"); let sub = replaced.track("video").unwrap().subscribe(None).await.unwrap(); let mut fresh = read(sub); @@ -527,8 +526,7 @@ async fn lagging_route_dies(version: Version) { } async fn subscribe(origin: &origin::Producer) -> track::Subscriber { let consumer = origin.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); let preferences = track::Subscription::default().with_max_delay(Duration::from_secs(60)); remote.track("video").unwrap().subscribe(preferences).await.unwrap() } @@ -654,8 +652,7 @@ async fn undetected_outage(budget: Duration) -> BTreeMap> { let m1_e = link(version, &m1, &e).await; let consumer = e.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); let prefs = track::Subscription::default().with_max_delay(budget); let mut rx = read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()); let m2_e = priced_link(version, &m2, &e, Some(1_000)).await; @@ -801,7 +798,7 @@ async fn redundant_pair_fails_over(version: &str, loss: Loss) { settle().await; let consumer = subscriber.consume(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.request("live", None).await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let mut rx = read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()); @@ -910,8 +907,7 @@ async fn replaced_behind_a_relay(version: &str, epoch: Option, r let _r_to_d = link(version, &relay, &downstream).await; let consumer = downstream.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let mut rx = read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()); @@ -1030,8 +1026,7 @@ async fn compression_changes_behind_a_relay(compress: bool) { let _r_to_d = link(version, &relay, &downstream).await; let consumer = downstream.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let mut rx = read(remote.track("video").unwrap().subscribe(prefs).await.unwrap()); @@ -1125,8 +1120,7 @@ async fn producer_replaced(version: &str) { let _a_to_r = link(version, &relay, &subscriber).await; let consumer = subscriber.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(60)); let sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); let mut rx = read(sub); diff --git a/rs/moq-net/tests/integration/segmented_frame.rs b/rs/moq-net/tests/integration/segmented_frame.rs index 0bfe4898972..27ac7c9e608 100644 --- a/rs/moq-net/tests/integration/segmented_frame.rs +++ b/rs/moq-net/tests/integration/segmented_frame.rs @@ -40,7 +40,7 @@ async fn a_segmented_frame_crosses_whole() { options.client_subscribe = Some(viewer.clone()); let _pair = connect_mock(options).await; - let remote = moq_clock::timeout(TIMEOUT, viewer.consume().routed_broadcast("room")) + let remote = moq_clock::timeout(TIMEOUT, viewer.consume().follow("room", None).unwrap().available()) .await .expect("broadcast timeout") .unwrap(); diff --git a/rs/moq-net/tests/integration/session_close.rs b/rs/moq-net/tests/integration/session_close.rs index 223b0bfddf2..7d268a3dbc8 100644 --- a/rs/moq-net/tests/integration/session_close.rs +++ b/rs/moq-net/tests/integration/session_close.rs @@ -54,11 +54,7 @@ async fn setup_with_gate(version: &str, gate: Option>) -> Se let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -117,8 +113,7 @@ async fn track_info_interest_precedes_a_subscription() { options.client_subscribe = Some(subscriber.clone()); let _pair = connect_mock(options).await; let consumer = subscriber.consume(); - consumer.routed("bcast").await.unwrap(); - let remote = consumer.request_broadcast("bcast", None).await.unwrap(); + let remote = consumer.follow("bcast", None).unwrap().available().await.unwrap(); let copy = remote.track("video").unwrap(); copy.info().await.expect("TRACK_INFO"); crate::support::wanted(track.demand()) @@ -238,7 +233,7 @@ async fn close_withdraws_announcements_before_closing_the_transport() { options.client_publish = Some(publisher.consume()); options.server_subscribe = Some(subscriber.clone()); let pair = connect_mock(options).await; - subscriber.consume().routed("bcast").await.unwrap(); + crate::support::announced(&subscriber.consume(), "bcast").await; let before = pair.client_transport.finished_streams(); pair.client.close().await.unwrap(); assert!( @@ -259,7 +254,7 @@ async fn close_times_out_waiting_for_announcement_acknowledgements() { options.client_publish = Some(publisher.consume()); options.server_subscribe = Some(subscriber.clone()); let pair = connect_mock(options).await; - subscriber.consume().routed("bcast").await.unwrap(); + crate::support::announced(&subscriber.consume(), "bcast").await; pair.client_transport.hold_fin_acknowledgements(); let started = moq_clock::now(); assert!(matches!(pair.client.close().await, Err(Error::Timeout)), "{version}"); diff --git a/rs/moq-net/tests/integration/session_panic.rs b/rs/moq-net/tests/integration/session_panic.rs index 3d44c69693a..4619728dc97 100644 --- a/rs/moq-net/tests/integration/session_panic.rs +++ b/rs/moq-net/tests/integration/session_panic.rs @@ -127,7 +127,7 @@ async fn a_panicking_session_leaves_the_others_serving() { let later = healthy.origin.create_broadcast("later").unwrap(); later.announce(Default::default()).unwrap(); until(&mut announced, "later", true).await; - assert!(relay.consume().routed("healthy").await.is_some()); + crate::support::announced(&relay.consume(), "healthy").await; drop((healthy, broken.client, later)); } } diff --git a/rs/moq-net/tests/integration/setup_negotiation.rs b/rs/moq-net/tests/integration/setup_negotiation.rs index 454d93ad169..1ea725b1aec 100644 --- a/rs/moq-net/tests/integration/setup_negotiation.rs +++ b/rs/moq-net/tests/integration/setup_negotiation.rs @@ -66,7 +66,7 @@ async fn every_lite_version_negotiates_in_setup() { assert_eq!(session.version(), version, "{name}"); } // The session runs on the selected version, not on the SETUP stream. - downstream.consume().routed("room").await.expect(name); + crate::support::announced(&downstream.consume(), "room").await; } } diff --git a/rs/moq-net/tests/integration/source_errors.rs b/rs/moq-net/tests/integration/source_errors.rs index 6e2f5a6c93c..9ba9f6824d0 100644 --- a/rs/moq-net/tests/integration/source_errors.rs +++ b/rs/moq-net/tests/integration/source_errors.rs @@ -40,11 +40,7 @@ struct Relayed { async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Consumer { let consumer = origin.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves") diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index af927a68852..fc89fadefd0 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -34,7 +34,13 @@ async fn one_stream_credit_serves_every_backlogged_group() { options.client_subscribe = Some(viewer.clone()); let _pair = connect_mock(options).await; - let remote = viewer.consume().routed_broadcast("live").await.unwrap(); + let remote = viewer + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let prefs = track::Subscription::default().with_max_delay(Duration::from_secs(30)); let mut subscribers = Vec::new(); for i in 0..tracks.len() { diff --git a/rs/moq-net/tests/integration/subscribe_priority.rs b/rs/moq-net/tests/integration/subscribe_priority.rs index a8b4bc9b3b0..a972876700c 100644 --- a/rs/moq-net/tests/integration/subscribe_priority.rs +++ b/rs/moq-net/tests/integration/subscribe_priority.rs @@ -65,11 +65,7 @@ async fn follows(version: Version, relay: bool) -> Result<(), String> { } let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index b5c50cfe806..d317e2b6f42 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -91,11 +91,7 @@ async fn ahead_then_live(version: Option<&str>, relay: bool) -> (Vec, Vec Rang options.client_subscribe = Some(subscriber.clone()); sessions.push(connect_mock(options).await); let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("ranges")) - .await - .unwrap() - .unwrap(); - let remote = consumer.request_broadcast("ranges", None).await.unwrap(); + let remote = consumer.follow("ranges", None).unwrap().available().await.unwrap(); RangeFixture { track, remote, @@ -751,11 +739,7 @@ async fn a_covered_bounded_subscription_ends_on_lite07() { options.client_subscribe = Some(subscriber.clone()); let session = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/subscribe_tracks.rs b/rs/moq-net/tests/integration/subscribe_tracks.rs index 34bf4203ff2..e33a0341b0f 100644 --- a/rs/moq-net/tests/integration/subscribe_tracks.rs +++ b/rs/moq-net/tests/integration/subscribe_tracks.rs @@ -61,11 +61,7 @@ async fn setup(version: Version) -> Setup { let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("room", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/subscriber_max_age.rs b/rs/moq-net/tests/integration/subscriber_max_age.rs index c809cf9d44c..a67328124ed 100644 --- a/rs/moq-net/tests/integration/subscriber_max_age.rs +++ b/rs/moq-net/tests/integration/subscriber_max_age.rs @@ -51,8 +51,7 @@ async fn relay_forwards_the_most_tolerant_subscriber_max_age() { group.finish().unwrap(); broadcast.announce(Default::default()).unwrap(); let consumer = viewer.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); let cache = remote.track("catalog").unwrap(); let prefs = |millis| track::Subscription::default().with_max_delay(Duration::from_millis(millis)); let mut short = cache.subscribe(prefs(250)).await.unwrap(); diff --git a/rs/moq-net/tests/integration/subscription_end_integrity.rs b/rs/moq-net/tests/integration/subscription_end_integrity.rs index 7cf37edc556..29568f78082 100644 --- a/rs/moq-net/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-net/tests/integration/subscription_end_integrity.rs @@ -67,11 +67,7 @@ async fn round(drop_session: bool) -> (Vec>, Option) { let MockPair { client, server, .. } = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -216,9 +212,10 @@ async fn killed(version: &str, local: bool) -> (Option, Option moq_net::Result<()> { Ok(()) } +/// Wait until `consumer` sees a route announced at exactly `path`, and return it. +#[allow(dead_code, reason = "shared by several test binaries, each using only part of it")] +pub async fn announced(consumer: &origin::Consumer, path: &str) -> origin::Route { + let mut announced = consumer.announced(); + loop { + match announced.next().await.expect("the origin closed") { + announce::Event::Start(announce) + | announce::Event::Update(announce) + | announce::Event::Restart(announce) + if announce.prefix.as_str() == path => + { + return announce.route; + } + _ => {} + } + } +} + /// Reads of the peer's GOAWAY over [`goaway::Consumer::poll`]. #[allow(dead_code, reason = "shared by several test binaries, each using only part of it")] pub trait Draining { diff --git a/rs/moq-net/tests/integration/track_abort_over_session.rs b/rs/moq-net/tests/integration/track_abort_over_session.rs index 388c8a995d4..b94dbd47d7f 100644 --- a/rs/moq-net/tests/integration/track_abort_over_session.rs +++ b/rs/moq-net/tests/integration/track_abort_over_session.rs @@ -38,8 +38,7 @@ async fn after_abort(version: &str, hops: u32) { options.client_subscribe = Some(far.clone()); let _pair2 = connect_mock(options).await; let consumer = if hops == 2 { far.consume() } else { relay.consume() }; - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut open = track.append_group().unwrap(); open.write_frame(Timestamp::ZERO, b"head".as_ref()).unwrap(); @@ -82,7 +81,7 @@ async fn recreate(finish: bool) { .announce(moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint())) .unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); - let remote = origin.consume().request_broadcast("bench", None).await.unwrap(); + let remote = origin.consume().request("bench", None).await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut open = track.create_group(moq_net::group::Info { sequence: 2 }).unwrap(); open.write_frame(Timestamp::ZERO, b"head".as_ref()).unwrap(); diff --git a/rs/moq-net/tests/integration/track_info_cancel.rs b/rs/moq-net/tests/integration/track_info_cancel.rs index bd0af6e56d3..089b5df834d 100644 --- a/rs/moq-net/tests/integration/track_info_cancel.rs +++ b/rs/moq-net/tests/integration/track_info_cancel.rs @@ -35,11 +35,7 @@ async fn abandoned_request_reaches_the_publisher(version: &str, relays: u64) { broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = nodes[relays as usize] - .consume() - .request_broadcast("room", None) - .await - .unwrap(); + let consumer = nodes[relays as usize].consume().request("room", None).await.unwrap(); let mut waiting = Box::pin(consumer.track("video").unwrap().subscribe(None)); let request = match futures::future::select(std::pin::pin!(dynamic.requested_track()), &mut waiting).await { futures::future::Either::Left((request, _)) => request.expect("the request reaches the publisher"), @@ -85,7 +81,13 @@ async fn withdrawn_broadcast_releases_track_info(version: &str, answered: bool, options.server_publish = Some(publisher.consume()); options.client_subscribe = Some(reader.clone()); let pair = connect_mock(options).await; - let remote = reader.consume().routed_broadcast("room").await.unwrap(); + let remote = reader + .consume() + .follow("room", None) + .unwrap() + .available() + .await + .unwrap(); let mut query = remote.track("video").unwrap().info(); let request = match futures::future::select(std::pin::pin!(dynamic.requested_track()), &mut query).await { futures::future::Either::Left((request, _)) => request.expect("TRACK reaches the publisher"), diff --git a/rs/moq-net/tests/integration/track_stream_demand.rs b/rs/moq-net/tests/integration/track_stream_demand.rs index c132853c31e..167d876b39c 100644 --- a/rs/moq-net/tests/integration/track_stream_demand.rs +++ b/rs/moq-net/tests/integration/track_stream_demand.rs @@ -103,11 +103,7 @@ async fn one_used_edge(version: &str, relays: usize, reorder: bool) { }); let consumer = nodes.last().unwrap().consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) - .await - .unwrap_or_else(|_| panic!("{label}: never announced")) - .unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + let remote = consumer.follow("room", None).unwrap().available().await.unwrap(); let subscribing = remote.track("video").unwrap().subscribe(None); if reorder { @@ -194,11 +190,7 @@ async fn bare_handle_is_lazy(version: &str, relays: usize) { }); let consumer = nodes.last().unwrap().consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) - .await - .unwrap_or_else(|_| panic!("{label}: never announced")) - .unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + let remote = consumer.follow("room", None).unwrap().available().await.unwrap(); let handle = remote.track("video").unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index 248541ee2a5..f96d9d2e501 100644 --- a/rs/moq-net/tests/integration/track_tail.rs +++ b/rs/moq-net/tests/integration/track_tail.rs @@ -86,11 +86,7 @@ async fn connect(version: &str) -> Pair { let pair = connect_mock(options).await; let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("bcast")) - .await - .expect("announce timeout") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("bcast", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/integration/tracks.rs b/rs/moq-net/tests/integration/tracks.rs index 1dcbf5fa696..365a4dd8ac8 100644 --- a/rs/moq-net/tests/integration/tracks.rs +++ b/rs/moq-net/tests/integration/tracks.rs @@ -53,7 +53,7 @@ async fn connect( } async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Consumer { - moq_clock::timeout(TIMEOUT, origin.consume().routed_broadcast("bcast")) + moq_clock::timeout(TIMEOUT, origin.consume().follow("bcast", None).unwrap().available()) .await .expect("announce timeout") .expect("routed") diff --git a/rs/moq-net/tests/integration/tracks_ietf.rs b/rs/moq-net/tests/integration/tracks_ietf.rs index 6eab3284ac4..0d6c60c7c91 100644 --- a/rs/moq-net/tests/integration/tracks_ietf.rs +++ b/rs/moq-net/tests/integration/tracks_ietf.rs @@ -64,7 +64,7 @@ async fn connect(publisher: &moq_net::origin::Producer, version: &str) -> (moq_n } async fn resolve(origin: &moq_net::origin::Producer, path: &str) -> moq_net::broadcast::Consumer { - moq_clock::timeout(TIMEOUT, origin.consume().routed_broadcast(path)) + moq_clock::timeout(TIMEOUT, origin.consume().follow(path, None).unwrap().available()) .await .expect("announce timeout") .expect("routed") diff --git a/rs/moq-net/tests/integration/unannounce_release.rs b/rs/moq-net/tests/integration/unannounce_release.rs index 551289eb499..e982824b905 100644 --- a/rs/moq-net/tests/integration/unannounce_release.rs +++ b/rs/moq-net/tests/integration/unannounce_release.rs @@ -28,8 +28,12 @@ async fn release(version: Version) { let track = broadcast.create_track("t", None).unwrap(); let consumer = relay.consume(); - consumer.routed("a/b").await.expect("routed"); - let remote = consumer.request_broadcast("a/b", None).await.expect("resolves"); + let remote = consumer + .follow("a/b", None) + .unwrap() + .available() + .await + .expect("resolves"); let sub = remote.track("t").unwrap().subscribe(None).await.expect("subscribes"); crate::support::wanted(track.demand()).await.unwrap(); diff --git a/rs/moq-net/tests/integration/untimed.rs b/rs/moq-net/tests/integration/untimed.rs index c313a31f23a..e49141cb56e 100644 --- a/rs/moq-net/tests/integration/untimed.rs +++ b/rs/moq-net/tests/integration/untimed.rs @@ -81,7 +81,7 @@ impl Chain { async fn subscribe(&self, track: &str) -> track::Subscriber { let consumer = self.nodes.last().unwrap().consume(); - let broadcast = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + let broadcast = moq_clock::timeout(TIMEOUT, consumer.request("room", None)) .await .expect("resolve timeout") .expect("broadcast resolves"); @@ -176,7 +176,7 @@ async fn an_explicit_start_holds_on_an_untimed_track() { } moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = chain.nodes[1].consume().request_broadcast("room", None).await.unwrap(); + let consumer = chain.nodes[1].consume().request("room", None).await.unwrap(); let subscription = track::Subscription::default() .with_range(2..) .with_max_delay(Duration::from_secs(30)); @@ -233,7 +233,7 @@ async fn a_fetched_untimed_frame_arrives_untimed() { broadcast.announce(Default::default()).unwrap(); moq_clock::sleep(Duration::from_secs(1)).await; - let consumer = chain.nodes[1].consume().request_broadcast("room", None).await.unwrap(); + let consumer = chain.nodes[1].consume().request("room", None).await.unwrap(); let mut waiting = Box::pin(consumer.track("video").unwrap().fetch_group(0, None)); let request = match futures::future::select(std::pin::pin!(dynamic.requested_track()), &mut waiting).await { futures::future::Either::Left((request, _)) => request.expect("the track request reaches the publisher"), diff --git a/rs/moq-net/tests/integration/warm_backfill.rs b/rs/moq-net/tests/integration/warm_backfill.rs index aeedd1ca90e..43581b440ca 100644 --- a/rs/moq-net/tests/integration/warm_backfill.rs +++ b/rs/moq-net/tests/integration/warm_backfill.rs @@ -39,8 +39,7 @@ fn origin(hop: u64) -> origin::Producer { async fn subscribe(relay: &origin::Producer) -> track::Subscriber { let consumer = relay.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); remote .track("video") .unwrap() diff --git a/rs/moq-net/tests/integration/wide_hop.rs b/rs/moq-net/tests/integration/wide_hop.rs index 82657f75e04..43eb0e30e0c 100644 --- a/rs/moq-net/tests/integration/wide_hop.rs +++ b/rs/moq-net/tests/integration/wide_hop.rs @@ -32,9 +32,9 @@ async fn widest_hop_crosses_each_varint_form() { moq_clock::sim::idle().await; let ids = |route: origin::Route| route.hops.iter().map(|hop| hop.id()).collect::>(); - let at_relay = relay.consume().routed("room").await.expect("relay learned the route"); + let at_relay = crate::support::announced(&relay.consume(), "room").await; assert_eq!(ids(at_relay), [u64::MAX], "{downstream}"); - let at_sink = sink.consume().routed("room").await.expect("sink learned the route"); + let at_sink = crate::support::announced(&sink.consume(), "room").await; assert_eq!(ids(at_sink), [forwarded, 2], "{downstream}"); } } diff --git a/rs/moq-net/tests/integration/wide_sequence.rs b/rs/moq-net/tests/integration/wide_sequence.rs index f3c337aba5e..8fcca1083bc 100644 --- a/rs/moq-net/tests/integration/wide_sequence.rs +++ b/rs/moq-net/tests/integration/wide_sequence.rs @@ -35,8 +35,13 @@ async fn largest_quic_sequence_reaches_the_subscriber() { } else { None }; - client.consume().routed("ladder").await.unwrap(); - let remote = client.consume().request_broadcast("ladder", None).await.unwrap(); + let remote = client + .consume() + .follow("ladder", None) + .unwrap() + .available() + .await + .unwrap(); let mut sub = remote.track("data").unwrap().subscribe(None).await.unwrap(); for sequence in [5, 1 << 32, (1 << 53) - 1, (1 << 53) + 1, (1 << 62) - 1] { // Timestamps stop at 2^61 - 1, the most lite-05/06 can zigzag as a first frame. @@ -100,14 +105,18 @@ async fn wide_sequence_fails_only_its_subscription() { let _downstream = connect_mock(options).await; // lite-07 carries the full 64 bits, so the relay holds the group. - relay.consume().routed("bench").await.unwrap(); - let cached = relay.consume().request_broadcast("bench", None).await.unwrap(); + let cached = relay + .consume() + .follow("bench", None) + .unwrap() + .available() + .await + .unwrap(); let mut sub = cached.track("wide").unwrap().subscribe(None).await.unwrap(); assert_eq!(sub.recv_group().await.unwrap().unwrap().sequence, WIDE); let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let result = moq_clock::timeout(Duration::from_secs(5), async { let mut sub = remote.track("wide").unwrap().subscribe(None).await?; @@ -156,8 +165,7 @@ async fn a_later_wide_group_fails_only_that_subscription() { let _downstream = connect_mock(options).await; let consumer = client.consume(); - consumer.routed("bench").await.unwrap(); - let remote = consumer.request_broadcast("bench", None).await.unwrap(); + let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); let mut sub = remote.track("wide").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); diff --git a/rs/moq-net/tests/integration/widened_max_age.rs b/rs/moq-net/tests/integration/widened_max_age.rs index c664ff65e80..d4a836b30f5 100644 --- a/rs/moq-net/tests/integration/widened_max_age.rs +++ b/rs/moq-net/tests/integration/widened_max_age.rs @@ -89,8 +89,7 @@ impl Chain { /// Subscribe from the viewer with `budget`, reading from the oldest group still around. async fn subscribe(&self, budget: Duration) -> track::Subscriber { let consumer = self.viewer.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); let subscription = Subscription::default() .with_max_delay(budget) .with_ranges([Range::oldest()]); @@ -233,8 +232,7 @@ async fn wider_newcomers_after_the_first_pull_nothing_upstream() { let viewer = origin(3); links.push(peer(version, &relay, &viewer).await); let consumer = viewer.consume(); - consumer.routed("live").await.unwrap(); - let remote = consumer.request_broadcast("live", None).await.unwrap(); + let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); let subscription = Subscription::default() .with_max_delay(budget) .with_ranges([Range::oldest()]); diff --git a/rs/moq-net/tests/integration/zero_copy.rs b/rs/moq-net/tests/integration/zero_copy.rs index 5e4c3212579..34732f0e9e6 100644 --- a/rs/moq-net/tests/integration/zero_copy.rs +++ b/rs/moq-net/tests/integration/zero_copy.rs @@ -59,11 +59,7 @@ async fn frames_cross_without_a_copy() { broadcast.announce(Default::default()).unwrap(); let consumer = subscriber.consume(); - moq_clock::timeout(TIMEOUT, consumer.routed("room")) - .await - .expect("announce timeout") - .unwrap(); - let remote = moq_clock::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + let remote = moq_clock::timeout(TIMEOUT, consumer.follow("room", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves"); diff --git a/rs/moq-net/tests/loom.rs b/rs/moq-net/tests/loom.rs index f74cf58299f..95658fcf665 100644 --- a/rs/moq-net/tests/loom.rs +++ b/rs/moq-net/tests/loom.rs @@ -270,7 +270,7 @@ fn a_front_sees_a_reader_come_and_go() { let noop = kio::Waiter::noop(); let now = moq_net::time::Instant::now(); - let pending = consumer.request_broadcast("room", None); + let pending = consumer.request("room", None); driver.poll(now, &noop).unwrap(); let room = block_on(pending).expect("resolves"); @@ -311,7 +311,7 @@ fn a_front_sees_a_reader_return() { let noop = kio::Waiter::noop(); let now = moq_net::time::Instant::now(); - let pending = consumer.request_broadcast("room", None); + let pending = consumer.request("room", None); driver.poll(now, &noop).unwrap(); let room = block_on(pending).expect("resolves"); @@ -503,11 +503,11 @@ fn a_request_never_joins_a_retiring_front() { let waiter = kio::Waiter::noop(); let now = moq_net::time::Instant::now(); - let pending = consumer.request_broadcast("room", None); + let pending = consumer.request("room", None); driver.poll(now, &waiter).unwrap(); let first = block_on(pending).expect("resolves"); - let requester = thread::spawn(move || consumer.request_broadcast("room", None)); + let requester = thread::spawn(move || consumer.request("room", None)); drop(first); driver.poll(now, &waiter).unwrap(); let pending = requester.join().unwrap(); @@ -526,7 +526,7 @@ fn a_refused_answer_is_never_announced() { model(|| { let (producer, mut driver) = origin::Producer::new(origin::Config::new(Hop::new(1).unwrap())); let claim = producer.requests("room").unwrap(); - let pending = producer.consume().request_broadcast("room/alice", None); + let pending = producer.consume().request("room/alice", None); driver .poll(moq_net::time::Instant::now(), &kio::Waiter::noop()) .unwrap(); @@ -536,11 +536,11 @@ fn a_refused_answer_is_never_announced() { .expect("prepare"); // Keep a refused answer alive so dropping it cannot hide a stray announcement. let _answer = prepared.broadcast().clone(); + // Only the claim and its answer can cover the path, so any start is a covering route. let announced = |consumer: &origin::Consumer| { - let mut route = std::pin::pin!(consumer.routed("room/alice")); matches!( - kio::Waiter::noop().poll_future(route.as_mut()), - std::task::Poll::Ready(Some(_)) + consumer.announced().poll_next(&kio::Waiter::noop()), + std::task::Poll::Ready(Some(moq_net::announce::Event::Start(_))) ) }; @@ -575,7 +575,7 @@ fn refused_track_race(read: fn(&mut moq_net::track::Subscriber) -> bool) { let noop = kio::Waiter::noop(); let now = moq_net::time::Instant::now(); - let pending = consumer.request_broadcast("room", None); + let pending = consumer.request("room", None); driver.poll(now, &noop).unwrap(); let room = block_on(pending).expect("resolves"); From c53081a5b65b21a9604258f5435e8804bbe427d1 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 17:08:53 -0700 Subject: [PATCH 3/5] wip: move callers to request and follow --- rs/hang/examples/subscribe.rs | 4 +- rs/moq-audio/src/decode/consumer.rs | 3 +- rs/moq-bench/src/connection.rs | 10 +- rs/moq-boy/src/input.rs | 2 +- rs/moq-cli/src/announced.rs | 2 +- rs/moq-cli/src/archive.rs | 4 +- rs/moq-cli/src/fetch.rs | 3 +- rs/moq-cli/src/hls.rs | 5 +- rs/moq-cli/src/main.rs | 18 +++- rs/moq-cli/src/publish.rs | 6 +- rs/moq-cli/src/report.rs | 9 +- rs/moq-cli/src/report/echo_test.rs | 8 +- rs/moq-cli/src/rtc.rs | 5 +- rs/moq-cli/src/rtmp.rs | 5 +- rs/moq-cli/src/subscribe.rs | 14 +-- rs/moq-cli/tests/integration/epochs.rs | 19 ++-- rs/moq-cli/tests/integration/export.rs | 9 +- rs/moq-cli/tests/integration/import.rs | 4 +- rs/moq-cli/tests/integration/rtsp.rs | 2 +- rs/moq-e2ee/tests/transport.rs | 11 +- rs/moq-gst/src/source/imp.rs | 29 ++--- rs/moq-hls/src/export/mod.rs | 8 +- rs/moq-hls/src/lib.rs | 5 +- rs/moq-hls/src/server/mod.rs | 51 ++++----- rs/moq-hls/tests/integration/server.rs | 27 ++--- rs/moq-mux/benches/containers.rs | 2 +- rs/moq-mux/benches/export.rs | 4 +- rs/moq-mux/src/catalog/hang/consumer.rs | 2 +- rs/moq-mux/src/container/consumer.rs | 2 +- rs/moq-mux/src/container/source.rs | 6 +- rs/moq-mux/src/container/ts/export_test.rs | 100 ++++++++++++++---- rs/moq-mux/src/container/ts/programs.rs | 6 +- rs/moq-mux/src/linger.rs | 4 +- rs/moq-mux/src/source.rs | 58 +++++----- .../tests/integration/ietf_conformance.rs | 9 +- rs/moq-net-tests/tests/integration/refresh.rs | 12 ++- rs/moq-net-tests/tests/integration/restart.rs | 6 +- rs/moq-relay/src/cluster.rs | 42 ++++---- rs/moq-relay/src/internal.rs | 2 +- rs/moq-relay/src/web.rs | 3 +- rs/moq-relay/tests/drills.rs | 11 +- .../tests/integration/auth_lifetime.rs | 12 +-- .../tests/integration/cluster_drain.rs | 30 ++++-- .../tests/integration/cluster_unknown.rs | 10 +- rs/moq-relay/tests/integration/connection.rs | 10 +- rs/moq-relay/tests/integration/embed.rs | 2 +- .../tests/integration/goaway_cluster.rs | 16 ++- .../tests/integration/public_rules.rs | 5 +- rs/moq-relay/tests/integration/refusals.rs | 23 ++-- .../tests/integration/runtime_uring.rs | 6 +- .../tests/integration/runtime_workers.rs | 2 +- .../tests/integration/shutdown_signal.rs | 3 +- rs/moq-relay/tests/integration/smoke.rs | 13 +-- .../tests/integration/upstream_links.rs | 9 +- rs/moq-room/src/chat.rs | 3 +- rs/moq-room/src/room.rs | 2 +- rs/moq-rtc/src/client/whip.rs | 2 +- rs/moq-rtc/src/egress.rs | 2 +- rs/moq-rtc/src/lib.rs | 12 +-- rs/moq-rtc/src/server/whep.rs | 18 ++-- rs/moq-rtc/src/server/whip.rs | 6 +- rs/moq-rtmp/src/dial.rs | 17 ++- rs/moq-rtmp/src/server.rs | 27 ++--- rs/moq-srt/src/ts.rs | 41 ++++--- rs/moq-stats/src/aggregate.rs | 6 +- rs/moq-stats/src/consume.rs | 8 +- rs/moq-stats/src/produce.rs | 42 ++------ rs/moq-studio/src/engine.rs | 2 +- rs/moq-tokio/examples/clock.rs | 2 +- rs/moq-tokio/src/client.rs | 5 +- rs/moq-tokio/src/connection.rs | 4 +- rs/moq-tokio/src/server.rs | 2 +- rs/moq-tokio/src/webrtc/tests.rs | 2 +- rs/moq-tokio/tests/integration/backend.rs | 10 +- rs/moq-tokio/tests/integration/broadcast.rs | 44 ++++---- rs/moq-tokio/tests/integration/max_age.rs | 2 +- .../tests/integration/receive_credit.rs | 6 +- rs/moq-tokio/tests/integration/runtime.rs | 2 +- .../integration/subscription_end_integrity.rs | 5 +- rs/moq-tokio/tests/integration/unannounce.rs | 2 +- rs/moq-transcode/examples/transcode.rs | 24 ++--- rs/moq-uring/benches/session_lite.rs | 5 +- .../tests/integration/receive_credit.rs | 26 ++--- rs/moq-uring/tests/integration/session.rs | 10 +- rs/moq-uring/tests/integration/web.rs | 5 +- rs/moq-video/src/decode/decoder.rs | 2 +- rs/moq-wasm/src/lib.rs | 5 +- test/interop/clients/rust/audio.rs | 2 +- test/interop/clients/rust/finish.rs | 7 +- test/interop/clients/rust/goaway-client.rs | 4 +- test/interop/clients/rust/tail.rs | 2 +- 91 files changed, 549 insertions(+), 490 deletions(-) diff --git a/rs/hang/examples/subscribe.rs b/rs/hang/examples/subscribe.rs index 8b74ba453d8..5cf536aafef 100644 --- a/rs/hang/examples/subscribe.rs +++ b/rs/hang/examples/subscribe.rs @@ -72,9 +72,7 @@ async fn run_subscribe(consumer: moq_net::origin::Consumer) -> anyhow::Result<() // Resolve an announced broadcast and read media frames. async fn play(consumer: moq_net::origin::Consumer, announce: moq_net::announce::Announce) -> anyhow::Result<()> { - let broadcast = consumer - .request_broadcast(&announce.prefix, announce.route.epoch) - .await?; + let broadcast = consumer.request(&announce.prefix, announce.route.epoch).await?; // Read the catalog to discover available tracks. let catalog_track = broadcast diff --git a/rs/moq-audio/src/decode/consumer.rs b/rs/moq-audio/src/decode/consumer.rs index 706fc7c0c83..4fc46cf5108 100644 --- a/rs/moq-audio/src/decode/consumer.rs +++ b/rs/moq-audio/src/decode/consumer.rs @@ -925,8 +925,7 @@ mod tests { let relay = origin(2); let _link = link(&publisher, &relay).await; let consumer = relay.consume(); - consumer.routed("bcast").await.unwrap(); - let remote = consumer.request_broadcast("bcast", None).await.unwrap(); + let remote = consumer.follow("bcast", None).unwrap().available().await.unwrap(); // A first reader warms the relay's copy with every group. { diff --git a/rs/moq-bench/src/connection.rs b/rs/moq-bench/src/connection.rs index 0f5bcde0373..53c35d6d250 100644 --- a/rs/moq-bench/src/connection.rs +++ b/rs/moq-bench/src/connection.rs @@ -315,11 +315,7 @@ async fn subscribe_named( max_delay: Duration, stats: Arc, ) -> anyhow::Result<()> { - consume - .routed(path.as_str()) - .await - .ok_or_else(|| anyhow::anyhow!("target broadcast was never announced: {path}"))?; - let broadcast = consume.request_broadcast(path.as_str(), None).await?; + let broadcast = consume.follow(path.as_str(), None)?.available().await?; drain(broadcast, max_delay, &stats).await } @@ -380,7 +376,7 @@ async fn subscribe( let mut selected = pool.len() as u64; for path in pool { - let Ok(broadcast) = consume.request_broadcast(path.as_str(), None).await else { + let Ok(broadcast) = consume.request(path.as_str(), None).await else { continue; }; spawn_drain(&mut tasks, path, broadcast, max_delay, stats.clone()); @@ -402,7 +398,7 @@ async fn subscribe( if own.contains(&path) || !seen.insert(path.clone()) { continue; } - let Ok(broadcast) = consume.request_broadcast(path.as_str(), None).await else { + let Ok(broadcast) = consume.request(path.as_str(), None).await else { continue; }; selected += 1; diff --git a/rs/moq-boy/src/input.rs b/rs/moq-boy/src/input.rs index 963d5a91105..5015279c5ec 100644 --- a/rs/moq-boy/src/input.rs +++ b/rs/moq-boy/src/input.rs @@ -84,7 +84,7 @@ pub async fn handle_viewers( if !restart && readers.get(&viewer_id).is_some_and(|reader| !reader.is_finished()) { continue; } - let Ok(broadcast) = viewer_origin.request_broadcast(&update.prefix, None).await else { + let Ok(broadcast) = viewer_origin.request(&update.prefix, None).await else { continue; }; tracing::info!(%viewer_id, restart, "viewer connected"); diff --git a/rs/moq-cli/src/announced.rs b/rs/moq-cli/src/announced.rs index 71f947dc80b..d86ae0ef9da 100644 --- a/rs/moq-cli/src/announced.rs +++ b/rs/moq-cli/src/announced.rs @@ -229,7 +229,7 @@ mod tests { // Every broadcast is on the relay before anything follows it. for (path, _) in &broadcasts { - tokio::time::timeout(TIMEOUT, relay.routed_broadcast(*path)) + tokio::time::timeout(TIMEOUT, relay.follow(*path, None).unwrap().available()) .await .expect("relay routes the broadcast") .expect("broadcast"); diff --git a/rs/moq-cli/src/archive.rs b/rs/moq-cli/src/archive.rs index d83a7ef08d3..6be95411af0 100644 --- a/rs/moq-cli/src/archive.rs +++ b/rs/moq-cli/src/archive.rs @@ -107,7 +107,7 @@ pub async fn export(origin: moq_net::origin::Consumer, prefix: String, args: Exp let store = moq_archive::Store::new(store.clone(), key); // Requested now, so an announcement resolves the instance serving it when read, not // whichever one serves by the time its task runs. - let request = origin.request_broadcast(&instance.0, instance.1.clone()); + let request = origin.request(&instance.0, instance.1.clone()); recordings.spawn(record(request, instance, store, config.clone(), claims.clone())); } } @@ -430,7 +430,7 @@ mod tests { }) .await .expect("the replay is announced"); - let broadcast = origin.consume().request_broadcast("replay", None).await.unwrap(); + let broadcast = origin.consume().request("replay", None).await.unwrap(); let track = broadcast.track("video").unwrap(); let mut group = track.fetch_group(0, None).await.unwrap(); let frame = group.read_frame().await.unwrap().unwrap(); diff --git a/rs/moq-cli/src/fetch.rs b/rs/moq-cli/src/fetch.rs index 299bbcac48e..770c9567aec 100644 --- a/rs/moq-cli/src/fetch.rs +++ b/rs/moq-cli/src/fetch.rs @@ -119,7 +119,8 @@ async fn fetch_from( // is still in flight right after connecting. let broadcast = origin .consume() - .routed_broadcast(path) + .follow(path, None)? + .available() .await .with_context(|| format!("broadcast `{}` not found", crate::display_name(path)))?; let track = broadcast.track(&args.track)?; diff --git a/rs/moq-cli/src/hls.rs b/rs/moq-cli/src/hls.rs index 7711a85229e..a10b1890769 100644 --- a/rs/moq-cli/src/hls.rs +++ b/rs/moq-cli/src/hls.rs @@ -299,7 +299,8 @@ pub async fn export(origin: moq_net::origin::Consumer, args: ExportArgs, name: S // Wait for a covering route rather than asking on the spot: a recording started beside // its publisher, or over a session that discovers only watched paths, sees no route yet. let broadcast = scoped - .routed_broadcast(name.as_str()) + .follow(name.as_str(), None)? + .available() .await .with_context(|| format!("failed to resolve broadcast `{name}`"))?; let source = moq_mux::Source::new(scoped.clone(), broadcast); @@ -523,7 +524,7 @@ mod test { let importing = tokio::spawn(import(target, args, moq_net::Epoch::mint())); announced.next().await.expect("announced"); - let broadcast = consumer.request_broadcast("hls", None).await.unwrap(); + let broadcast = consumer.request("hls", None).await.unwrap(); let mut catalogs = hang::catalog::Catalog::<()>::subscribe(&broadcast).await.unwrap(); let catalog = catalogs.next().await.unwrap().expect("a catalog"); let name = catalog.audio.renditions.keys().next().expect("an audio rendition"); diff --git a/rs/moq-cli/src/main.rs b/rs/moq-cli/src/main.rs index eda6fb07fbb..28e08262eca 100644 --- a/rs/moq-cli/src/main.rs +++ b/rs/moq-cli/src/main.rs @@ -924,9 +924,10 @@ async fn run_stdout( // resolves it, and any sibling broadcast a rendition's `broadcast` field references // (e.g. "./source") through the same origin. consumer - .routed(&name) + .follow(name.as_str(), None)? + .available() .await - .ok_or_else(|| anyhow::anyhow!("origin closed before broadcast `{name}` was announced"))?; + .with_context(|| format!("failed to resolve broadcast `{name}`"))?; let subscribe = Subscribe::new(consumer, &name, catalog, args).await?; let Some(echo) = echo else { @@ -1265,7 +1266,13 @@ mod tests { .unwrap(); // Media proves the CLI admitted the session, even on a transport that establishes early. let payload = tokio::time::timeout(TIMEOUT, async { - let broadcast = listening.consumer.routed_broadcast("probe").await.unwrap(); + let broadcast = listening + .consumer + .follow("probe", None) + .unwrap() + .available() + .await + .unwrap(); let mut track = broadcast .track("status") .unwrap() @@ -1360,9 +1367,10 @@ mod tests { group.finish().unwrap(); let reader = relay.consume(); - reader.routed("demo").await.unwrap(); let mut live = reader - .request_broadcast("demo", None) + .follow("demo", None) + .unwrap() + .available() .await .unwrap() .track("live") diff --git a/rs/moq-cli/src/publish.rs b/rs/moq-cli/src/publish.rs index 068c293f6d1..3f6fbb76885 100644 --- a/rs/moq-cli/src/publish.rs +++ b/rs/moq-cli/src/publish.rs @@ -1078,7 +1078,7 @@ pub(crate) mod tests { /// A source for the broadcast at `path`, resolved through `origin`. async fn resolved(origin: &moq_net::origin::Producer, path: &str) -> moq_mux::Source { let consumer = origin.consume(); - let broadcast = consumer.request_broadcast(path, None).await.unwrap(); + let broadcast = consumer.request(path, None).await.unwrap(); moq_mux::Source::new(consumer, broadcast) } @@ -1342,7 +1342,7 @@ pub(crate) mod tests { // the lead holds; the jump is in the copy after it. const WAIT: Duration = Duration::from_secs(10); decoder.decode_chunk(&lead).unwrap(); - let consumer = tokio::time::timeout(WAIT, remote.consume().routed_broadcast("pt.hang")) + let consumer = tokio::time::timeout(WAIT, remote.consume().follow("pt.hang", None).unwrap().available()) .await .unwrap() .unwrap(); @@ -1787,7 +1787,7 @@ pub(crate) mod tests { resolved = async { let event = announced.next().await.expect("origin closed"); assert!(matches!(event, moq_net::announce::Event::Start(_)), "{event:?}"); - let broadcast = consumer.request_broadcast("demo", None).await.unwrap(); + let broadcast = consumer.request("demo", None).await.unwrap(); let mut catalogs = hang::catalog::Catalog::<()>::subscribe(&broadcast).await.unwrap(); let catalog = catalogs.next().await.unwrap().expect("a catalog"); // A passthrough carries the multiplex on one track, named by its m2ts section. diff --git a/rs/moq-cli/src/report.rs b/rs/moq-cli/src/report.rs index 9eeb5fe17f7..2abeae7af96 100644 --- a/rs/moq-cli/src/report.rs +++ b/rs/moq-cli/src/report.rs @@ -413,12 +413,9 @@ async fn snapshot( /// track its catalog's `stats` section names, until the catalog and that track have both ended. pub async fn print_report(origin: moq_net::origin::Consumer, path: String) -> anyhow::Result<()> { let mut stdout = tokio::io::stdout(); - origin - .routed(&path) - .await - .ok_or_else(|| anyhow::anyhow!("origin closed before broadcast `{path}` was announced"))?; let broadcast = origin - .request_broadcast(path.as_str(), None) + .follow(path.as_str(), None)? + .available() .await .with_context(|| format!("failed to resolve broadcast `{path}`"))?; let source = moq_mux::Source::new(origin, broadcast.clone()); @@ -569,7 +566,7 @@ impl Readers { /// Send a line for each feedback snapshot the broadcast at `path` publishes, until it ends. async fn read_echo(origin: moq_net::origin::Consumer, path: moq_net::Path, lines: tokio::sync::mpsc::Sender) { let read = async { - let broadcast = origin.request_broadcast(&path, None).await?; + let broadcast = origin.request(&path, None).await?; let subscriber = broadcast.track(hang::echo::TRACK)?.subscribe(None).await?; let mut track = reader(subscriber); while let Some(moq_net::Timed { value: feedback, .. }) = track.latest().await? { diff --git a/rs/moq-cli/src/report/echo_test.rs b/rs/moq-cli/src/report/echo_test.rs index 8a508b3c23d..e1870ec1f6f 100644 --- a/rs/moq-cli/src/report/echo_test.rs +++ b/rs/moq-cli/src/report/echo_test.rs @@ -29,7 +29,13 @@ async fn export_echo_reports_where_the_import_solicits() { let mut import = ts::Import::new(broadcast, catalog.reserve()); import.decode(&CLIP[..HALF]).unwrap(); publication.announce(Default::default()).unwrap(); - origin.consume().routed("demo").await.unwrap(); + origin + .consume() + .follow("demo", None) + .unwrap() + .available() + .await + .unwrap(); let args = SubscribeArgs { format: SubscribeFormat::Ts, diff --git a/rs/moq-cli/src/rtc.rs b/rs/moq-cli/src/rtc.rs index 311f6fdfb57..80c275737a4 100644 --- a/rs/moq-cli/src/rtc.rs +++ b/rs/moq-cli/src/rtc.rs @@ -118,9 +118,10 @@ pub async fn connect_export(origin: moq_net::origin::Consumer, url: Url, name: S // Confirm the broadcast is reachable (and wait for it to be announced) before dialing; // the egress re-resolves it (and any referenced sibling broadcast) through the origin. origin - .routed(&name) + .follow(name.as_str(), None)? + .available() .await - .with_context(|| format!("origin closed before broadcast `{name}` was announced"))?; + .with_context(|| format!("failed to resolve broadcast `{name}`"))?; tracing::info!(url = %RedactedUrl::new(&url), %name, "WHIP client pushing"); notify_ready(); diff --git a/rs/moq-cli/src/rtmp.rs b/rs/moq-cli/src/rtmp.rs index 8039444f956..b4b0fe76d69 100644 --- a/rs/moq-cli/src/rtmp.rs +++ b/rs/moq-cli/src/rtmp.rs @@ -173,9 +173,10 @@ pub async fn connect_export( // Confirm the broadcast is reachable (and wait for it to be announced) before dialing; // the FLV export re-resolves it (and any referenced sibling broadcast) through the origin. origin - .routed(&name) + .follow(&name, None)? + .available() .await - .with_context(|| format!("origin closed before broadcast `{name}` was announced"))?; + .with_context(|| format!("failed to resolve broadcast `{name}`"))?; // The stream key is the ingest credential, so log the dial target and app instead. tracing::info!(%addr, %app, %name, "RTMP client pushing"); diff --git a/rs/moq-cli/src/subscribe.rs b/rs/moq-cli/src/subscribe.rs index 0f8ed9b9347..7ac908cecf8 100644 --- a/rs/moq-cli/src/subscribe.rs +++ b/rs/moq-cli/src/subscribe.rs @@ -246,8 +246,6 @@ impl SubscribeArgs { /// Exports one broadcast from the Origin to stdout in the requested format. pub struct Subscribe { - origin: moq_net::origin::Consumer, - path: moq_net::Path, source: moq_mux::Source, catalog: CatalogFormat, args: SubscribeArgs, @@ -280,13 +278,11 @@ impl Subscribe { ) -> anyhow::Result { let path = moq_net::Path::new(path)?; let broadcast = origin - .request_broadcast(&path, None) + .request(&path, None) .await .with_context(|| format!("failed to resolve broadcast `{path}`"))?; - let source = moq_mux::Source::new(origin.clone(), broadcast); + let source = moq_mux::Source::new(origin, broadcast); Ok(Self { - origin, - path, source, catalog, args, @@ -390,12 +386,6 @@ impl Subscribe { } async fn run_ts(self) -> anyhow::Result<()> { - self.origin.routed(&self.path).await.with_context(|| { - format!( - "broadcast `{}` is outside the session's scope, or the origin closed before it was announced", - self.path - ) - })?; if self.args.passthrough { return self.run_ts_passthrough().await; } diff --git a/rs/moq-cli/tests/integration/epochs.rs b/rs/moq-cli/tests/integration/epochs.rs index ce6539ce8a3..e0843551721 100644 --- a/rs/moq-cli/tests/integration/epochs.rs +++ b/rs/moq-cli/tests/integration/epochs.rs @@ -117,7 +117,7 @@ async fn within(started: Instant, change: impl Future) -> T { } /// Ignore same-instance metadata updates, but keep the actual replacement representation. -async fn changed(follow: &mut announce::Follow) -> bool { +async fn changed(follow: &mut announce::Consumer) -> bool { loop { match follow.next().await.unwrap() { announce::Event::Restart(_) => return true, @@ -146,8 +146,12 @@ async fn replacement(version: &str) { .unwrap(); let viewer_origin = moq_tokio::origin::spawn(); let viewer = viewer_origin.consume(); - let mut catalog_follow = viewer.follow("live/catalog.hang").unwrap(); - let mut media_follow = viewer.follow("live/media").unwrap(); + let watch = |path| { + let path = moq_net::Patterns::from(moq_net::Pattern::literal(path).unwrap()); + viewer.scope("", &path).unwrap().announced() + }; + let mut catalog_follow = watch("live/catalog.hang"); + let mut media_follow = watch("live/media"); let viewer_client = client(version).with_subscriber(viewer_origin); let _viewer_connection = viewer_client .clone() @@ -158,7 +162,7 @@ async fn replacement(version: &str) { assert!(matches!(catalog_follow.next().await, Some(announce::Event::Start(_)))); assert!(matches!(media_follow.next().await, Some(announce::Event::Start(_)))); - let held = viewer.request_broadcast("live/catalog.hang", None).await.unwrap(); + let held = viewer.request("live/catalog.hang", None).await.unwrap(); let old = moq_mux::Source::new(viewer.clone(), held); let mut catalog = old.catalog::<()>(moq_mux::catalog::CatalogFormat::Hang).await.unwrap(); let snapshot = catalog.next().await.unwrap().unwrap(); @@ -249,10 +253,7 @@ async fn replacement(version: &str) { assert!(subscribed.is_err(), "retired handle subscribed to B's late track"); // Fresh catalog handles start fresh pins instead of sharing the old Source's cache. - let fresh = moq_mux::Source::new( - viewer.clone(), - viewer.request_broadcast("live/catalog.hang", None).await.unwrap(), - ); + let fresh = moq_mux::Source::new(viewer.clone(), viewer.request("live/catalog.hang", None).await.unwrap()); let mut fresh_catalog = fresh .catalog::<()>(moq_mux::catalog::CatalogFormat::Hang) .await @@ -279,7 +280,7 @@ async fn replacement(version: &str) { changed(&mut media_follow).await; }) .await; - let returned = viewer.request_broadcast("live/media", None).await.unwrap(); + let returned = viewer.request("live/media", None).await.unwrap(); let mut returned = returned.track("audio").unwrap().subscribe(None).await.unwrap(); write(&first.media, "A:3"); let returned_frame = read(&mut returned).await; diff --git a/rs/moq-cli/tests/integration/export.rs b/rs/moq-cli/tests/integration/export.rs index 287a88e50ef..975f5ed7304 100644 --- a/rs/moq-cli/tests/integration/export.rs +++ b/rs/moq-cli/tests/integration/export.rs @@ -557,7 +557,7 @@ async fn the_same_instance_within_the_follow_continues() { } export.output_past(0).await; assert!(split < LONG.len(), "the capture has a tail after the export joined"); - let old = relay.origin.request_broadcast("demo", None).await.unwrap(); + let old = relay.origin.request("demo", None).await.unwrap(); assert_eq!(old.info().epoch.as_ref(), Some(&epoch)); let clock = catalog.snapshot().clock; connection.abort(moq_net::Error::Cancel); @@ -567,7 +567,7 @@ async fn the_same_instance_within_the_follow_continues() { .expect("the relay observes the lost publication"); let mark = output.lock().unwrap().len().next_multiple_of(188); let connection = client.connect(url).established().await.unwrap(); - let back = tokio::time::timeout(TIMEOUT, relay.origin.routed_broadcast("demo")) + let back = tokio::time::timeout(TIMEOUT, relay.origin.follow("demo", None).unwrap().available()) .await .expect("the relay observes the returning publication") .unwrap(); @@ -1042,7 +1042,7 @@ async fn redundant_failover(bufferbloat: bool) { } /// The epoch of the next route announced for the path. -async fn next_epoch(announced: &mut moq_net::announce::Follow) -> moq_net::Epoch { +async fn next_epoch(announced: &mut moq_net::announce::Consumer) -> moq_net::Epoch { tokio::time::timeout(TIMEOUT, async { loop { match announced.next().await.expect("the relay stays up") { @@ -1063,7 +1063,8 @@ async fn next_epoch(announced: &mut moq_net::announce::Follow) -> moq_net::Epoch #[ignore = "real-time process test: just rs cli-export"] async fn a_passthrough_export_ends_with_its_redundant_importer() { let relay = relay().await; - let mut announced = relay.origin.follow("demo").unwrap(); + let demo = moq_net::Patterns::from(moq_net::Pattern::literal("demo").unwrap()); + let mut announced = relay.origin.scope("", &demo).unwrap().announced(); let (feed, feeding) = redundant_feed(); let mut first = redundant_import(&relay, &feed, &["--passthrough"]); let incumbent = next_epoch(&mut announced).await; diff --git a/rs/moq-cli/tests/integration/import.rs b/rs/moq-cli/tests/integration/import.rs index 6f584b9f9c4..d8a96d2ff78 100644 --- a/rs/moq-cli/tests/integration/import.rs +++ b/rs/moq-cli/tests/integration/import.rs @@ -92,7 +92,7 @@ async fn import_delivers_the_catalog_finish_at_eof() { panic!("the first announce event is {event:?}, not a start"); }; assert_eq!(announce.prefix.as_str(), "demo"); - let broadcast = running(&mut child, "the broadcast", consumer.request_broadcast("demo", None)) + let broadcast = running(&mut child, "the broadcast", consumer.request("demo", None)) .await .expect("announced broadcast resolves"); let mut catalogs = hang::catalog::Catalog::<()>::subscribe(&broadcast) @@ -167,7 +167,7 @@ async fn a_short_import_drains_its_media_to_a_waiting_subscriber() { running(&mut child, "the announce", announced.next()) .await .expect("origin closed"); - let broadcast = running(&mut child, "the broadcast", consumer.request_broadcast("demo", None)) + let broadcast = running(&mut child, "the broadcast", consumer.request("demo", None)) .await .expect("announced broadcast resolves"); let mut catalogs = running( diff --git a/rs/moq-cli/tests/integration/rtsp.rs b/rs/moq-cli/tests/integration/rtsp.rs index 6b1d23b8be8..c98c7cc0aba 100644 --- a/rs/moq-cli/tests/integration/rtsp.rs +++ b/rs/moq-cli/tests/integration/rtsp.rs @@ -67,7 +67,7 @@ async fn next_broadcast( moq_net::announce::Event::End(_) | moq_net::announce::Event::Update(_) => {} } } - let broadcast = running(child, "the broadcast", consumer.request_broadcast("camera", None)) + let broadcast = running(child, "the broadcast", consumer.request("camera", None)) .await .expect("announced broadcast resolves"); let mut catalogs = running( diff --git a/rs/moq-e2ee/tests/transport.rs b/rs/moq-e2ee/tests/transport.rs index 68d4ef00178..1f55abe297e 100644 --- a/rs/moq-e2ee/tests/transport.rs +++ b/rs/moq-e2ee/tests/transport.rs @@ -58,16 +58,19 @@ async fn connect_protected(version: Version, track: &str) -> Fixture { // The subscriber knows the opaque path and takes the epoch from the announced route. // A wire without epochs leaves it to the application's own channel. let consumer = consumer_origin.consume(); - let route = consumer.routed(&path).await.unwrap(); + let remote = consumer.follow(&path, None).unwrap().available().await.unwrap(); if version.to_string().starts_with("moq-lite-07") { assert_eq!( - route.epoch.as_ref(), + remote.info().epoch.as_ref(), Some(generation.epoch()), "lite-07 announces the epoch" ); } - let epoch = route.epoch.unwrap_or_else(|| generation.epoch().clone()); - let remote = consumer.request_broadcast(&path, None).await.unwrap(); + let epoch = remote + .info() + .epoch + .clone() + .unwrap_or_else(|| generation.epoch().clone()); let consumer = moq_e2ee::broadcast::Consumer::new(remote, cred.consume(epoch)) .subscribe( track, diff --git a/rs/moq-gst/src/source/imp.rs b/rs/moq-gst/src/source/imp.rs index 075ff496262..9b5c60f64e3 100644 --- a/rs/moq-gst/src/source/imp.rs +++ b/rs/moq-gst/src/source/imp.rs @@ -3433,7 +3433,7 @@ mod session_tests { } /// Block until the path's announcements report an event `wanted` accepts. - fn await_event(follow: &mut moq_net::announce::Follow, wanted: impl Fn(&moq_net::announce::Event) -> bool) { + fn await_event(follow: &mut moq_net::announce::Consumer, wanted: impl Fn(&moq_net::announce::Event) -> bool) { let next = async { while let Some(event) = follow.next().await { if wanted(&event) { @@ -3456,10 +3456,15 @@ mod session_tests { .expect("the demand never changed"); } - /// Follow `room` on `origin` past its start. A follower folds everything on hand while nothing - /// serves the path, so one first polled after the next change would never report it. - fn announced(origin: &moq_net::origin::Producer) -> moq_net::announce::Follow { - let mut follow = origin.consume().follow("room").unwrap(); + /// The announcements of the routes covering `path` on `origin`. + fn watch(origin: &moq_net::origin::Producer, path: &str) -> moq_net::announce::Consumer { + let path = moq_net::Patterns::from(moq_net::Pattern::literal(path).unwrap()); + origin.consume().scope("", &path).unwrap().announced() + } + + /// Follow `room` on `origin` past its start. + fn announced(origin: &moq_net::origin::Producer) -> moq_net::announce::Consumer { + let mut follow = watch(origin, "room"); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); follow } @@ -3590,7 +3595,7 @@ mod session_tests { let mut first = Publisher::sibling(&origin, Default::default()); let pad = recorder.written(&mut first, 1); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = watch(&origin, "cam"); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); drop(first); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::End(_))); @@ -3676,7 +3681,7 @@ mod session_tests { let origin = origin(); let _room = referencing(&origin, None); let session = follow(&element, &origin); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = watch(&origin, "cam"); let route = epoch(); let mut first = Publisher::sibling(&origin, route.clone()); @@ -3758,7 +3763,7 @@ mod session_tests { let mut first = Publisher::sibling(&origin, Default::default()); let pad = recorder.written(&mut first, 1); room.catalog.finish().unwrap(); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = watch(&origin, "cam"); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); drop(first); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::End(_))); @@ -4028,7 +4033,7 @@ mod session_tests { let mut second = Publisher::sibling(&origin, moq_net::origin::Route::default().with_epoch(other)); let unpinned = recorder.written(&mut second, 2); let pad = played.into_iter().find(|pad| *pad != unpinned).unwrap(); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = watch(&origin, "cam"); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); drop(second); await_event(&mut follow, |event| { @@ -4078,7 +4083,7 @@ mod session_tests { let mut first = Publisher::sibling(&origin, Default::default()); let pad = recorder.written(&mut first, 1); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = watch(&origin, "cam"); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); drop(first); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::End(_))); @@ -4120,7 +4125,7 @@ mod session_tests { let mut first = Publisher::sibling(&origin, Default::default()); let pad = recorder.written(&mut first, 1); - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = watch(&origin, "cam"); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); drop(first); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::End(_))); @@ -4201,7 +4206,7 @@ mod session_tests { // The reference lets the old instance go once another wins its path, and only then // does the new one leave, so the return is a resume rather than a missed restart. - let mut follow = origin.consume().follow("cam").unwrap(); + let mut follow = watch(&origin, "cam"); await_event(&mut follow, |event| matches!(event, moq_net::announce::Event::Start(_))); let mut new = Publisher::sibling(&origin, epoch()); await_event(&mut follow, |event| { diff --git a/rs/moq-hls/src/export/mod.rs b/rs/moq-hls/src/export/mod.rs index 9de11ac934c..9a71f1afdfe 100644 --- a/rs/moq-hls/src/export/mod.rs +++ b/rs/moq-hls/src/export/mod.rs @@ -2197,7 +2197,13 @@ mod tests { let audio_muxer = moq_mux::container::fmp4::Muxer::audio(snapshot.audio.renditions.values().next().unwrap()).unwrap(); let consuming = remote.as_ref().unwrap_or(&origin); - consuming.consume().routed("live").await.unwrap(); + consuming + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let source = crate::resolved(consuming, "live").await; let broadcaster = (!late).then(|| Broadcaster::new(source.clone(), Config::default())); for i in 0..20u64 { diff --git a/rs/moq-hls/src/lib.rs b/rs/moq-hls/src/lib.rs index be9fa4377e9..f4ed3152d02 100644 --- a/rs/moq-hls/src/lib.rs +++ b/rs/moq-hls/src/lib.rs @@ -42,9 +42,6 @@ pub use axum; #[cfg(test)] pub(crate) async fn resolved(origin: &moq_net::origin::Producer, path: &str) -> moq_mux::Source { let consumer = origin.consume(); - let broadcast = consumer - .request_broadcast(path, None) - .await - .expect("the broadcast resolves"); + let broadcast = consumer.request(path, None).await.expect("the broadcast resolves"); moq_mux::Source::new(consumer, broadcast) } diff --git a/rs/moq-hls/src/server/mod.rs b/rs/moq-hls/src/server/mod.rs index 39dc006b01d..3e3e4f50f7b 100644 --- a/rs/moq-hls/src/server/mod.rs +++ b/rs/moq-hls/src/server/mod.rs @@ -72,7 +72,8 @@ use moq_mux::follow; use crate::export::{Broadcaster, Config}; -/// How long to wait for the relay to say whether a requested broadcast is announced. +/// How long to wait for the route serving a requested broadcast to answer: a covering +/// dynamic route may never do so. const RESOLVE_TIMEOUT: Duration = Duration::from_secs(5); /// HLS export HTTP server. Cheap to clone (shared inner). @@ -205,28 +206,15 @@ impl Server { return Some(followed.clone()); } - // Confirm a route covers the broadcast (and it is in scope) before resolving it. The - // source resolves a rendition's sibling `broadcast` reference through the same origin. - // Once the origin has synced, a path with no route is not announced, so answer now - // rather than wait out a publisher that has gone. - let mut routes = self.inner.origin.follow(name).ok()?; - let routed = kio::wait(|waiter| match routes.poll_next(waiter) { - Poll::Ready(Some(moq_net::announce::Event::End(_)) | None) => Poll::Ready(false), - Poll::Ready(Some(_)) => Poll::Ready(true), - Poll::Pending => routes.poll_synced(waiter).map(|()| false), - }); - if !moq_clock::timeout(RESOLVE_TIMEOUT, routed).await.unwrap_or(false) { - return None; - } - - let mut instances = follow::Instances::new(&self.inner.origin, name, None) + let instances = follow::Instances::new(&self.inner.origin, name, None) .map_err(|err| tracing::warn!(%err, %name, "failed to follow broadcast")) .ok()?; - // A covering dynamic route may never answer, so the resolution is bounded too. - let broadcast = match moq_clock::timeout(RESOLVE_TIMEOUT, instances.next()).await { - Ok(Ok(follow::Event::Start(broadcast))) => broadcast, - // Nothing was handed out, so there is nothing to end. - Ok(Ok(follow::Event::End)) => return None, + // A request answers once the origin has synced with the relay, so a path with no route + // fails now rather than waiting out a publisher that has gone. The source resolves a + // rendition's sibling `broadcast` reference through the same origin. + let broadcast = match moq_clock::timeout(RESOLVE_TIMEOUT, self.inner.origin.request(name, None)).await { + Ok(Ok(broadcast)) => broadcast, + Ok(Err(moq_net::Error::Unroutable)) => return None, Ok(Err(err)) => { tracing::warn!(%err, %name, "failed to resolve broadcast"); return None; @@ -236,7 +224,7 @@ impl Server { return None; } }; - let followed = Arc::new(Followed::new(self.inner.serve(broadcast))); + let followed = Arc::new(Followed::new(self.inner.serve(broadcast.clone()))); { let mut broadcasts = self.inner.broadcasts.lock().unwrap(); @@ -256,6 +244,7 @@ impl Server { name.to_string(), Arc::downgrade(&followed), instances, + broadcast, )); *followed.task.lock().unwrap() = Some(task); Some(followed) @@ -272,8 +261,16 @@ impl Inner { /// Follow `name`'s instances into `followed` until nothing serves the path, then forget it, so the /// next request follows the path afresh. Holds both weakly, so it never keeps the server's state -/// alive; dropping `followed` aborts it. -async fn run_follow(inner: Weak, name: String, followed: Weak, mut instances: follow::Instances) { +/// alive; dropping `followed` aborts it. `served` is the instance `followed` starts on, which the +/// follower hands out first unless another took over since. +async fn run_follow( + inner: Weak, + name: String, + followed: Weak, + mut instances: follow::Instances, + served: moq_net::broadcast::Consumer, +) { + let mut served = Some(served); let (inner, followed) = loop { let next = kio::wait(|waiter| { let Some(followed) = followed.upgrade() else { @@ -287,7 +284,11 @@ async fn run_follow(inner: Weak, name: String, followed: Weak, return; }; match next { - Some(Ok(follow::Event::Start(broadcast))) => followed.start(inner.serve(broadcast)), + Some(Ok(follow::Event::Start(broadcast))) => { + if !served.take().is_some_and(|served| served.is_clone(&broadcast)) { + followed.start(inner.serve(broadcast)); + } + } Some(Ok(follow::Event::End)) => break (inner, followed), Some(Err(err)) => { tracing::warn!(%err, %name, "stopped following broadcast"); diff --git a/rs/moq-hls/tests/integration/server.rs b/rs/moq-hls/tests/integration/server.rs index 2063df6949a..083358e29a1 100644 --- a/rs/moq-hls/tests/integration/server.rs +++ b/rs/moq-hls/tests/integration/server.rs @@ -50,11 +50,7 @@ async fn a_cursor_records_a_publisher_without_fetch() { let mut publisher = Publisher::new(&pair.publisher, "live", Default::default()); let origin = pair.subscriber.consume(); - moq_clock::timeout(TIMEOUT, origin.routed("live")) - .await - .expect("announce timed out") - .expect("routed"); - let remote = moq_clock::timeout(TIMEOUT, origin.request_broadcast("live", None)) + let remote = moq_clock::timeout(TIMEOUT, origin.follow("live", None).unwrap().available()) .await .expect("request timed out") .expect("remote broadcast"); @@ -119,7 +115,7 @@ async fn a_disconnected_publisher_on_the_catalog_broadcast_answers_404() { let media = media_uri(&app, "live").await; let first = segment(&listed(&app, &media, ".0.m4s").await, 0); - let remote = moq_clock::timeout(TIMEOUT, pair.subscriber.consume().request_broadcast("live", None)) + let remote = moq_clock::timeout(TIMEOUT, pair.subscriber.consume().request("live", None)) .await .expect("remote resolve timed out") .expect("remote broadcast"); @@ -148,7 +144,7 @@ async fn lookups_ride_the_servers_scope_watch() { // Nothing watches `room/other` on its own, yet the synced lookup already discovered it. pair.subscriber .consume() - .request_broadcast("room/other", None) + .request("room/other", None) .await .expect("discovered through the scope watch"); } @@ -174,7 +170,7 @@ async fn a_sibling_resolves_through_a_client_session() { media.announce(Default::default()).expect("announce media"); let origin = pair.subscriber.consume(); - let broadcast = moq_clock::timeout(TIMEOUT, origin.routed_broadcast("room/live")) + let broadcast = moq_clock::timeout(TIMEOUT, origin.follow("room/live", None).unwrap().available()) .await .expect("catalog resolve timed out") .expect("catalog broadcast"); @@ -223,10 +219,17 @@ async fn a_disconnected_sibling_publisher_answers_404() { let first = segment(&listed(&app, &uri, ".0.m4s").await, 0); // Waited on rather than requested once: a client only asks about what it watches. - let remote_media = moq_clock::timeout(TIMEOUT, pair.subscriber.consume().routed_broadcast("room/source")) - .await - .expect("sibling resolve timed out") - .expect("sibling broadcast"); + let remote_media = moq_clock::timeout( + TIMEOUT, + pair.subscriber + .consume() + .follow("room/source", None) + .unwrap() + .available(), + ) + .await + .expect("sibling resolve timed out") + .expect("sibling broadcast"); // Only the sibling goes: the catalog keeps listing the rendition, so the request reaches the // media fetch rather than missing the rendition. media_broadcast.close(); diff --git a/rs/moq-mux/benches/containers.rs b/rs/moq-mux/benches/containers.rs index b844fd55ba2..2f598f66563 100644 --- a/rs/moq-mux/benches/containers.rs +++ b/rs/moq-mux/benches/containers.rs @@ -85,7 +85,7 @@ async fn prepare(video: Video, payload: &Bytes) -> (moq_mux::Source, impl Stream } catalog.finish().unwrap(); broadcast.announce(Default::default()).unwrap(); - let resolved = origin.consume().request_broadcast("bench", None).await.unwrap(); + let resolved = origin.consume().request("bench", None).await.unwrap(); let source = moq_mux::Source::new(origin.consume(), resolved); let stream = source.catalog::<()>(CatalogFormat::Hang).await.unwrap(); let fixture = Fixture { diff --git a/rs/moq-mux/benches/export.rs b/rs/moq-mux/benches/export.rs index dee27305ed1..b88e8435952 100644 --- a/rs/moq-mux/benches/export.rs +++ b/rs/moq-mux/benches/export.rs @@ -56,7 +56,7 @@ async fn prepare(tracks: usize, frames: usize) -> (moq_mux::Source, moq_mux::cat } catalog.finish().unwrap(); broadcast.announce(Default::default()).unwrap(); - let resolved = origin.consume().request_broadcast("bench", None).await.unwrap(); + let resolved = origin.consume().request("bench", None).await.unwrap(); let source = moq_mux::Source::new(origin.consume(), resolved); let fixture = Fixture { _published: Box::new((broadcast, catalog, publishers)), @@ -213,7 +213,7 @@ async fn prepare_video( video.finish().unwrap(); catalog.finish().unwrap(); broadcast.announce(Default::default()).unwrap(); - let resolved = origin.consume().request_broadcast("bench", None).await.unwrap(); + let resolved = origin.consume().request("bench", None).await.unwrap(); let source = moq_mux::Source::new(origin.consume(), resolved); ( source, diff --git a/rs/moq-mux/src/catalog/hang/consumer.rs b/rs/moq-mux/src/catalog/hang/consumer.rs index bd7cfb1e575..83a03846273 100644 --- a/rs/moq-mux/src/catalog/hang/consumer.rs +++ b/rs/moq-mux/src/catalog/hang/consumer.rs @@ -147,7 +147,7 @@ mod test { async fn publish_catalog_served(published: Catalog<()>) -> Result> { let origin = crate::source::produce_origin(); let dynamic = origin.requests("").unwrap(); - let requesting = origin.consume().request_broadcast("a/pub", None); + let requesting = origin.consume().request("a/pub", None); // The handler hands its route back: dropping it would retract the route and end // the broadcast it just served. let handler = tokio::spawn(async move { diff --git a/rs/moq-mux/src/container/consumer.rs b/rs/moq-mux/src/container/consumer.rs index f93bec2bf59..534940c5dc5 100644 --- a/rs/moq-mux/src/container/consumer.rs +++ b/rs/moq-mux/src/container/consumer.rs @@ -2591,7 +2591,7 @@ mod tests { let info = hang::container::track_info(hang::catalog::PRIORITY.video); let first_track = first.create_track("video", info.clone()).unwrap(); first.announce(route(5)).unwrap(); - let broadcast = origin.consume().request_broadcast("live", None).await.unwrap(); + let broadcast = origin.consume().request("live", None).await.unwrap(); let track = broadcast .track("video") .unwrap() diff --git a/rs/moq-mux/src/container/source.rs b/rs/moq-mux/src/container/source.rs index 2933f19c490..35a8c15ce74 100644 --- a/rs/moq-mux/src/container/source.rs +++ b/rs/moq-mux/src/container/source.rs @@ -1083,8 +1083,7 @@ mod tests { .unwrap(); broadcast.announce(Default::default()).unwrap(); let consumer = subscriber.consume(); - consumer.routed("room").await.unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + let remote = consumer.follow("room", None).unwrap().available().await.unwrap(); let source = crate::Source::new(consumer, remote); let mut export = ExportSource::for_audio(&source, "audio", &audio(None), Duration::from_secs(1)) .unwrap() @@ -1161,8 +1160,7 @@ mod tests { .unwrap(); broadcast.announce(Default::default()).unwrap(); let consumer = subscriber.consume(); - consumer.routed("room").await.unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + let remote = consumer.follow("room", None).unwrap().available().await.unwrap(); let source = crate::Source::new(consumer, remote); // MPEG-1 audio from TS: one 24 ms frame per group, a PES of five written at once. diff --git a/rs/moq-mux/src/container/ts/export_test.rs b/rs/moq-mux/src/container/ts/export_test.rs index a91df660ac4..38576a15883 100644 --- a/rs/moq-mux/src/container/ts/export_test.rs +++ b/rs/moq-mux/src/container/ts/export_test.rs @@ -8772,7 +8772,13 @@ async fn same_instance_returns(finish: bool) { tokio::time::sleep(Duration::from_secs(1)).await; let (broadcast, mut catalog) = publish_live::<()>(&origin, route()); std::ops::DerefMut::deref_mut(&mut catalog.modify().unwrap()); - let back = origin.consume().routed_broadcast("live").await.unwrap(); + let back = origin + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); let mut export = export.follow(back, stream).unwrap(); frames.extend(drain_frames(&mut export).await); @@ -8844,7 +8850,13 @@ async fn a_return_keeps_catalog_and_group_history() { crate::clock::fake_host_wall(wall + start.elapsed()); broadcast.announce(route).unwrap(); assert_eq!(catalog.snapshot().clock, clock, "a return must keep the catalog clock"); - let back = origin.consume().routed_broadcast("live").await.unwrap(); + let back = origin + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); assert_eq!(back.info().epoch.as_ref(), Some(&epoch)); assert!(!back.is_clone(&old), "the withdrawn front is replaced"); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); @@ -8892,7 +8904,7 @@ async fn a_switch_carries_through_an_instance_that_never_built_its_tables() { // Switched to an instance whose catalog lists nothing, so it never builds its tables... let (_bare, _bare_catalog) = publish_live::<()>(&origin, route()); - let bare = origin.consume().request_broadcast("live", None).await.unwrap(); + let bare = origin.consume().request("live", None).await.unwrap(); let stream = crate::catalog::Consumer::new(&bare, Default::default()).await.unwrap(); let mut export = export.follow(bare, stream).unwrap(); assert!( @@ -8903,7 +8915,7 @@ async fn a_switch_carries_through_an_instance_that_never_built_its_tables() { // ...and then to another. let (new, mut new_catalog) = publish_live::<()>(&origin, route()); let mut new_audio = aac_rendition(&mut new.broadcast().clone(), &mut new_catalog, "b.aac"); - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request("live", None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -8954,7 +8966,7 @@ async fn another_instance_is_a_full_program_switch() { let (new, mut new_catalog) = publish_live::<()>(&origin, route()); let mut video = h264_rendition(&mut new.broadcast().clone(), &mut new_catalog, "video.avc1"); let mut new_audio = aac_rendition(&mut new.broadcast().clone(), &mut new_catalog, "b.aac"); - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request("live", None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -9064,7 +9076,7 @@ async fn a_switch_moving_the_pmt_advances_the_pat() { let before = drain_frames(&mut export).await; let (_new, mut new_catalog, mut new_track) = publish(0x200); - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request("live", None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -9122,7 +9134,13 @@ async fn export_stats_count_only_returned_output() { drop((broadcast, catalog, track)); let (broadcast, mut catalog) = publish_live::<()>(&origin, route()); let mut track = aac_rendition(&mut broadcast.broadcast().clone(), &mut catalog, "a.aac"); - let back = origin.consume().routed_broadcast("live").await.unwrap(); + let back = origin + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); let mut export = export.follow(back, stream).unwrap(); for ms in (1_000..1_200).step_by(20) { @@ -10399,7 +10417,7 @@ async fn a_switch_reads_the_instance_it_followed() { for ms in (0..200).step_by(20) { write_aac(&mut followed_audio, ms); } - let broadcast = origin.consume().request_broadcast("live", None).await.unwrap(); + let broadcast = origin.consume().request("live", None).await.unwrap(); // Replaced again, ten seconds ahead, before the switched export requests its track. let (newer, mut newer_catalog) = publish_live::<()>(&origin, Default::default()); @@ -11100,7 +11118,13 @@ async fn a_track_renamed_on_its_pid_across_returns_retires_the_one_before() { for round in 1..=4 { tokio::time::sleep(Duration::from_secs(1)).await; let (broadcast, mut catalog) = publish_live::(&origin, route()); - let back = origin.consume().routed_broadcast("live").await.unwrap(); + let back = origin + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); export = export.follow(back, stream).unwrap(); drain_frames(&mut export).await; @@ -11160,7 +11184,13 @@ async fn a_track_renamed_on_its_pid_across_a_return_is_quiet_from_its_listing() tokio::time::sleep(Duration::from_secs(10)).await; let (broadcast, mut catalog) = publish_live::(&origin, route()); - let back = origin.consume().routed_broadcast("live").await.unwrap(); + let back = origin + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&back, Default::default()).await.unwrap(); let mut export = export.follow(back, stream).unwrap(); drain_frames(&mut export).await; @@ -11213,7 +11243,7 @@ async fn a_switch_follows_the_last_pmt_out() { let (new, mut new_catalog) = publish_live::(&origin, route()); let mut audio = aac_rendition(&mut new.broadcast().clone(), &mut new_catalog, "b.aac"); - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request("live", None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -11241,7 +11271,7 @@ async fn a_switch_past_an_instance_that_laid_no_tables_follows_the_last_pmt_out( let origin = crate::source::produce_origin(); let route = || moq_net::origin::Route::default().with_epoch(moq_net::Epoch::mint()); let follow = async |export: Export<_>| { - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request("live", None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -11314,7 +11344,7 @@ async fn a_stitched_switch_keeps_the_healthy_legs_held_frames() { assert!(held > 0, "the old healthy leg has future output buffered"); let (new, mut new_catalog) = publish_live::<()>(&origin, route()); let _new_audio = aac_rendition(&mut new.broadcast().clone(), &mut new_catalog, "a.aac"); - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request("live", None).await.unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -11501,7 +11531,13 @@ async fn an_expired_follow_stops_healthy_input_but_drains_its_buffered_tail() { if elapsed == selected { let (new, mut catalog) = publish_live::<()>(&origin, route()); let audio = aac_rendition(&mut new.broadcast().clone(), &mut catalog, "a.aac"); - let target = origin.consume().routed_broadcast("live").await.unwrap(); + let target = origin + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&target, Default::default()) .await .unwrap(); @@ -11584,7 +11620,13 @@ async fn a_replacement_leaving_before_it_commits_keeps_the_old_program() { if ms == 1000 { let (new, mut catalog) = publish_live::<()>(&origin, route()); let audio = aac_rendition(&mut new.broadcast().clone(), &mut catalog, "a.aac"); - let target = origin.consume().routed_broadcast("live").await.unwrap(); + let target = origin + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&target, Default::default()) .await .unwrap(); @@ -11644,7 +11686,7 @@ async fn a_newer_pending_instance_discards_the_unemitted_held_replacement() { for ms in (0..1000).step_by(20) { write_aac(&mut b_audio, 100_000 + ms); } - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request("live", None).await.unwrap(); let catalog = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -11658,7 +11700,7 @@ async fn a_newer_pending_instance_discards_the_unemitted_held_replacement() { for ms in (0..1000).step_by(20) { write_aac(&mut c_audio, 200_000 + ms); } - let replacement = origin.consume().request_broadcast("live", None).await.unwrap(); + let replacement = origin.consume().request("live", None).await.unwrap(); let catalog = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -11702,7 +11744,13 @@ async fn an_empty_finished_replacement_drains_the_old_program() { } let (_new, mut empty) = publish_live::<()>(&origin, route()); empty.finish().unwrap(); - let replacement = origin.consume().routed_broadcast("live").await.unwrap(); + let replacement = origin + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&replacement, Default::default()) .await .unwrap(); @@ -11754,7 +11802,13 @@ async fn cold_same_epoch_return(pending: bool) { video.finish().unwrap(); audio.finish().unwrap(); catalog.finish().unwrap(); - let target = origin.consume().routed_broadcast("live").await.unwrap(); + let target = origin + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&target, Default::default()) .await .unwrap(); @@ -11775,7 +11829,13 @@ async fn cold_same_epoch_return(pending: bool) { let (back, mut catalog) = publish_live::<()>(&origin, moq_net::origin::Route::default().with_epoch(returned_epoch)); let mut video = h264_rendition(&mut back.broadcast().clone(), &mut catalog, "v.avc1"); let mut audio = aac_rendition(&mut back.broadcast().clone(), &mut catalog, "a.aac"); - let target = origin.consume().routed_broadcast("live").await.unwrap(); + let target = origin + .consume() + .follow("live", None) + .unwrap() + .available() + .await + .unwrap(); let stream = crate::catalog::Consumer::new(&target, Default::default()) .await .unwrap(); diff --git a/rs/moq-mux/src/container/ts/programs.rs b/rs/moq-mux/src/container/ts/programs.rs index 05dbcaff1ca..e0400a15ec4 100644 --- a/rs/moq-mux/src/container/ts/programs.rs +++ b/rs/moq-mux/src/container/ts/programs.rs @@ -1222,7 +1222,7 @@ mod test { programs.finish().unwrap(); assert_eq!(programs.programs.len(), 1, "only program 50 has a PMT"); - let consumer = origin.consume().request_broadcast("event/50.hang", None).await.unwrap(); + let consumer = origin.consume().request("event/50.hang", None).await.unwrap(); let catalog = hang::catalog::Catalog::<()>::subscribe(&consumer) .await .unwrap() @@ -1262,7 +1262,7 @@ mod test { /// How many audio renditions the catalog `path` publishes lists. async fn renditions(origin: &moq_net::origin::Producer, path: &str) -> usize { - let consumer = origin.consume().request_broadcast(path, None).await.unwrap(); + let consumer = origin.consume().request(path, None).await.unwrap(); let catalog = hang::catalog::Catalog::<()>::subscribe(&consumer) .await .unwrap() @@ -1725,7 +1725,7 @@ mod test { let after = moq_clock::wall(); for (path, fills) in [("event/1.hang", [0xAA, 0xBB]), ("event/2.hang", [0xCC, 0xDD])] { - let consumer = origin.consume().request_broadcast(path, None).await.unwrap(); + let consumer = origin.consume().request(path, None).await.unwrap(); let catalog = hang::catalog::Catalog::<()>::subscribe(&consumer) .await .unwrap() diff --git a/rs/moq-mux/src/linger.rs b/rs/moq-mux/src/linger.rs index 804dc4f0ab6..f0cf35914a0 100644 --- a/rs/moq-mux/src/linger.rs +++ b/rs/moq-mux/src/linger.rs @@ -97,7 +97,7 @@ mod tests { /// Whether the origin has stopped routing [`PATH`]. async fn unroutable(origin: &moq_net::origin::Producer) -> bool { matches!( - origin.consume().request_broadcast(PATH, None).await, + origin.consume().request(PATH, None).await, Err(moq_net::Error::Unroutable) ) } @@ -112,7 +112,7 @@ mod tests { let linger = tokio::spawn(Linger::new([broadcast], track, Duration::from_secs(30)).wait()); moq_clock::sleep(Duration::from_secs(29)).await; - let late = origin.consume().request_broadcast(PATH, None).await.unwrap(); + let late = origin.consume().request(PATH, None).await.unwrap(); let video = late.track("video").unwrap(); for sequence in 0..3 { let mut group = video.fetch_group(sequence, None).await.unwrap(); diff --git a/rs/moq-mux/src/source.rs b/rs/moq-mux/src/source.rs index 4931b2bf422..131cd3a89f1 100644 --- a/rs/moq-mux/src/source.rs +++ b/rs/moq-mux/src/source.rs @@ -6,7 +6,7 @@ //! broadcast's own path and an [`moq_net::origin::Consumer`] to fetch the //! referenced broadcast from. [`Source`] bundles the two, and resolves every //! referenced broadcast through the same origin so -//! [`request_broadcast`](moq_net::origin::Consumer::request_broadcast) deduplicates +//! [`request`](moq_net::origin::Consumer::request) deduplicates //! shared subscriptions. use std::collections::HashMap; @@ -55,7 +55,7 @@ impl Source { /// `broadcast` is the catalog broadcast as resolved through `origin`: a rendition's relative /// `broadcast` reference resolves against its [path](moq_net::broadcast::Info::path), and the /// referenced broadcast is fetched via - /// [`origin.request_broadcast`](moq_net::origin::Consumer::request_broadcast), so it must be + /// [`origin.request`](moq_net::origin::Consumer::request), so it must be /// reachable through `origin` (by exact path, or served by a dynamic handler). A standalone /// broadcast has an empty path, so it is its own root and any `..` reference escapes. pub fn new(origin: moq_net::origin::Consumer, broadcast: moq_net::broadcast::Consumer) -> Self { @@ -140,20 +140,28 @@ impl Source { /// The broadcast `path` is pinned to, or a lookup that waits for the path's first /// announcement and pins its answer, either checked against `epoch` on every read. pub(crate) fn request_path(&self, path: &moq_net::Path, epoch: Option<&moq_net::Epoch>) -> Binding { - let bound = match self.pins.lock().expect("pins poisoned").get(path) { - Some(pinned) => Bound::Ready(pinned.clone()), + let pinned = self.pins.lock().expect("pins poisoned").get(path).cloned(); + let bound = match pinned { + Some(pinned) => Bound::Ready(pinned), // Unpinned even with an epoch: an epochless route still answers, best effort, and // the read refuses a route that proves another instance. - None => { - let mut routing = self.origin.routed_broadcast(path).into_inner(); + None => match self.origin.follow(path, None) { + Err(err) => Bound::Failed(err), // Issue the request now: a handler answers it whether or not anyone reads yet. - let _ = kio::Task::poll(&mut routing, &kio::Waiter::noop()); - Bound::Requested { - routing: Box::new(Mutex::new(routing)), - pins: self.pins.clone(), - path: path.clone(), - } - } + // The follower hands an instance out once, so an answer on hand is pinned here. + Ok(mut following) => match following.poll_available(&kio::Waiter::noop()) { + Poll::Ready(Ok(broadcast)) => { + let mut pins = self.pins.lock().expect("pins poisoned"); + Bound::Ready(pins.entry(path.clone()).or_insert(broadcast).clone()) + } + Poll::Ready(Err(err)) => Bound::Failed(err), + Poll::Pending => Bound::Requested { + following: Box::new(Mutex::new(following)), + pins: self.pins.clone(), + path: path.clone(), + }, + }, + }, }; Binding { bound, @@ -342,7 +350,7 @@ pub(crate) fn check_epoch( /// A held broadcast or the retained result of one eagerly issued broadcast request. /// /// A pending request waits for a path nothing announces yet and rides out route churn until it -/// resolves (see [`routed_broadcast`](moq_net::origin::Consumer::routed_broadcast)). Once the +/// resolves (see [`follow`](moq_net::origin::Consumer::follow)). Once the /// path is pinned, reading the binding answers that pin and never looks the path up again, even /// after its publisher is replaced or goes. Issuing a request does not establish an epoch /// relationship with a separate catalog broadcast. A binding made with an epoch refuses a @@ -360,9 +368,11 @@ pub struct Binding { enum Bound { /// A broadcast the caller already holds. Ready(moq_net::broadcast::Consumer), + /// A request that failed when the binding was made. + Failed(moq_net::Error), /// A request issued when the binding was made, resolved once something announces the path. Requested { - routing: Box>, + following: Box>, /// Where the answer is pinned, the first for its path winning. pins: Pins, path: moq_net::Path, @@ -390,16 +400,17 @@ impl Binding { pub fn poll_broadcast(&self, waiter: &kio::Waiter) -> Poll> { let broadcast = match &self.bound { Bound::Ready(broadcast) => broadcast.clone(), - Bound::Requested { routing, pins, path } => { + Bound::Failed(err) => return Poll::Ready(Err(err.clone().into())), + Bound::Requested { following, pins, path } => { // Once a path is pinned, its pin is the answer: a request that raced another for - // the path takes the one pinned first, and the routing is never polled again, since + // the path takes the one pinned first, and the follower is never polled again, since // it would wait out the gap after the pinned instance goes. if let Some(pinned) = pins.lock().expect("pins poisoned").get(path) { pinned.clone() } else { let broadcast = { - let mut routing = routing.lock().expect("routing poisoned"); - ready!(kio::Task::poll(&mut *routing, waiter))? + let mut following = following.lock().expect("following poisoned"); + ready!(following.poll_available(waiter))? }; // The path's first answer is pinned even when it fails this binding's epoch, so // no later reference resolves the path independently. @@ -437,10 +448,7 @@ pub(crate) fn produce_origin() -> moq_net::origin::Producer { #[cfg(test)] pub(crate) async fn resolved(origin: &moq_net::origin::Producer, path: &str) -> Source { let consumer = origin.consume(); - let broadcast = consumer - .request_broadcast(path, None) - .await - .expect("the broadcast resolves"); + let broadcast = consumer.request(path, None).await.expect("the broadcast resolves"); Source::new(consumer, broadcast) } @@ -547,7 +555,7 @@ mod tests { let _old = origin.publish("live", Default::default()).unwrap(); settle().await; let consumer = origin.consume(); - let first = consumer.request_broadcast("live", None).await.unwrap(); + let first = consumer.request("live", None).await.unwrap(); let new = origin.publish("live", Default::default()).unwrap(); let _late = new.create_track("late", None).unwrap(); @@ -577,7 +585,7 @@ mod tests { let timeout = std::time::Duration::from_secs(5); let consumer = subscriber.consume(); - let catalog = tokio::time::timeout(timeout, consumer.routed_broadcast("a/pub")) + let catalog = tokio::time::timeout(timeout, consumer.follow("a/pub", None).unwrap().available()) .await .expect("the catalog resolves") .unwrap(); diff --git a/rs/moq-net-tests/tests/integration/ietf_conformance.rs b/rs/moq-net-tests/tests/integration/ietf_conformance.rs index e458c15a3dd..7b7c8c27f2c 100644 --- a/rs/moq-net-tests/tests/integration/ietf_conformance.rs +++ b/rs/moq-net-tests/tests/integration/ietf_conformance.rs @@ -56,8 +56,13 @@ async fn routing(version: &str, cluster: bool) { options.client_subscribe = Some(reader.clone()); links.push(connect_mock(options).await); - reader.consume().routed(NAMESPACE).await.unwrap(); - let remote = reader.consume().request_broadcast(NAMESPACE, None).await.unwrap(); + let remote = reader + .consume() + .follow(NAMESPACE, None) + .unwrap() + .available() + .await + .unwrap(); let mut subscription = remote.track("test").unwrap().subscribe(None).await.unwrap(); crate::support::harness::subscribed(&track).await; let mut group = track.append_group().unwrap(); diff --git a/rs/moq-net-tests/tests/integration/refresh.rs b/rs/moq-net-tests/tests/integration/refresh.rs index 1ed4866c3e1..1f8a5931a86 100644 --- a/rs/moq-net-tests/tests/integration/refresh.rs +++ b/rs/moq-net-tests/tests/integration/refresh.rs @@ -42,8 +42,13 @@ async fn json_snapshot_refresh_crosses_a_two_relay_cluster() { options.client_subscribe = Some(downstream.clone()); links.push(connect_mock(options).await); } - reader.consume().routed("room").await.unwrap(); - let remote = reader.consume().request_broadcast("room", None).await.unwrap(); + let remote = reader + .consume() + .follow("room", None) + .unwrap() + .available() + .await + .unwrap(); let remote = remote.track("state").unwrap(); let mut baseline = remote.subscribe(None).await.unwrap(); assert_eq!(baseline.info().refresh, Some(ratio)); @@ -161,8 +166,7 @@ async fn ratio_joins_cross_two_relays() { options.client_subscribe = Some(downstream.clone()); links.push(connect_mock(options).await); } - b.consume().routed("room").await.unwrap(); - let remote = b.consume().request_broadcast("room", None).await.unwrap(); + let remote = b.consume().follow("room", None).unwrap().available().await.unwrap(); let remote = remote.track("data").unwrap(); let mut baseline = remote.subscribe(None).await.unwrap(); assert_eq!(baseline.info().refresh, (name == "moq-lite-07-wip").then_some(1)); diff --git a/rs/moq-net-tests/tests/integration/restart.rs b/rs/moq-net-tests/tests/integration/restart.rs index 3d86b8fc6e9..4b7684b3b83 100644 --- a/rs/moq-net-tests/tests/integration/restart.rs +++ b/rs/moq-net-tests/tests/integration/restart.rs @@ -103,7 +103,7 @@ async fn read(subscription: &mut track::Subscriber) -> String { } async fn subscribe(origin: &origin::Producer, path: &str) -> (broadcast::Consumer, track::Subscriber) { - let broadcast = origin.consume().request_broadcast(path, None).await.unwrap(); + let broadcast = origin.consume().request(path, None).await.unwrap(); let subscription = broadcast.track("video").unwrap().subscribe(None).await.unwrap(); (broadcast, subscription) } @@ -433,7 +433,7 @@ async fn dynamic_epoch_second_route_keeps_winning() { "dropping a shared epoch delivered {event:?}" ); } - let fresh = origin.consume().request_broadcast("live/cam", None).await.unwrap(); + let fresh = origin.consume().request("live/cam", None).await.unwrap(); assert!(fresh.is_clone(&resolved), "the epoch's broadcast was replaced"); assert_eq!((first.answered(), second.answered()), (1, 1)); // The same epoch serves the same bytes: group 0 was delivered, so it resumes at 1. @@ -686,7 +686,7 @@ impl Pool { /// subscription through it is reset once the exact route arrives: the cold-start reset /// accepted until announce takeover lands. async fn claimed(origin: &origin::Producer, path: &str) -> (broadcast::Consumer, track::Subscriber) { - let cold = origin.consume().request_broadcast(path, None).await.unwrap(); + let cold = origin.consume().request(path, None).await.unwrap(); drop(cold.track("video").unwrap().subscribe(None).await); settle().await; subscribe(origin, path).await diff --git a/rs/moq-relay/src/cluster.rs b/rs/moq-relay/src/cluster.rs index 495c46e907e..9309dd5b500 100644 --- a/rs/moq-relay/src/cluster.rs +++ b/rs/moq-relay/src/cluster.rs @@ -2423,7 +2423,7 @@ mod tests { .expect("publish at the fleet path"); let subscriber = cluster.subscriber(&token).expect("subscribe grant").consume(); let broadcast = subscriber - .request_broadcast(".svc/foo", None) + .request(".svc/foo", None) .await .expect("resolves through the mount"); assert_eq!(broadcast.info().path.as_str(), ".svc/foo"); @@ -2483,25 +2483,22 @@ mod tests { let path = moq_net::Path::from_static(".stats/node/test"); let consumer = cluster.origin.consume(); - let route = tokio::time::timeout(std::time::Duration::from_secs(5), consumer.routed(&path)) - .await - .expect("stats broadcast announced within 5s") - .expect("stats broadcast present"); - assert!(route.epoch.is_some(), "stats announce under an epoch"); - let broadcast = consumer - .request_broadcast(&path, None) - .await - .expect("stats broadcast resolves"); + let broadcast = tokio::time::timeout( + std::time::Duration::from_secs(5), + consumer.follow(&path, None).unwrap().available(), + ) + .await + .expect("stats broadcast announced within 5s") + .expect("stats broadcast resolves"); + assert!(broadcast.info().epoch.is_some(), "stats announce under an epoch"); // Several publish intervals (1s each by default) after the handle went out - // of scope, the task is still running and its broadcast still open. The - // re-check is bounded: without the keepalive the broadcast is gone and - // `routed` waits forever, which must read as a failure rather - // than a hung test. + // of scope, the task is still running and its broadcast still announced: a + // request refuses a front whose route retracted. tokio::time::sleep(std::time::Duration::from_millis(2500)).await; - let still_live = tokio::time::timeout(std::time::Duration::from_secs(2), consumer.routed(&path)).await; + let still_live = consumer.request(&path, None).await; assert!( - matches!(still_live, Ok(Some(_))), + still_live.is_ok(), "stats broadcast unannounced after the producer handle was dropped: \ the publish task stopped while the cluster kept serving" ); @@ -3088,16 +3085,19 @@ mod tests { assert!(pool.used() > 0, "writes charge the constructed cache pool"); let consumer = cluster.origin.consume(); - tokio::time::timeout(Duration::from_secs(2), consumer.request_broadcast("cam", None)) + tokio::time::timeout(Duration::from_secs(2), consumer.request("cam", None)) .await .expect("broadcast resolves") .expect("broadcast present"); let stats_path = moq_net::Path::from_static(".stats/node/test"); - tokio::time::timeout(Duration::from_secs(5), consumer.routed(&stats_path)) - .await - .expect("stats announced") - .expect("stats present"); + tokio::time::timeout( + Duration::from_secs(5), + consumer.follow(&stats_path, None).unwrap().available(), + ) + .await + .expect("stats announced") + .expect("stats present"); } /// The reserved `cluster.id` 0 is rejected, since it cannot be excluded for loop diff --git a/rs/moq-relay/src/internal.rs b/rs/moq-relay/src/internal.rs index 7c88c8420a8..a188743142a 100644 --- a/rs/moq-relay/src/internal.rs +++ b/rs/moq-relay/src/internal.rs @@ -1372,7 +1372,7 @@ mod tests { // egress bytes out of the default-tier broadcast. let (update, active) = next_update(&mut announced).await.unwrap(); assert!(active); - let bc = egress.request_broadcast(update.prefix.clone(), None).await.unwrap(); + let bc = egress.request(update.prefix.clone(), None).await.unwrap(); let mut egress_sub = bc.track("video").unwrap().subscribe(None).await.unwrap(); { let mut group = pub_track.append_group().unwrap(); diff --git a/rs/moq-relay/src/web.rs b/rs/moq-relay/src/web.rs index 92d78a7961c..b6878ad8c4b 100644 --- a/rs/moq-relay/src/web.rs +++ b/rs/moq-relay/src/web.rs @@ -1101,7 +1101,8 @@ async fn serve_fetch( // NOTE: The auth token is already scoped to the broadcast. // Block until a route covers the broadcast (within the fetch deadline) so // freshly-connected subscribers don't get a spurious 404 before the announce arrives. - let broadcast = origin.routed_broadcast("").await.map_err(|_| StatusCode::NOT_FOUND)?; + let mut following = origin.follow("", None).map_err(|_| StatusCode::NOT_FOUND)?; + let broadcast = following.available().await.map_err(|_| StatusCode::NOT_FOUND)?; let sequence = match params.group { FetchGroup::Num(sequence) => Some(sequence), FetchGroup::Latest => None, diff --git a/rs/moq-relay/tests/drills.rs b/rs/moq-relay/tests/drills.rs index 547b6fb0cd8..8fbc9e12d6f 100644 --- a/rs/moq-relay/tests/drills.rs +++ b/rs/moq-relay/tests/drills.rs @@ -414,9 +414,9 @@ struct Reader { /// Wait for `path` to be announced, then subscribe to [`TRACK`]. async fn subscribe(origin: &moq_net::origin::Consumer, path: &str) -> Reader { - // `routed_broadcast` parks until a route covers the path; `request_broadcast` - // would race the announcement and report a live broadcast as unroutable. - let broadcast = tokio::time::timeout(TIMEOUT, origin.routed_broadcast(path)) + // Following parks until a route covers the path, where a request could find the + // discovery synced before the announcement reaches this relay. + let broadcast = tokio::time::timeout(TIMEOUT, origin.follow(path, None).unwrap().available()) .await .expect("announcement timed out") .expect("origin closed before announcing"); @@ -1359,9 +1359,10 @@ async fn no_publisher_never_delivers(lane: Lane) { }; let mut announced = subscribed.announced(); + let mut following = subscribed.follow("live", None).unwrap(); let (update, resolved) = tokio::join!( tokio::time::timeout(quiet, next_update(&mut announced)), - tokio::time::timeout(quiet, subscribed.routed_broadcast("live")), + tokio::time::timeout(quiet, following.available()), ); if let Ok(update) = update { let path = update.map(|(update, _)| update.prefix.to_string()); @@ -1447,7 +1448,7 @@ async fn subscriber_max_age_skips_bufferbloat(version: &str) { .await .unwrap(); write_group(&mut track, b"warmup"); - let remote = tokio::time::timeout(TIMEOUT, consumed.routed_broadcast("live")) + let remote = tokio::time::timeout(TIMEOUT, consumed.follow("live", None).unwrap().available()) .await .unwrap() .unwrap(); diff --git a/rs/moq-relay/tests/integration/auth_lifetime.rs b/rs/moq-relay/tests/integration/auth_lifetime.rs index 5be27b6b924..24a1e590264 100644 --- a/rs/moq-relay/tests/integration/auth_lifetime.rs +++ b/rs/moq-relay/tests/integration/auth_lifetime.rs @@ -308,7 +308,7 @@ async fn connect_and_round_trip(url: &url::Url) -> (moq_tokio::Connection, moq_t assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); let bc = sub_consumer - .request_broadcast("test", None) + .request("test", None) .await .expect("announced broadcast resolves"); @@ -670,7 +670,7 @@ async fn a_moved_tier_retags_the_live_session() { assert_eq!(update.prefix.as_str(), "test"); assert!(announced, "expected announce, got retraction"); let bc = sub_consumer - .request_broadcast("test", None) + .request("test", None) .await .expect("announced broadcast resolves"); let mut track_sub = bc.track("video").unwrap().subscribe(None).await.expect("subscribe"); @@ -812,7 +812,7 @@ async fn a_rechecked_grant_resizes_live_sessions() { let mut subs = Vec::new(); for path in ["alice/audio", "alice/video"] { - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.routed_broadcast(path)) + let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.follow(path, None).unwrap().available()) .await .expect("announcement timeout") .expect("announced broadcast resolves"); @@ -875,7 +875,7 @@ async fn a_rechecked_grant_resizes_live_sessions() { // Undeafen: the path is announced again and a new subscription flows. script.on_revalidate(Answer::Grant(grant(Duration::from_secs(3600)))); - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.routed_broadcast("alice/audio")) + let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.follow("alice/audio", None).unwrap().available()) .await .expect("the undeafened path was never announced again") .expect("announced broadcast resolves"); @@ -1770,7 +1770,7 @@ async fn in_band_tokens_widen_and_withdraw_live_prefixes() { .await .unwrap() .unwrap(); - let a_read = tokio::time::timeout(TIMEOUT, read.routed_broadcast("a/cam")) + let a_read = tokio::time::timeout(TIMEOUT, read.follow("a/cam", None).unwrap().available()) .await .unwrap() .unwrap(); @@ -1782,7 +1782,7 @@ async fn in_band_tokens_widen_and_withdraw_live_prefixes() { .await .unwrap() .unwrap(); - let b_read = tokio::time::timeout(TIMEOUT, read.routed_broadcast("b/cam")) + let b_read = tokio::time::timeout(TIMEOUT, read.follow("b/cam", None).unwrap().available()) .await .expect("new prefix not announced") .unwrap(); diff --git a/rs/moq-relay/tests/integration/cluster_drain.rs b/rs/moq-relay/tests/integration/cluster_drain.rs index 30c4c1fd54d..c6cc69a93a3 100644 --- a/rs/moq-relay/tests/integration/cluster_drain.rs +++ b/rs/moq-relay/tests/integration/cluster_drain.rs @@ -162,10 +162,18 @@ async fn draining_relay_keeps_its_peers_until_it_restarts_inner() { let (c, _c_broadcast) = peer("c", &forward_c).await; // The mesh converges: each side learns the other's broadcasts. - within("A learns b", a.origin.consume().routed("b")).await; - within("C learns b", c.origin.consume().routed("b")).await; - within("B learns a", b_origin.consume().routed("a")).await; - within("B learns c", b_origin.consume().routed("c")).await; + within("A learns b", a.origin.consume().follow("b", None).unwrap().available()) + .await + .expect("resolves"); + within("C learns b", c.origin.consume().follow("b", None).unwrap().available()) + .await + .expect("resolves"); + within("B learns a", b_origin.consume().follow("a", None).unwrap().available()) + .await + .expect("resolves"); + within("B learns c", b_origin.consume().follow("c", None).unwrap().available()) + .await + .expect("resolves"); assert_eq!(forward_a.sessions(b_addr), 1); assert_eq!(forward_c.sessions(b_addr), 1); @@ -199,8 +207,18 @@ async fn draining_relay_keeps_its_peers_until_it_restarts_inner() { pass(&clock, STEP).await; waited += STEP; } - within("B' learns a", b2_origin.consume().routed("a")).await; - within("B' learns c", b2_origin.consume().routed("c")).await; + within( + "B' learns a", + b2_origin.consume().follow("a", None).unwrap().available(), + ) + .await + .expect("resolves"); + within( + "B' learns c", + b2_origin.consume().follow("c", None).unwrap().available(), + ) + .await + .expect("resolves"); // And reconnects exactly once. pass(&clock, Duration::from_secs(30)).await; diff --git a/rs/moq-relay/tests/integration/cluster_unknown.rs b/rs/moq-relay/tests/integration/cluster_unknown.rs index 54e2d990d50..a65512f8727 100644 --- a/rs/moq-relay/tests/integration/cluster_unknown.rs +++ b/rs/moq-relay/tests/integration/cluster_unknown.rs @@ -207,14 +207,12 @@ async fn read_first_frame(port: u16) -> Result, String> { .map_err(|err| format!("subscriber connect failed: {err}"))?; // Wait for the announcement rather than asking the moment the session connects: - // `request_broadcast` answers on the spot, so it would race the announcement that + // `request` answers on the spot, so it would race the announcement that // makes the path routable. - tokio::time::timeout(TIMEOUT, consumer.routed(PATH)) - .await - .map_err(|_| "routed timed out".to_string())? - .ok_or_else(|| "origin closed before the broadcast was announced".to_string())?; let broadcast = consumer - .request_broadcast(PATH, None) + .follow(PATH, None) + .unwrap() + .available() .await .map_err(|err| format!("broadcast unroutable: {err}"))?; diff --git a/rs/moq-relay/tests/integration/connection.rs b/rs/moq-relay/tests/integration/connection.rs index 0e9e537e165..8db97bc578e 100644 --- a/rs/moq-relay/tests/integration/connection.rs +++ b/rs/moq-relay/tests/integration/connection.rs @@ -40,11 +40,13 @@ async fn largest_quic_sequence_reaches_the_subscriber() { ) .await .unwrap(); - tokio::time::timeout(TIMEOUT, subscriber.consume().routed("ladder")) - .await + let remote = subscriber + .consume() + .follow("ladder", None) .unwrap() + .available() + .await .unwrap(); - let remote = subscriber.consume().request_broadcast("ladder", None).await.unwrap(); let mut sub = remote.track("data").unwrap().subscribe(None).await.unwrap(); for sequence in [5, 1 << 32, (1 << 53) - 1, (1 << 53) + 1, (1 << 62) - 1] { // Timestamps stop at 2^61 - 1, the most lite-05/06 can zigzag as a first frame. @@ -233,7 +235,7 @@ async fn the_setup_path_reaches_the_decider_and_roots_the_grant() { assert_eq!(next_active(&mut announced).await, "room/cam"); let broadcast = consumer - .request_broadcast("room/cam", None) + .request("room/cam", None) .await .expect("announced broadcast resolves"); let mut track = broadcast diff --git a/rs/moq-relay/tests/integration/embed.rs b/rs/moq-relay/tests/integration/embed.rs index c40d96800dc..dab7c2d84c1 100644 --- a/rs/moq-relay/tests/integration/embed.rs +++ b/rs/moq-relay/tests/integration/embed.rs @@ -293,7 +293,7 @@ async fn embed_and_stop(mut config: Config) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let announced = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let announced = tokio::time::timeout(TIMEOUT, consumer.request("test", None)) .await .expect("request timeout") .expect("announced broadcast resolves"); diff --git a/rs/moq-relay/tests/integration/goaway_cluster.rs b/rs/moq-relay/tests/integration/goaway_cluster.rs index f5fc86e0b3e..919bdf13384 100644 --- a/rs/moq-relay/tests/integration/goaway_cluster.rs +++ b/rs/moq-relay/tests/integration/goaway_cluster.rs @@ -171,9 +171,10 @@ async fn cluster_continues_a_group_split_by_goaway_inner() { let session_a = within("A accepts", accepted_a.recv()).await.expect("A accepts"); let consumer = cluster.origin.consume(); - within("routed via A", consumer.routed("cam")).await.expect("routed"); let bc = consumer - .request_broadcast("cam", None) + .follow("cam", None) + .unwrap() + .available() .await .expect("broadcast resolves"); let mut sub = within("subscribe", bc.track("video").expect("track").subscribe(None)) @@ -314,12 +315,10 @@ async fn cluster_migrates_on_upstream_goaway_inner() { // ── downstream consumer on the cluster origin ─────────────────── let consumer = cluster.origin.consume(); - consumer - .routed("cam") - .await - .expect("broadcast announced through sibling A"); let bc = consumer - .request_broadcast("cam", None) + .follow("cam", None) + .unwrap() + .available() .await .expect("broadcast resolves"); let mut sub = bc @@ -563,8 +562,7 @@ async fn cluster_diamond_goaway_seamless_failover_inner() { let bc = within("broadcast resolves on the subscriber origin", async { let consumer = sub_origin.consume(); - consumer.routed("diamond").await?; - consumer.request_broadcast("diamond", None).await.ok() + consumer.follow("diamond", None).unwrap().available().await.ok() }) .await .expect("broadcast announced"); diff --git a/rs/moq-relay/tests/integration/public_rules.rs b/rs/moq-relay/tests/integration/public_rules.rs index 4fda0621ca6..1136482ac5a 100644 --- a/rs/moq-relay/tests/integration/public_rules.rs +++ b/rs/moq-relay/tests/integration/public_rules.rs @@ -119,10 +119,7 @@ async fn first_broadcast(url: url::Url) -> String { .expect("announcement timeout"); let name = update.prefix.to_string(); - let broadcast = consumer - .request_broadcast(&name, None) - .await - .expect("broadcast resolves"); + let broadcast = consumer.request(&name, None).await.expect("broadcast resolves"); let mut track = broadcast .track("video") .unwrap() diff --git a/rs/moq-relay/tests/integration/refusals.rs b/rs/moq-relay/tests/integration/refusals.rs index 9db71a5a70f..725b79dcb0c 100644 --- a/rs/moq-relay/tests/integration/refusals.rs +++ b/rs/moq-relay/tests/integration/refusals.rs @@ -244,14 +244,13 @@ async fn refused_only_stats_depth_one_has_root_totals_and_shared_embedder_metric 1, "native admission counts exactly once" ); - tokio::time::timeout(TIMEOUT, relay.origin.routed(".stats/node/test")) - .await - .unwrap() - .unwrap(); - let broadcast = tokio::time::timeout(TIMEOUT, relay.origin.request_broadcast(".stats/node/test", None)) - .await - .unwrap() - .unwrap(); + let broadcast = tokio::time::timeout( + TIMEOUT, + relay.origin.follow(".stats/node/test", None).unwrap().available(), + ) + .await + .unwrap() + .unwrap(); let consumer = moq_stats::Consumer::new(broadcast, Default::default()); let mut totals = consumer.totals().await.unwrap(); tokio::time::timeout(TIMEOUT, async { @@ -301,11 +300,13 @@ async fn peer_zero_close_is_clean_and_application_close_counts_once() { config.stats.enabled = true; config.stats.node = Some("test".into()); let relay = start(config).await; - tokio::time::timeout(TIMEOUT, relay.origin.routed(".stats/node/test")) - .await + let broadcast = relay + .origin + .follow(".stats/node/test", None) .unwrap() + .available() + .await .unwrap(); - let broadcast = relay.origin.request_broadcast(".stats/node/test", None).await.unwrap(); let consumer = moq_stats::Consumer::new(broadcast, Default::default()); let mut totals = consumer.totals().await.unwrap(); for (index, error) in [moq_net::Error::Cancel, moq_net::Error::App(42)] diff --git a/rs/moq-relay/tests/integration/runtime_uring.rs b/rs/moq-relay/tests/integration/runtime_uring.rs index 32cdc6ad448..f2d4219afeb 100644 --- a/rs/moq-relay/tests/integration/runtime_uring.rs +++ b/rs/moq-relay/tests/integration/runtime_uring.rs @@ -162,7 +162,7 @@ async fn uring_workers_serve_webtransport_and_raw_quic() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request("test", None)) .await .unwrap_or_else(|_| panic!("subscriber {index} request timeout")) .expect("announced broadcast resolves"); @@ -267,7 +267,7 @@ async fn uring_workers_serve_every_configured_version() { // moq-lite-02 has no in-band path, so a raw QUIC session sits at the root. let path = update.prefix.as_str().to_owned(); assert!(active && path.ends_with("test"), "{scheme} {name}: announced {path}"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast(&path, None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request(&path, None)) .await .unwrap_or_else(|_| panic!("{scheme} {name}: request timeout")) .expect("announced broadcast resolves"); @@ -625,7 +625,7 @@ async fn an_mtls_client_authenticates_without_a_token() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let announced = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let announced = tokio::time::timeout(TIMEOUT, consumer.request("test", None)) .await .expect("request timeout") .expect("announced broadcast resolves"); diff --git a/rs/moq-relay/tests/integration/runtime_workers.rs b/rs/moq-relay/tests/integration/runtime_workers.rs index de40e7273f5..bc6d1178d57 100644 --- a/rs/moq-relay/tests/integration/runtime_workers.rs +++ b/rs/moq-relay/tests/integration/runtime_workers.rs @@ -117,7 +117,7 @@ async fn workers_serve_quic_and_share_one_origin() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request("test", None)) .await .unwrap_or_else(|_| panic!("subscriber {index} request timeout")) .expect("announced broadcast resolves"); diff --git a/rs/moq-relay/tests/integration/shutdown_signal.rs b/rs/moq-relay/tests/integration/shutdown_signal.rs index 7efa62bc93a..2dd9edf2a0d 100644 --- a/rs/moq-relay/tests/integration/shutdown_signal.rs +++ b/rs/moq-relay/tests/integration/shutdown_signal.rs @@ -481,8 +481,9 @@ async fn a_reconnecting_client_rides_out_a_restart_inner() { .established() .await .expect("connect"); + let mut following = consumer.follow("cam", None).unwrap(); tokio::select! { - res = consumer.routed_broadcast("cam") => { + res = following.available() => { res.expect("the publisher's broadcast never resolved"); } res = publisher.closed() => panic!("the publisher gave up during the restart: {res:?}"), diff --git a/rs/moq-relay/tests/integration/smoke.rs b/rs/moq-relay/tests/integration/smoke.rs index 8df533b45a6..1fc476eb172 100644 --- a/rs/moq-relay/tests/integration/smoke.rs +++ b/rs/moq-relay/tests/integration/smoke.rs @@ -194,7 +194,7 @@ async fn relay_websocket_round_trip_uses_newest_version() { // Auth root for `/smoke` is "smoke"; the broadcast "test" announces underneath. assert_eq!(path.as_str(), "test"); let bc = sub_consumer - .request_broadcast(&path, None) + .request(&path, None) .await .expect("announced broadcast resolves"); @@ -349,10 +349,7 @@ async fn hidden_broadcasts_need_a_lite07_opt_in() { if version == lite06 { continue; } - let bc = consumer - .request_broadcast(".x/y", None) - .await - .expect("hidden broadcast resolves"); + let bc = consumer.request(".x/y", None).await.expect("hidden broadcast resolves"); let mut sub = bc.track("video").unwrap().subscribe(None).await.expect("subscribe"); let mut group = tokio::time::timeout(TIMEOUT, sub.recv_group()) .await @@ -526,7 +523,7 @@ async fn relay_websocket_root_path_upgrades() { assert!(active, "expected announce, got retraction"); assert_eq!(path.as_str(), "test"); let bc = sub_consumer - .request_broadcast(&path, None) + .request(&path, None) .await .expect("announced broadcast resolves"); @@ -664,7 +661,7 @@ async fn internal_tcp_round_trip() { assert!(active, "expected announce, got retraction"); assert_eq!(path.as_str(), "test"); let bc = sub_consumer - .request_broadcast(&path, None) + .request(&path, None) .await .expect("announced broadcast resolves"); @@ -763,7 +760,7 @@ async fn internal_unix_round_trip() { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timeout") .expect("announced broadcast resolves"); diff --git a/rs/moq-relay/tests/integration/upstream_links.rs b/rs/moq-relay/tests/integration/upstream_links.rs index 88000ca2ac2..a0ec91899dc 100644 --- a/rs/moq-relay/tests/integration/upstream_links.rs +++ b/rs/moq-relay/tests/integration/upstream_links.rs @@ -172,9 +172,12 @@ fn publish(origin: &origin::Producer, path: &str) -> Publisher { /// Subscribe to `path` through `origin`'s routes and read one frame. async fn read_frame(origin: &origin::Producer, path: &str) { let consumer = origin.consume(); - let broadcast = within(&format!("route to {path}"), consumer.routed_broadcast(path)) - .await - .unwrap_or_else(|err| panic!("{path} unroutable: {err}")); + let broadcast = within( + &format!("route to {path}"), + consumer.follow(path, None).unwrap().available(), + ) + .await + .unwrap_or_else(|err| panic!("{path} unroutable: {err}")); let subscription = moq_net::track::Subscription::default().with_max_delay(Duration::from_secs(1)); let mut track = within( &format!("subscribe to {path}"), diff --git a/rs/moq-room/src/chat.rs b/rs/moq-room/src/chat.rs index 82b6c807e43..c9eaee01589 100644 --- a/rs/moq-room/src/chat.rs +++ b/rs/moq-room/src/chat.rs @@ -294,8 +294,7 @@ mod tests { let relay = origin(2); let _link = link(&publisher, &relay).await; let consumer = relay.consume(); - consumer.routed("room").await.unwrap(); - let remote = consumer.request_broadcast("room", None).await.unwrap(); + let remote = consumer.follow("room", None).unwrap().available().await.unwrap(); // A first reader warms the relay's copy with the first window. { diff --git a/rs/moq-room/src/room.rs b/rs/moq-room/src/room.rs index c2d7ca1486a..495e78c08e1 100644 --- a/rs/moq-room/src/room.rs +++ b/rs/moq-room/src/room.rs @@ -102,7 +102,7 @@ impl Room { })); } - let mut request = self.origin.request_broadcast(&path, None).into_inner(); + let mut request = self.origin.request(&path, None).into_inner(); match kio::Task::poll(&mut request, waiter) { Poll::Ready(Ok(broadcast)) => { return Poll::Ready(Some(Event { diff --git a/rs/moq-rtc/src/client/whip.rs b/rs/moq-rtc/src/client/whip.rs index 8ae87b9a814..c7993fa29ad 100644 --- a/rs/moq-rtc/src/client/whip.rs +++ b/rs/moq-rtc/src/client/whip.rs @@ -23,7 +23,7 @@ pub(crate) async fn dial( origin: moq_net::origin::Consumer, path: impl TryInto>, ) -> Result<()> { - let broadcast = origin.request_broadcast(path, None).await?; + let broadcast = origin.request(path, None).await?; let source = EgressSource::new(moq_mux::Source::new(origin, broadcast)).await?; let codecs = source.catalog_codecs(); if codecs.is_empty() { diff --git a/rs/moq-rtc/src/egress.rs b/rs/moq-rtc/src/egress.rs index 7806aab986e..dc451f77fd1 100644 --- a/rs/moq-rtc/src/egress.rs +++ b/rs/moq-rtc/src/egress.rs @@ -929,7 +929,7 @@ mod tests { }; point(&mut catalog, "a", None); - let broadcast = origin.consume().request_broadcast("live", None).await.unwrap(); + let broadcast = origin.consume().request("live", None).await.unwrap(); let mut egress = EgressSource::new(moq_mux::Source::new(origin.consume(), broadcast)) .await .unwrap(); diff --git a/rs/moq-rtc/src/lib.rs b/rs/moq-rtc/src/lib.rs index 6844e399e68..38edebfc3ad 100644 --- a/rs/moq-rtc/src/lib.rs +++ b/rs/moq-rtc/src/lib.rs @@ -284,11 +284,7 @@ mod tests { let source = origin.consume(); let pushed = tokio::spawn(async move { client.publish(url, source, "source").await }); let ingested = ingest_origin.consume(); - tokio::time::timeout(TIMEOUT, ingested.routed("ingested")) - .await - .expect("WHIP negotiation timed out") - .expect("the ingest origin closed"); - let ingested = ingested.request_broadcast("ingested", None).await.unwrap(); + let ingested = ingested.follow("ingested", None).unwrap().available().await.unwrap(); let mut played = opus_output(&ingested).await; assert_eq!(next_payload(&mut played).await, OPUS_PACKET); @@ -438,11 +434,7 @@ mod tests { .unwrap(); // The DELETE ended the ingest cleanly, so it serves the finished broadcast for the // linger; dropping the session, as an interrupt does, ends that at once. - let ingested = server_origin - .consume() - .request_broadcast("ingested", None) - .await - .unwrap(); + let ingested = server_origin.consume().request("ingested", None).await.unwrap(); assert!(!ingested.is_closed(), "the finished ingest lingers"); whip_task.abort(); let stopped = tokio::time::timeout(TIMEOUT, whip_task).await.unwrap(); diff --git a/rs/moq-rtc/src/server/whep.rs b/rs/moq-rtc/src/server/whep.rs index bbadda817fb..5acfe81b1cf 100644 --- a/rs/moq-rtc/src/server/whep.rs +++ b/rs/moq-rtc/src/server/whep.rs @@ -197,9 +197,9 @@ fn is_sdp(headers: &HeaderMap) -> bool { /// Resolve `path` on the subscribe origin and wait for its first catalog. /// -/// `routed_broadcast` watches the path while it resolves, which is what makes a lazily -/// discovering client session ask its peer about it; a plain request would be unroutable -/// there. The `Source` resolves any sibling broadcast a rendition's catalog `broadcast` field +/// Following the path watches it while it resolves, which is what makes a lazily +/// discovering client session ask its peer about it, and waits out a publisher that has not +/// announced yet. The `Source` resolves any sibling broadcast a rendition's catalog `broadcast` field /// references (e.g. `./source`) through the same origin. /// /// Both waits share one bound, or an unannounced broadcast, or an announced-but-catalog-less @@ -207,7 +207,8 @@ fn is_sdp(headers: &HeaderMap) -> bool { /// [`moq_net::Error::Unroutable`], so the WHEP client sees a 404 and retries (typical). async fn resolve(subscriber: &moq_net::origin::Consumer, path: moq_net::Path) -> Result { let deadline = moq_clock::now() + CATALOG_TIMEOUT; - let broadcast = moq_clock::timeout_at(deadline, subscriber.routed_broadcast(path)) + let mut following = subscriber.follow(path, None)?; + let broadcast = moq_clock::timeout_at(deadline, following.available()) .await .map_err(|_| Error::Moq(moq_net::Error::Unroutable))??; moq_clock::timeout_at( @@ -327,15 +328,18 @@ mod tests { let (sub_origin, _connection, accept) = lazy_client(pub_origin).await; let _router = super::router(crate::server::Server::new(Default::default()), sub_origin.consume()); - let missing = sub_origin.consume().follow("missing").expect("follow"); - moq_clock::timeout(TIMEOUT, missing.synced()) + let missing = moq_clock::timeout(TIMEOUT, sub_origin.consume().request("missing", None)) .await .expect("sync timed out"); + assert!( + matches!(missing, Err(moq_net::Error::Unroutable)), + "the missing path resolved" + ); // Nothing watches `other` on its own, yet the synced lookup already discovered it. sub_origin .consume() - .request_broadcast("other", None) + .request("other", None) .await .expect("discovered through the scope watch"); diff --git a/rs/moq-rtc/src/server/whip.rs b/rs/moq-rtc/src/server/whip.rs index 2c0835f67c5..608df548c60 100644 --- a/rs/moq-rtc/src/server/whip.rs +++ b/rs/moq-rtc/src/server/whip.rs @@ -231,7 +231,7 @@ mod tests { let session = accept(&server, &origin, moq_net::Path::from_static("live/cam0"), &offer()) .await .unwrap(); - let broadcast = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let broadcast = consumer.request("live/cam0", None).await.unwrap(); let mut catalog = broadcast .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -262,7 +262,7 @@ mod tests { let _stale_session = accept(&server, &origin, moq_net::Path::from_static("live/cam0"), &offer()) .await .unwrap(); - let stale = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let stale = consumer.request("live/cam0", None).await.unwrap(); let mut catalog = stale .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -284,7 +284,7 @@ mod tests { }) .await; assert!(stale_viewer.is_err(), "the stale viewer ended: {stale_viewer:?}"); - let fresh = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let fresh = consumer.request("live/cam0", None).await.unwrap(); assert!(!fresh.is_clone(&stale), "viewers reach the reconnected session"); } } diff --git a/rs/moq-rtmp/src/dial.rs b/rs/moq-rtmp/src/dial.rs index 1d9f2eb980c..1ed62a77a0d 100644 --- a/rs/moq-rtmp/src/dial.rs +++ b/rs/moq-rtmp/src/dial.rs @@ -257,7 +257,7 @@ impl Client { let queued = std::mem::take(&mut self.work); self.drain(queued).await?; - let broadcast = origin.request_broadcast(path, None).await?; + let broadcast = origin.request(path, None).await?; let source = moq_mux::Source::new(origin, broadcast); let catalog = source .catalog::<()>(moq_mux::catalog::CatalogFormat::default()) @@ -818,8 +818,7 @@ mod tests { }); let consumer = downstream.consume(); - consumer.routed("live/cam0").await.unwrap(); - let copy = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let copy = consumer.follow("live/cam0", None).unwrap().available().await.unwrap(); // The catalog goes out once the keyframe landed, so the copy holds media to linger with. let mut listed = copy.track("catalog.json").unwrap().subscribe(None).await.unwrap(); assert!(listed.recv_group().await.unwrap().is_some()); @@ -899,8 +898,7 @@ mod tests { // Read what reaches the remote back out as FLV. let consumer = downstream.consume(); - consumer.routed("live/cam0").await.unwrap(); - let copy = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let copy = consumer.follow("live/cam0", None).unwrap().available().await.unwrap(); let source = moq_mux::Source::new(consumer, copy); let catalog = source .catalog::<()>(moq_mux::catalog::CatalogFormat::default()) @@ -994,11 +992,12 @@ mod tests { }); // The republished broadcast should show up in the client's origin. - tokio::time::timeout(Duration::from_secs(5), announced.routed("pulled/cam0")) + let broadcast = announced + .follow("pulled/cam0", None) + .unwrap() + .available() .await - .expect("client republish timed out") - .expect("broadcast announced in client origin"); - let broadcast = announced.request_broadcast("pulled/cam0", None).await.unwrap(); + .unwrap(); // It should carry a hang catalog track (proof the FLV demux produced real // media on the far side): subscribe to it and read one catalog frame. diff --git a/rs/moq-rtmp/src/server.rs b/rs/moq-rtmp/src/server.rs index 65f256302da..0ceab89108b 100644 --- a/rs/moq-rtmp/src/server.rs +++ b/rs/moq-rtmp/src/server.rs @@ -812,6 +812,10 @@ impl Play { /// own task. pub async fn accept(mut self, origin: &origin::Consumer, path: impl Into) -> Result<()> { let path: moq_net::Path = path.into(); + let Ok(mut following) = origin.follow(&path, None) else { + tracing::debug!(peer = %self.peer, %path, "play broadcast unavailable"); + return self.reject("stream not found").await; + }; // Wait for the broadcast before telling the client playback started. Feed the // client's bytes through the session (not discard them) so its deserializer // stays in sync for everything `play_pump` parses next. @@ -822,7 +826,7 @@ impl Play { tracing::debug!(peer = %self.peer, %path, "viewer disconnected before play started"); return Ok(()); } - resolved = moq_clock::timeout(PLAY_RESOLVE_TIMEOUT, origin.routed_broadcast(&path)) => { + resolved = moq_clock::timeout(PLAY_RESOLVE_TIMEOUT, following.available()) => { match resolved { Ok(resolved) => resolved, Err(_) => { @@ -1874,10 +1878,7 @@ mod tests { let (client, server) = tokio::io::duplex(64 * 1024); let start = tokio::time::Instant::now(); let accept = tokio::spawn(accept_publish(server, origin.clone(), Duration::from_secs(10))); - let broadcast = async { - consumer.routed("live/cam0").await.unwrap(); - consumer.request_broadcast("live/cam0", None).await.unwrap() - }; + let broadcast = async { consumer.follow("live/cam0", None).unwrap().available().await.unwrap() }; let (broadcast, ()) = tokio::join!(broadcast, publish_one_keyframe(client, leave)); accept.await.unwrap(); @@ -1895,8 +1896,7 @@ mod tests { let (mut client, server) = tokio::io::duplex(64 * 1024); let accept = tokio::spawn(accept_publish(server, origin.clone(), Duration::ZERO)); let catalog = async { - consumer.routed("live/cam0").await.unwrap(); - let broadcast = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let broadcast = consumer.follow("live/cam0", None).unwrap().available().await.unwrap(); let track = broadcast.track(hang::Catalog::DEFAULT_NAME).unwrap(); track.subscribe(None).await.unwrap() }; @@ -1925,7 +1925,7 @@ mod tests { publish_one_keyframe(client, Leave::Unpublish).await; tokio::time::sleep(Duration::from_secs(5)).await; - let finished = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let finished = consumer.request("live/cam0", None).await.unwrap(); let mut video = finished.track("0.flv-v").unwrap().subscribe(None).await.unwrap(); assert!( video.recv_group().await.unwrap().is_some(), @@ -2206,8 +2206,7 @@ mod tests { publisher.push(flv::TAG_VIDEO, 0, &vseq).unwrap(); let consumer = origin.consume(); - consumer.routed("live/cam0").await.unwrap(); - let broadcast = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let broadcast = consumer.follow("live/cam0", None).unwrap().available().await.unwrap(); let info = broadcast.track("0.flv-v").unwrap().info().await.unwrap(); assert_eq!(info.max_age, Some(Duration::from_secs(3))); } @@ -2797,11 +2796,7 @@ mod tests { let stale_client = tokio::spawn(async move { run_client(TcpStream::connect(addr).await.unwrap(), ClientMode::Publish).await; }); - tokio::time::timeout(Duration::from_secs(5), consumer.routed("live/cam0")) - .await - .expect("stale publish timed out") - .unwrap(); - let stale = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let stale = consumer.follow("live/cam0", None).unwrap().available().await.unwrap(); let mut catalog = stale .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -2831,7 +2826,7 @@ mod tests { assert!(stale_viewer.is_err(), "the stale viewer ended: {stale_viewer:?}"); assert!(!stale_client.is_finished(), "the stale connection is still open"); - let fresh = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let fresh = consumer.request("live/cam0", None).await.unwrap(); assert!(!fresh.is_clone(&stale), "viewers reach the reconnected publish"); stale_client.abort(); diff --git a/rs/moq-srt/src/ts.rs b/rs/moq-srt/src/ts.rs index 9424d837955..79e38e0cc0b 100644 --- a/rs/moq-srt/src/ts.rs +++ b/rs/moq-srt/src/ts.rs @@ -216,13 +216,17 @@ impl Subscriber { /// consumer's scope, or the origin closed). Otherwise waits for the broadcast /// to be announced, so a caller may connect before the publisher does. pub(crate) async fn new(origin: &origin::Consumer, path: &str, options: Options) -> Result> { - if origin.routed(path).await.is_none() { + let Ok(mut following) = origin.follow(path, None) else { return Ok(None); - } + }; - // Join the broadcast just announced. The export resolves any referenced sibling + // Join the broadcast once announced. The export resolves any referenced sibling // broadcast (the catalog `broadcast` field) through the same origin. - let broadcast = origin.request_broadcast(path, None).await?; + let broadcast = match following.available().await { + Ok(broadcast) => broadcast, + Err(moq_net::Error::Closed) => return Ok(None), + Err(err) => return Err(err.into()), + }; let source = moq_mux::Source::new(origin.clone(), broadcast); let catalog = source.catalog::(moq_mux::catalog::CatalogFormat::Hang).await?; let export = ts::Export::new(source, catalog).with_delay(options.latency.max(MIN_DELAY)); @@ -478,11 +482,7 @@ mod tests { /// announced. async fn program(origin: &moq_net::origin::Producer, path: &str) -> (u16, Vec) { let consumer = origin.consume(); - timeout(Duration::from_secs(5), consumer.routed(path)) - .await - .expect("announce timed out") - .expect("the broadcast is announced"); - let broadcast = consumer.request_broadcast(path, None).await.unwrap(); + let broadcast = consumer.follow(path, None).unwrap().available().await.unwrap(); let mut catalog = moq_mux::catalog::Consumer::::new(&broadcast, CatalogFormat::Hang) .await .unwrap(); @@ -518,7 +518,7 @@ mod tests { let origin = produce_origin(); let consumer = origin.consume(); let _stale = Publisher::new(&origin, "ingest", Default::default(), None).unwrap(); - let stale = consumer.request_broadcast("ingest", None).await.unwrap(); + let stale = consumer.request("ingest", None).await.unwrap(); let mut catalog = stale .track(hang::Catalog::DEFAULT_NAME) .unwrap() @@ -537,7 +537,7 @@ mod tests { }) .await; assert!(stale_viewer.is_err(), "the stale viewer ended: {stale_viewer:?}"); - let fresh = consumer.request_broadcast("ingest", None).await.unwrap(); + let fresh = consumer.request("ingest", None).await.unwrap(); assert!(!fresh.is_clone(&stale), "viewers reach the reconnected caller"); } @@ -559,9 +559,10 @@ mod tests { assert_eq!(program(&origin, "ingest/1").await, (1, vec![0x0101])); assert_eq!(program(&origin, "ingest/2").await, (2, vec![0x0201])); assert!( - timeout(Duration::from_secs(1), origin.consume().routed("ingest")) - .await - .is_err(), + matches!( + origin.consume().request("ingest", None).await, + Err(moq_net::Error::Unroutable) + ), "nothing is published on the bare path" ); drop(publisher.finish(Duration::ZERO).unwrap()); @@ -577,8 +578,7 @@ mod tests { publisher.feed(Bytes::from_static(BBB5S)).unwrap(); let consumer = origin.consume(); - consumer.routed("live/cam0").await.unwrap(); - let broadcast = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let broadcast = consumer.follow("live/cam0", None).unwrap().available().await.unwrap(); let start = tokio::time::Instant::now(); let wait = tokio::spawn(publisher.finish(linger).unwrap().wait()); tokio::time::sleep(linger / 2).await; @@ -611,8 +611,7 @@ mod tests { publisher.feed(Bytes::from(ts)).unwrap(); let consumer = origin.consume(); - consumer.routed("live/cam0").await.unwrap(); - let broadcast = consumer.request_broadcast("live/cam0", None).await.unwrap(); + let broadcast = consumer.follow("live/cam0", None).unwrap().available().await.unwrap(); let info = broadcast.track("0.avc3").unwrap().info().await.unwrap(); assert_eq!(info.max_age, Some(Duration::from_secs(3))); } @@ -658,11 +657,7 @@ mod tests { let mut publisher = Publisher::new(&origin, "ingest", Default::default(), None).unwrap(); let consumer = origin.consume(); - timeout(Duration::from_secs(5), consumer.routed("ingest")) - .await - .expect("announce timed out") - .expect("the ingest broadcast is announced"); - let broadcast = consumer.request_broadcast("ingest", None).await.unwrap(); + let broadcast = consumer.follow("ingest", None).unwrap().available().await.unwrap(); publisher.feed(bytes::Bytes::from_static(BBB5S)).unwrap(); diff --git a/rs/moq-stats/src/aggregate.rs b/rs/moq-stats/src/aggregate.rs index 21df5a506c3..a72635086fa 100644 --- a/rs/moq-stats/src/aggregate.rs +++ b/rs/moq-stats/src/aggregate.rs @@ -1132,7 +1132,7 @@ fn advance( /// Start resolving `path` (relative to the announce cursor) into a broadcast. fn resolve(origin: &origin::Consumer, path: &Path, epoch: Option) -> Reader { - let pending = origin.request_broadcast(path, epoch); + let pending = origin.request(path, epoch); Reader::Resolving(Box::new(pending)) } @@ -1292,7 +1292,7 @@ mod tests { let (_, active) = next_update(&mut announced).await.expect("announce"); assert!(active); - let consumer = egress.request_broadcast(path, None).await.expect("resolve"); + let consumer = egress.request(path, None).await.expect("resolve"); let mut sub = consumer.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); @@ -1711,7 +1711,7 @@ mod tests { .announce(origin::Route::default().with_epoch(epoch_b.clone())) .unwrap(); new.publish("acme/room", 30); - let mut pending = origin.consume().request_broadcast(".stats/node/a", None); + let mut pending = origin.consume().request(".stats/node/a", None); let front = futures::executor::block_on(kio::wait(|waiter| { driver.poll(now, waiter).unwrap(); pending.poll_ok(waiter) diff --git a/rs/moq-stats/src/consume.rs b/rs/moq-stats/src/consume.rs index e01d5bcfd8c..9c6f81d5e58 100644 --- a/rs/moq-stats/src/consume.rs +++ b/rs/moq-stats/src/consume.rs @@ -224,7 +224,7 @@ mod tests { let (_, active) = next_update(&mut announced).await.expect("announce"); assert!(active); - let consumer = egress.request_broadcast(path, None).await.expect("resolve"); + let consumer = egress.request(path, None).await.expect("resolve"); let sub = consumer.track("video").unwrap().subscribe(None).await.unwrap(); Feed { @@ -241,11 +241,7 @@ mod tests { tokio::time::advance(Duration::from_millis(1)).await; let (update, active) = next_update(&mut consumer).await.expect("expected announce"); assert!(active); - origin - .consume() - .request_broadcast(&update.prefix, None) - .await - .expect("resolve") + origin.consume().request(&update.prefix, None).await.expect("resolve") } async fn drive_tick() { diff --git a/rs/moq-stats/src/produce.rs b/rs/moq-stats/src/produce.rs index 3af8f2ba158..3417359f932 100644 --- a/rs/moq-stats/src/produce.rs +++ b/rs/moq-stats/src/produce.rs @@ -1444,7 +1444,7 @@ mod tests { let (route, active) = next_update(&mut events).await.unwrap(); assert!(active); assert_eq!(route.prefix.as_str(), ".stats/node"); - let broadcast = consumer.request_broadcast(".stats/node", None).await.unwrap(); + let broadcast = consumer.request(".stats/node", None).await.unwrap(); let name = presence_track(moq_net::Path::from_static("room")); let mut previous = None; for (reading, delta) in [(40, 11), (1_000, 7)] { @@ -1651,7 +1651,7 @@ mod tests { let (_, active) = next_update(&mut announced).await.expect("announce"); assert!(active); - let consumer = egress.request_broadcast(path, None).await.expect("resolve"); + let consumer = egress.request(path, None).await.expect("resolve"); let sub = if subscribe { let mut sub = consumer @@ -1692,11 +1692,7 @@ mod tests { tokio::time::advance(Duration::from_millis(1)).await; let (update, active) = next_update(&mut consumer).await.expect("expected announce"); assert!(active); - let broadcast = origin - .consume() - .request_broadcast(&update.prefix, None) - .await - .expect("resolve"); + let broadcast = origin.consume().request(&update.prefix, None).await.expect("resolve"); (update.prefix.as_str().to_string(), broadcast) } @@ -1852,7 +1848,7 @@ mod tests { step(0).await; let broadcast = origin .consume() - .request_broadcast(".stats/node/sjc", None) + .request(".stats/node/sjc", None) .await .expect("resolve"); let mut totals = reader::(&broadcast, crate::TOTALS).await; @@ -1949,11 +1945,7 @@ mod tests { let [(path, true, before)] = &take_epochs(&mut events)[..] else { panic!("expected one announce"); }; - let stats = origin - .consume() - .request_broadcast(path.as_str(), None) - .await - .expect("resolve"); + let stats = origin.consume().request(path.as_str(), None).await.expect("resolve"); let mut old = subscribe(&stats, &crate::group_track(moq_net::Path::from_static(""))).await; while try_next_frame(&mut old).is_some() {} @@ -1967,11 +1959,7 @@ mod tests { assert!(after > before); drop(old); - let stats = origin - .consume() - .request_broadcast(path.as_str(), None) - .await - .expect("resolve"); + let stats = origin.consume().request(path.as_str(), None).await.expect("resolve"); assert_eq!(read_egress(&stats).await["foo/bar"].bytes, 30); } @@ -2085,7 +2073,7 @@ mod tests { ); async fn view(egress: &origin::Consumer, video: &mut track::Producer, size: usize) { - let broadcast = egress.request_broadcast("foo/bar", None).await.expect("resolve"); + let broadcast = egress.request("foo/bar", None).await.expect("resolve"); let mut sub = broadcast .track("video") .expect("track") @@ -2368,11 +2356,7 @@ mod tests { drain.publish(moq_clock::now()); drain.node.presence.len() }; - let broadcast = origin - .consume() - .request_broadcast(".stats/node", None) - .await - .expect("resolve"); + let broadcast = origin.consume().request(".stats/node", None).await.expect("resolve"); // Let the request reach the stats broadcast's queue before the drain. let subscribing = broadcast @@ -2538,7 +2522,7 @@ mod tests { .tier(Tier::default()) .session(moq_net::Path::from_static("viewer")), ); - let broadcast = egress.request_broadcast("acme/live", None).await.expect("resolve"); + let broadcast = egress.request("acme/live", None).await.expect("resolve"); let mut subs = Vec::new(); for _ in 0..300 { let track = broadcast.track("video").expect("track"); @@ -2627,11 +2611,7 @@ mod tests { drain.publish(moq_clock::now()); drain.node.prefixes.len() }; - let broadcast = origin - .consume() - .request_broadcast(".stats/node", None) - .await - .expect("resolve"); + let broadcast = origin.consume().request(".stats/node", None).await.expect("resolve"); let subscribing = broadcast .track(&prefix_track(moq_net::Path::from_static("acme"))) @@ -2953,7 +2933,7 @@ mod tests { let (route, active) = next_update(&mut announced).await.unwrap(); assert!(active); assert_eq!(route.prefix.as_str(), ".stats/node"); - let broadcast = consumer.request_broadcast(".stats/node", None).await.unwrap(); + let broadcast = consumer.request(".stats/node", None).await.unwrap(); let mut tracks = broadcast.tracks().unwrap(); assert_eq!(next_listed(&mut drain, start, &mut tracks).await, ("acme".into(), true)); diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs index 47797713f58..f0e2b2bb93b 100644 --- a/rs/moq-studio/src/engine.rs +++ b/rs/moq-studio/src/engine.rs @@ -632,7 +632,7 @@ mod tests { .await .expect("the studio starts"); - let broadcast = tokio::time::timeout(TIMEOUT, relay.routed_broadcast("studio")) + let broadcast = tokio::time::timeout(TIMEOUT, relay.follow("studio", None).unwrap().available()) .await .expect("the relay routes the program") .expect("broadcast"); diff --git a/rs/moq-tokio/examples/clock.rs b/rs/moq-tokio/examples/clock.rs index 62dce53dabf..bd33b4f191c 100644 --- a/rs/moq-tokio/examples/clock.rs +++ b/rs/moq-tokio/examples/clock.rs @@ -114,7 +114,7 @@ async fn main() -> anyhow::Result<()> { // A restart is a new broadcast: subscribe to it afresh. announce::Event::Start(update) | announce::Event::Update(update) | announce::Event::Restart(update) => { tracing::info!(broadcast = %update.prefix, "broadcast is online, subscribing to track"); - let broadcast = consumer.request_broadcast(&update.prefix, None).await?; + let broadcast = consumer.request(&update.prefix, None).await?; let track = broadcast .track(&track)?.subscribe(None).await?; clock = Some(Subscriber::new(track)); diff --git a/rs/moq-tokio/src/client.rs b/rs/moq-tokio/src/client.rs index a662d46bc48..b032dbf51bd 100644 --- a/rs/moq-tokio/src/client.rs +++ b/rs/moq-tokio/src/client.rs @@ -1217,10 +1217,7 @@ mod tests { event => panic!("expected announcement, got {event:?}"), }; assert_eq!(update.prefix.as_str(), "test"); - let broadcast = sub_consumer - .request_broadcast("test", None) - .await - .expect("broadcast resolves"); + let broadcast = sub_consumer.request("test", None).await.expect("broadcast resolves"); let mut track = broadcast .track("video") .unwrap() diff --git a/rs/moq-tokio/src/connection.rs b/rs/moq-tokio/src/connection.rs index 3cd5b0ffb8b..1b3be3b2420 100644 --- a/rs/moq-tokio/src/connection.rs +++ b/rs/moq-tokio/src/connection.rs @@ -3340,7 +3340,7 @@ mod tests { let session_a = tokio::time::timeout(WAIT, accepted_a.recv()).await.unwrap().unwrap(); let consumer = subscriber.consume(); - let cam = tokio::time::timeout(WAIT, consumer.routed_broadcast("cam")) + let cam = tokio::time::timeout(WAIT, consumer.follow("cam", None).unwrap().available()) .await .unwrap() .unwrap(); @@ -3423,7 +3423,7 @@ mod tests { // A broadcast announced after the GOAWAY still arrives: the drained session serves. let late = origin.create_broadcast("late").unwrap(); late.announce(Default::default()).unwrap(); - tokio::time::timeout(WAIT, subscriber.consume().routed("late")) + tokio::time::timeout(WAIT, subscriber.consume().follow("late", None).unwrap().available()) .await .expect("the drained session stopped serving") .unwrap(); diff --git a/rs/moq-tokio/src/server.rs b/rs/moq-tokio/src/server.rs index 2c1589881d7..ad1f666a71e 100644 --- a/rs/moq-tokio/src/server.rs +++ b/rs/moq-tokio/src/server.rs @@ -2772,7 +2772,7 @@ mod tests { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active); - let broadcast = consumer.request_broadcast("test", None).await.expect("resolve"); + let broadcast = consumer.request("test", None).await.expect("resolve"); let mut track = broadcast .track("video") diff --git a/rs/moq-tokio/src/webrtc/tests.rs b/rs/moq-tokio/src/webrtc/tests.rs index 00c4ac0e4cc..3c46e3c1d9e 100644 --- a/rs/moq-tokio/src/webrtc/tests.rs +++ b/rs/moq-tokio/src/webrtc/tests.rs @@ -64,7 +64,7 @@ async fn transfer(offerer: &Offerer, answerer: &Answerer, payload: &[u8]) { panic!("expected the broadcast to be announced"); }; assert_eq!(route.prefix.as_str(), "test"); - let broadcast = consumer.request_broadcast("test", None).await.unwrap(); + let broadcast = consumer.request("test", None).await.unwrap(); let mut track = broadcast.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.recv_group().await.unwrap().unwrap(); group.read_frame().await.unwrap().unwrap() diff --git a/rs/moq-tokio/tests/integration/backend.rs b/rs/moq-tokio/tests/integration/backend.rs index d78a202392a..cc3f9ca6882 100644 --- a/rs/moq-tokio/tests/integration/backend.rs +++ b/rs/moq-tokio/tests/integration/backend.rs @@ -189,7 +189,7 @@ async fn connect_test(config: ConnectTest<'_>) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -703,7 +703,7 @@ async fn iroh_connect_test(version: Option<&str>) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -899,7 +899,7 @@ async fn quic_client_close_drains_finished_track() { .await .expect("announce timed out") .expect("origin closed"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request("test", None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -1023,7 +1023,7 @@ async fn quic_client_close_drains_migrated_predecessor() { .await .expect("announce timed out") .expect("origin closed"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request("test", None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -1160,7 +1160,7 @@ async fn quic_client_close_keeps_predecessor_handover() { .await .expect("announce timed out") .expect("origin closed"); - let broadcast = tokio::time::timeout(TIMEOUT, consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, consumer.request("test", None)) .await .expect("request timed out") .expect("announced broadcast resolves"); diff --git a/rs/moq-tokio/tests/integration/broadcast.rs b/rs/moq-tokio/tests/integration/broadcast.rs index d6cbe68f8ef..a55e77baf86 100644 --- a/rs/moq-tokio/tests/integration/broadcast.rs +++ b/rs/moq-tokio/tests/integration/broadcast.rs @@ -97,7 +97,7 @@ async fn broadcast_test(scheme: &str, client_version: Option<&str>, server_versi assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -206,7 +206,7 @@ async fn lite05_timestamp_roundtrip(scheme: &str) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -320,7 +320,7 @@ async fn lite05_fetch_roundtrip(scheme: &str) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -430,7 +430,7 @@ async fn transport_fetch_roundtrip(version: &str) { .await .expect("announce timed out") .expect("origin closed"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -555,7 +555,7 @@ async fn lite05_fetch_during_subscribe(scheme: &str) { .expect("origin closed"); assert_eq!(update.prefix.as_str(), "test"); assert!(active, "expected announce, got retraction"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -661,7 +661,7 @@ async fn broadcast_moq_lite_05_untimed_track() { .expect("announce timeout") .expect("origin closed"); assert!(active, "expected announce"); - let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(&update.prefix, None)) + let bc = tokio::time::timeout(TIMEOUT, sub_consumer.request(&update.prefix, None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -756,7 +756,7 @@ async fn broadcast_moq_transport_22_current_group_join() { let (announced, announced_active) = next_announce(&mut announcements).await; assert_eq!(announced.prefix.as_str(), "test"); assert!(announced_active, "expected an announce"); - let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast(&announced.prefix, None)) + let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request(&announced.prefix, None)) .await .expect("request timed out") .expect("announced broadcast resolves"); @@ -1073,7 +1073,7 @@ async fn broadcast_route_migration() { let subscription = moq_net::track::Subscription::default() .with_range(1..) .with_max_delay(Duration::from_secs(10)); - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timeout") .expect("routed broadcast resolves"); @@ -1201,7 +1201,7 @@ async fn rejoin_skips_a_stale_warm_cache(version: &str) { .expect("connect failed"); assert!(next_announce(&mut announcements).await.1); - let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timeout") .expect("broadcast resolves"); @@ -1325,7 +1325,7 @@ async fn rejoin_replays_a_current_warm_cache(version: &str, open: bool) { .expect("connect failed"); assert!(next_announce(&mut announcements).await.1); - let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timeout") .expect("broadcast resolves"); @@ -1459,7 +1459,7 @@ async fn route_reannounce_test(version: Option<&str>) { assert!(active, "expected announce"); let initial = update.route; - let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test", None)) + let broadcast = tokio::time::timeout(TIMEOUT, sub_consumer.request("test", None)) .await .expect("request timeout") .expect("routed broadcast resolves"); @@ -1668,7 +1668,7 @@ async fn max_age_test(version: &str, published: Option) -> Option) -> anyhow::R .ok_or_else(|| anyhow::anyhow!("announcements closed"))?, moq_net::announce::Event::Start(_) ) {} - let front = consumer.request_broadcast("age", None).await?; + let front = consumer.request("age", None).await?; for (i, age) in AGES.into_iter().enumerate() { let track = front.track(&i.to_string())?.subscribe(None).await?; anyhow::ensure!( diff --git a/rs/moq-tokio/tests/integration/receive_credit.rs b/rs/moq-tokio/tests/integration/receive_credit.rs index ebdb762d841..9e85edee36e 100644 --- a/rs/moq-tokio/tests/integration/receive_credit.rs +++ b/rs/moq-tokio/tests/integration/receive_credit.rs @@ -168,11 +168,7 @@ fn rand_seed() -> u64 { /// Broadcast `room`, once the peer announces it into `origin`. async fn room(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Consumer { let consumer = origin.consume(); - tokio::time::timeout(TIMEOUT, consumer.routed("room")) - .await - .expect("announce timeout") - .expect("routed"); - tokio::time::timeout(TIMEOUT, consumer.request_broadcast("room", None)) + tokio::time::timeout(TIMEOUT, consumer.follow("room", None).unwrap().available()) .await .expect("resolve timeout") .expect("broadcast resolves") diff --git a/rs/moq-tokio/tests/integration/runtime.rs b/rs/moq-tokio/tests/integration/runtime.rs index f1654eb15d1..58497ab6297 100644 --- a/rs/moq-tokio/tests/integration/runtime.rs +++ b/rs/moq-tokio/tests/integration/runtime.rs @@ -86,7 +86,7 @@ fn sessions_without_a_runtime() { announced.next().await.expect("origin closed"); let broadcast = consumer - .request_broadcast("test", None) + .request("test", None) .await .expect("announced broadcast resolves"); let mut track = broadcast diff --git a/rs/moq-tokio/tests/integration/subscription_end_integrity.rs b/rs/moq-tokio/tests/integration/subscription_end_integrity.rs index e6fb3675db0..fdf780243fa 100644 --- a/rs/moq-tokio/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-tokio/tests/integration/subscription_end_integrity.rs @@ -84,9 +84,10 @@ async fn round(drop_session: bool) -> (usize, Option) { .await .expect("client connect"); - consumer.routed("test").await.expect("routed"); let remote = consumer - .request_broadcast("test", None) + .follow("test", None) + .unwrap() + .available() .await .expect("broadcast resolves"); let mut sub = remote.track("video").unwrap().subscribe(None).await.expect("subscribe"); diff --git a/rs/moq-tokio/tests/integration/unannounce.rs b/rs/moq-tokio/tests/integration/unannounce.rs index e40aa15d674..ee17ed78829 100644 --- a/rs/moq-tokio/tests/integration/unannounce.rs +++ b/rs/moq-tokio/tests/integration/unannounce.rs @@ -12,7 +12,7 @@ async fn release(unannounce: bool, settle: bool) { let origin = moq_tokio::origin::spawn(); let broadcast = origin.publish("a/b", moq_net::origin::Route::default()).unwrap(); let track = broadcast.create_track("t", None).unwrap(); - let consumer = origin.consume().request_broadcast("a/b", None).await.unwrap(); + let consumer = origin.consume().request("a/b", None).await.unwrap(); let sub = consumer.track("t").unwrap().subscribe(None).await.unwrap(); crate::wanted(track.demand()).await.unwrap(); diff --git a/rs/moq-transcode/examples/transcode.rs b/rs/moq-transcode/examples/transcode.rs index badad02c0d8..2e06b578bf8 100644 --- a/rs/moq-transcode/examples/transcode.rs +++ b/rs/moq-transcode/examples/transcode.rs @@ -50,29 +50,21 @@ async fn main() -> anyhow::Result<()> { .with_subscriber(remote.clone()) .connect(args.url.clone()); - // Wait for the source to be announced rather than for the session to connect: - // `request_broadcast` answers on the spot, so asking the moment a session exists - // races the announcement that makes the path routable. + // Follow the source until it is announced rather than asking once the session + // connects: the announcement that makes the path routable may still be in flight. // // Raced against the session ending, since the wait itself never fails: the origin // outlives the session here, so a rejected token or an exhausted retry budget would - // otherwise leave us waiting for an announcement that can never arrive. - let consumer = remote.consume(); - tokio::select! { - routed = consumer.routed(&source_path) => { - routed.context("origin closed before the source broadcast was announced")?; - } + // otherwise leave us waiting for an announcement that can never arrive. The session + // subscribes upstream on demand. + let mut following = remote.consume().follow(&source_path, None)?; + let source = tokio::select! { + resolved = following.available() => resolved.context("source broadcast unavailable")?, closed = session.closed() => { closed.context("session failed before the source broadcast was announced")?; anyhow::bail!("session closed before the source broadcast was announced"); } - } - - // Resolve it for real; the session subscribes upstream on demand. - let source = consumer - .request_broadcast(&source_path, None) - .await - .context("source broadcast unavailable")?; + }; // The default ladder and encoder (hardware first: NVENC on Linux) apply. let mut config = moq_transcode::Config::default(); diff --git a/rs/moq-uring/benches/session_lite.rs b/rs/moq-uring/benches/session_lite.rs index b759239d65d..673f848b05b 100644 --- a/rs/moq-uring/benches/session_lite.rs +++ b/rs/moq-uring/benches/session_lite.rs @@ -178,9 +178,10 @@ mod linux { }); let bc = { let consumer = sub_origin.consume(); - consumer.routed("bench").await.expect("broadcast announced"); consumer - .request_broadcast("bench", None) + .follow("bench", None) + .unwrap() + .available() .await .expect("broadcast resolves") }; diff --git a/rs/moq-uring/tests/integration/receive_credit.rs b/rs/moq-uring/tests/integration/receive_credit.rs index 1eca6be441c..04ce4d77143 100644 --- a/rs/moq-uring/tests/integration/receive_credit.rs +++ b/rs/moq-uring/tests/integration/receive_credit.rs @@ -157,12 +157,13 @@ fn partial_frame_gives_way() { }); let consumer = sub.consume(); - within(&handle, "the route", consumer.routed("room")) - .await - .expect("routed"); - let remote = within(&handle, "the broadcast", consumer.request_broadcast("room", None)) - .await - .expect("broadcast resolves"); + let remote = within( + &handle, + "the broadcast", + consumer.follow("room", None).unwrap().available(), + ) + .await + .expect("broadcast resolves"); let subscribe = |name: &str, priority: i8| { let track = remote.track(name).expect("track"); async move { @@ -313,12 +314,13 @@ fn javascript_partial_frame_gives_way() { }); let consumer = sub.consume(); - within(&handle, "the route", consumer.routed("room")) - .await - .expect("routed"); - let remote = within(&handle, "the broadcast", consumer.request_broadcast("room", None)) - .await - .expect("broadcast resolves"); + let remote = within( + &handle, + "the broadcast", + consumer.follow("room", None).unwrap().available(), + ) + .await + .expect("broadcast resolves"); let subscribe = |name: &str, priority: i8| { let track = remote.track(name).expect("track"); async move { diff --git a/rs/moq-uring/tests/integration/session.rs b/rs/moq-uring/tests/integration/session.rs index 2e2a2f27b25..0759d7813ed 100644 --- a/rs/moq-uring/tests/integration/session.rs +++ b/rs/moq-uring/tests/integration/session.rs @@ -137,9 +137,10 @@ fn lite_session_over_the_worker() { let bc = { let consumer = sub.consume(); - consumer.routed("test").await.expect("broadcast announced"); consumer - .request_broadcast("test", None) + .follow("test", None) + .unwrap() + .available() .await .expect("broadcast resolves") }; @@ -280,9 +281,10 @@ fn two_lite_sessions_share_the_server_socket() { let bc = { let consumer = sub.consume(); - consumer.routed("test").await.expect("broadcast announced"); consumer - .request_broadcast("test", None) + .follow("test", None) + .unwrap() + .available() .await .expect("broadcast resolves") }; diff --git a/rs/moq-uring/tests/integration/web.rs b/rs/moq-uring/tests/integration/web.rs index b3599ff74f5..efbaa0a89be 100644 --- a/rs/moq-uring/tests/integration/web.rs +++ b/rs/moq-uring/tests/integration/web.rs @@ -292,9 +292,10 @@ fn lite_session_over_webtransport() { let bc = { let consumer = sub_origin.consume(); - consumer.routed("test").await.expect("broadcast announced"); consumer - .request_broadcast("test", None) + .follow("test", None) + .unwrap() + .available() .await .expect("broadcast resolves") }; diff --git a/rs/moq-video/src/decode/decoder.rs b/rs/moq-video/src/decode/decoder.rs index 7010abe83be..dc5a445b7bb 100644 --- a/rs/moq-video/src/decode/decoder.rs +++ b/rs/moq-video/src/decode/decoder.rs @@ -654,7 +654,7 @@ mod tests { .unwrap(); producer.finish().unwrap(); - let broadcast = origin.consume().request_broadcast("test", None).await.unwrap(); + let broadcast = origin.consume().request("test", None).await.unwrap(); let catalog = moq_mux::catalog::Consumer::<()>::new(&broadcast, moq_mux::catalog::CatalogFormat::Hang) .await .unwrap(); diff --git a/rs/moq-wasm/src/lib.rs b/rs/moq-wasm/src/lib.rs index c0f420ae59d..37b5ad152ee 100644 --- a/rs/moq-wasm/src/lib.rs +++ b/rs/moq-wasm/src/lib.rs @@ -160,10 +160,7 @@ impl Session { let session = self.inner.clone(); let consumer = self.consumer.clone(); future_to_promise(async move { - let request = pin!(async { - consumer.routed(path.as_str()).await?; - consumer.request_broadcast(path.as_str(), None).await.ok() - }); + let request = pin!(async { consumer.follow(path.as_str(), None).ok()?.available().await.ok() }); // The origin outlives the session, so its wait alone never ends on a close. let closed = pin!(session.closed()); match select(request, closed).await { diff --git a/test/interop/clients/rust/audio.rs b/test/interop/clients/rust/audio.rs index 73e86881dec..cc6e0b45082 100644 --- a/test/interop/clients/rust/audio.rs +++ b/test/interop/clients/rust/audio.rs @@ -41,7 +41,7 @@ async fn main() -> anyhow::Result<()> { .established() .await?; - let broadcast = consumer.routed_broadcast(&args[2]).await?; + let broadcast = consumer.follow(&args[2], None)?.available().await?; let source = moq_mux::Source::new(consumer, broadcast.clone()); let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, CatalogFormat::Hang).await?; // A lazy publisher (the browser) may add audio in a later catalog update. diff --git a/test/interop/clients/rust/finish.rs b/test/interop/clients/rust/finish.rs index 6e6deb4712d..1854dc20f88 100644 --- a/test/interop/clients/rust/finish.rs +++ b/test/interop/clients/rust/finish.rs @@ -117,7 +117,7 @@ async fn main() -> anyhow::Result<()> { ensure!(command == "read\n", "finish read phase was not released"); moq_clock::timeout(args.timeout, async { let mut routes = consumer.announced(); - let broadcast = consumer.routed_broadcast(&args.broadcast).await?; + let broadcast = consumer.follow(&args.broadcast, None)?.available().await?; let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, moq_mux::catalog::CatalogFormat::Hang).await?; let catalog = loop { @@ -162,7 +162,10 @@ async fn main() -> anyhow::Result<()> { break; } } - let health = consumer.routed_broadcast(format!("{}.health", args.broadcast)).await?; + let health = consumer + .follow(format!("{}.health", args.broadcast), None)? + .available() + .await?; let mut track = health.track("live")?.subscribe(None).await?; let mut group = track.recv_group().await?.context("no health group")?; let frame = group.read_frame().await?.context("no health frame")?; diff --git a/test/interop/clients/rust/goaway-client.rs b/test/interop/clients/rust/goaway-client.rs index 781d360ba69..b4499699885 100644 --- a/test/interop/clients/rust/goaway-client.rs +++ b/test/interop/clients/rust/goaway-client.rs @@ -40,7 +40,7 @@ async fn main() -> anyhow::Result<()> { connection.version() == Some(version.parse().map_err(anyhow::Error::msg)?), "wrong negotiated version" ); - let broadcast = consumer.routed_broadcast("handover").await?; + let broadcast = consumer.follow("handover", None)?.available().await?; let mut track = broadcast.track("video")?.subscribe(None).await?; let input = child.stdin.as_mut().context("stdin")?; for sequence in 0..2 { @@ -55,7 +55,7 @@ async fn main() -> anyhow::Result<()> { input.write_all(b"first group\n").await?; // The first endpoint's publisher scope excludes this broadcast, so its bytes // prove that the replacement session is serving beyond its SETUP handshake. - let ready = consumer.routed_broadcast("replacement").await?; + let ready = consumer.follow("replacement", None)?.available().await?; let mut marker = ready.track("ready")?.subscribe(None).await?; let mut marker = marker.recv_group().await?.context("replacement marker")?; ensure!( diff --git a/test/interop/clients/rust/tail.rs b/test/interop/clients/rust/tail.rs index 4761b988306..fc5ee5f6dbd 100644 --- a/test/interop/clients/rust/tail.rs +++ b/test/interop/clients/rust/tail.rs @@ -186,7 +186,7 @@ async fn main() -> anyhow::Result<()> { .connect(url) .established() .await?; - let broadcast = consumer.routed_broadcast(&args[3]).await?; + let broadcast = consumer.follow(&args[3], None)?.available().await?; let remote = broadcast.track("tail")?; if status { // Query before subscribing so draft-18+ must use TRACK_STATUS, From 1bfb221d51d0eb2a63e9ee569d2db9c8dcb90200 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 17:47:56 -0700 Subject: [PATCH 4/5] wip: fix the mux binding and tests, update docs and quests --- doc/lib/rs/index.md | 2 +- doc/lib/rs/moq-net.md | 6 ++-- quest/m1/api-audit/resolve/README.md | 27 ++++++++-------- quest/m1/api-audit/resolve/bindings.md | 4 --- quest/m1/api-audit/resolve/callers.md | 13 +++++--- quest/m1/api-audit/resolve/js.md | 3 +- quest/m1/api-audit/resolve/rust.md | 32 ------------------- rs/moq-mux/src/source.rs | 44 ++++++++++++++++++-------- rs/moq-net/src/client.rs | 2 +- rs/moq-net/src/model/origin.rs | 2 +- rs/moq-rtmp/src/server.rs | 8 ++++- rs/moq-srt/src/server.rs | 2 +- 12 files changed, 67 insertions(+), 78 deletions(-) delete mode 100644 quest/m1/api-audit/resolve/rust.md diff --git a/doc/lib/rs/index.md b/doc/lib/rs/index.md index 9ff73657c4e..d6093c51d3b 100644 --- a/doc/lib/rs/index.md +++ b/doc/lib/rs/index.md @@ -64,7 +64,7 @@ let mut announced = consumer.announced(); while let Some(event) = announced.next().await { // Skip updates and retractions. let moq_net::announce::Event::Start(update) = event else { continue }; - let broadcast = consumer.request_broadcast(&update.prefix, update.route.epoch).await?; + let broadcast = consumer.request(&update.prefix, update.route.epoch).await?; let catalog = broadcast .track(hang::Catalog::DEFAULT_NAME)? .subscribe(hang::Catalog::default_subscription()) diff --git a/doc/lib/rs/moq-net.md b/doc/lib/rs/moq-net.md index f7022eb7b4e..0ab5c1c4bb0 100644 --- a/doc/lib/rs/moq-net.md +++ b/doc/lib/rs/moq-net.md @@ -16,10 +16,10 @@ moq-transport at setup and presents one API either way. Media is a layer above What you use it for, beyond what the concept page already describes: - **An origin outlives the session.** Creating a broadcast returns an origin publication that controls its announcement and exposes the broadcast to fill. Standalone and Prepared fill producers cannot announce; only publishing the Prepared answer admits its publication. A reconnect announces existing publications again, and closing the session does not delete them. -- **Requests can pin an epoch.** `consumer.request_broadcast(path, Some(epoch))` resolves only through a route announcing that [publisher epoch](/concept/moq-lite#publisher-epochs); `None` takes whichever route wins. The resolved consumer names its epoch in `info().epoch`, pinned or not. +- **Requests can pin an epoch.** `consumer.request(path, Some(epoch))` resolves only through a route announcing that [publisher epoch](/concept/moq-lite#publisher-epochs); `None` takes whichever route wins. The resolved consumer names its epoch in `info().epoch`, pinned or not. - **Rank several CDNs.** Dial each with its own subscribe handle, `origin.clone().with_preference(origin::Preference::new(rank))` (higher wins; 0 is neutral and a negative rank demotes), all on one origin. Requests use the preferred link that has a route and fail over to the next; see [multiple CDNs](/concept/moq-lite#multiple-cdns). -- **Follow restarts.** `consumer.announced_broadcast(path, None)` hands out each publisher instance serving a path from `available()`: the first once announced, then each one that takes over or returns after an end, like JS `request(path, { announced: true })`. A broadcast already resolved stays on the old instance until dropped or its route goes. `consumer.follow(path)` yields the underlying start, update, restart, and end of the route a request resolves. -- **Discovery follows what you watch.** A client session asks the relay for announcements only under the prefixes its subscribe origin's readers watch, with `announced()`, `routed_broadcast`, or `announced_broadcast`, stops asking about a prefix 2s after nothing at or beneath it is watched, and asks again on reconnect. A broadcast resolved through a discovered route keeps its path watched until dropped. `request_broadcast` owns discovery of its path and reports absence only once discovery has synced; no separate watch is needed. A server session, or a client fed into an origin handle marked `with_link(origin::Link::Peer)` or `Link::Upstream`, asks for everything it may, so a relay discovers everything. An HTTP gateway (the moq-hls `Server`, the moq-rtc WHEP router) watches its whole scope while it lives, so the paths its callers name never open a request each. moq-lite-03/04 sessions, whose announcements mark no initial set, still ask for everything. +- **Request one instance, or follow them all.** `consumer.request(path, None)` resolves the instance serving a path now, and fails `Unroutable` only once discovery has synced with no route for it. `consumer.follow(path, None)` hands out each publisher instance serving a path from `available()`: the first once announced, then each one that takes over or returns after an end. A broadcast already resolved stays on the old instance until dropped or its route goes. +- **Discovery follows what you watch.** A client session asks the relay for announcements only under the prefixes its subscribe origin's readers watch, with `announced()`, `request`, or `follow`, stops asking about a prefix 2s after nothing at or beneath it is watched, and asks again on reconnect. A broadcast resolved through a discovered route keeps its path watched until dropped. `request` owns discovery of its path, so no separate watch is needed. A server session, or a client fed into an origin handle marked `with_link(origin::Link::Peer)` or `Link::Upstream`, asks for everything it may, so a relay discovers everything. An HTTP gateway (the moq-hls `Server`, the moq-rtc WHEP router) watches its whole scope while it lives, so the paths its callers name never open a request each. moq-lite-03/04 sessions, whose announcements mark no initial set, still ask for everything. - **One track per name.** Concurrent subscriptions share one request and producer. The application owns sequence numbers: the broadcast keeps nothing of an ended track, so a producer that replaces it starts at 0. A name always means the same content, so the replacement continues past its predecessor's groups with `create_group` at an explicit sequence. Readers of an aborted track resume onto the replacement only when the broadcast announces an epoch; otherwise their subscription ends with the error. - **End content by finishing tracks.** A broadcast has no finished state. When the input ends, finish each track; the broadcast stays announced and keeps serving them until you close it or drop its last producer. How long to keep it up for late readers is yours to decide: `moq_mux::Linger` holds a hang broadcast for a fixed window. - **Publish only while someone is watching.** `demand()` on a track, group, or broadcast says whether a subscriber is attached, which is how capture and transcode skip work nobody asked for. Holding a broadcast or track consumer is not demand: a track consumer requests nothing until it queries, subscribes, or fetches, and those count until dropped. A shared fetch stays up until its last reader leaves. Demand rolls up: a frame being read keeps its group wanted, a group a subscription or fetch handed out keeps its track wanted until read to its end, and any wanted track keeps its broadcast wanted. diff --git a/quest/m1/api-audit/resolve/README.md b/quest/m1/api-audit/resolve/README.md index 215dd750002..6cae783122a 100644 --- a/quest/m1/api-audit/resolve/README.md +++ b/quest/m1/api-audit/resolve/README.md @@ -20,25 +20,25 @@ No caller can assemble a racy two-step resolve, and no crate hand-rolls Decided 2026-10-22 (API audit, maintainer approved the recommendation). -The behavioral checkpoint makes `request_broadcast` own scoped discovery and +The behavioral checkpoint makes the Rust request own scoped discovery and retry route churn. It reports table absence only after sync; a selected handler's explicit refusal stays terminal, including a dropped Prepared answer. The front records that refusal privately at its existing standing-route decision, rather than guessing from unrelated mutations of the table. The old immediate lookup is private to sessions. `Requesting::is_queued` and the public `Routing` task are gone; `Requesting` is the owned task. The stats reader uses it instead of its -own retry on `is_queued`; the mux binding keeps its pinned `routed_broadcast` -wait. Rust and JS have same-epoch follow-return coverage, and every JS request -owns its discovery watch from creation. A pending plain JS request fails -`Unroutable` once that discovery syncs with no route for it, matching Rust. JS -announcement-following no longer silently uses a blind peer. The existing -`routed_broadcast` helper retains its route-change retry policy for the CLI, -gateway, mux binding, and relay HTTP consumers. Its removal belongs to the remaining rollout. - -The approved public method names have not rolled out. Decided 2026-10-28 -(maintainer, /quest-plan): the rollout splits into the four children below, so -each language and the callers review on their own. Rust and JS proceed in -parallel; the bindings follow Rust, and the callers follow both. +own retry on `is_queued`. Rust and JS have same-epoch follow-return coverage, +and every JS request owns its discovery watch from creation. A pending plain JS +request fails `Unroutable` once that discovery syncs with no route for it, +matching Rust. JS announcement-following no longer silently uses a blind peer. + +Decided 2026-10-28 (maintainer, /quest-plan): the rollout splits into a child +per language and one for the callers, so each reviews on its own. Rust has +landed: `request(path, epoch)` and `follow(path, epoch)` (returning +`origin::Following`), with `routed`, `routed_broadcast`, and the route-level +`announce::Follow` gone, and its in-tree callers following the path where they +used to wait for a route. JS proceeds in parallel; the bindings follow Rust, +and the callers follow both. This README's own work, once every child lands: the lifecycle and churn checks across languages, the required Nix gate, and all-language interop @@ -50,7 +50,6 @@ Wire: none. ## Required -- [Rust request and follow](/quest/m1/api-audit/resolve/rust.md) - Rust names the two resolutions `request` and `follow`, deletes `routed` and `routed_broadcast`, and makes the route-level `Follow` private - [JS request and follow](/quest/m1/api-audit/resolve/js.md) - `@moq/net` exposes `request(path, {epoch})` and `follow(path, {epoch})` instead of the `announced` option - [Bindings request and follow](/quest/m1/api-audit/resolve/bindings.md) - moq-ffi, the C ABI, and every wrapper mirror `request` and `follow` with an optional epoch - [Callers resolve once](/quest/m1/api-audit/resolve/callers.md) - no caller hand-rolls synced resolution or decides table absence by wall clock diff --git a/quest/m1/api-audit/resolve/bindings.md b/quest/m1/api-audit/resolve/bindings.md index 938e9776298..7c4cf1fc20e 100644 --- a/quest/m1/api-audit/resolve/bindings.md +++ b/quest/m1/api-audit/resolve/bindings.md @@ -19,7 +19,3 @@ Regenerate bindings from source, update every wrapper's tests, READMEs and `just test interop --all`. Public API: breaking in moq-ffi, the C ABI, and every wrapper. Wire: none. - -## Required - -- [Rust request and follow](/quest/m1/api-audit/resolve/rust.md) - the Rust names the bindings mirror diff --git a/quest/m1/api-audit/resolve/callers.md b/quest/m1/api-audit/resolve/callers.md index 40978216747..76eb1253380 100644 --- a/quest/m1/api-audit/resolve/callers.md +++ b/quest/m1/api-audit/resolve/callers.md @@ -11,11 +11,15 @@ broadcast is absent. Each first-party caller resolves with `request` or Split from [Two broadcast resolutions](/quest/m1/api-audit/resolve/README.md) on 2026-10-28 (maintainer). -- Remove the racy two-step lookup and its hidden error in moq-wasm. -- Replace the route waits in moq-cli's subscribe and report. +- Remove the hidden error in moq-wasm's resolve, which follows the path but + still discards why it failed. +- Replace moq-cli's resolve-and-drop waits before its stdout, RTMP, and WHIP + exports, which follow the path only to wait for its announcement and then + resolve it again. - Review SRT, transcode, the benchmark connections, relay HTTP fetch - deadlines, the e2ee epoch advice, and the demo's announce-derived epoch pin; - fix each that hand-rolls resolution or decides absence by time. + deadlines, the moq-hls server's `RESOLVE_TIMEOUT` handler-stall bound, the + e2ee epoch advice, and the demo's announce-derived epoch pin; fix each that + hand-rolls resolution or decides absence by time. List every caller in the PR with what it now uses. Run the affected packages' tests and `just test interop --all`. @@ -24,5 +28,4 @@ Public API: none beyond the callers' own surfaces. Wire: none. ## Required -- [Rust request and follow](/quest/m1/api-audit/resolve/rust.md) - the Rust names the callers move to - [JS request and follow](/quest/m1/api-audit/resolve/js.md) - the JS names the callers move to diff --git a/quest/m1/api-audit/resolve/js.md b/quest/m1/api-audit/resolve/js.md index 38890233630..b9c8177c256 100644 --- a/quest/m1/api-audit/resolve/js.md +++ b/quest/m1/api-audit/resolve/js.md @@ -16,7 +16,8 @@ on 2026-10-28 (maintainer); its Plan holds the behavior already landed in resolved instance. - Retain synchronous request peeks and path-local wakeups. - `Producer` pass-throughs stay only where `Table` needs them. -- Mirror the Rust names from [Rust request and follow](/quest/m1/api-audit/resolve/rust.md). +- Mirror the Rust names: `origin::Consumer::request` and `follow`, the latter + returning a `Following` whose `available()` hands out each instance. Tests: synced absence, no follower fallback on a blind peer, pinned follow return, and discovery retention and release, on mocked time. diff --git a/quest/m1/api-audit/resolve/rust.md b/quest/m1/api-audit/resolve/rust.md deleted file mode 100644 index be9ef749807..00000000000 --- a/quest/m1/api-audit/resolve/rust.md +++ /dev/null @@ -1,32 +0,0 @@ -# [M] Rust request and follow - -## Goal - -Rust names the two resolutions `request(path, epoch)` and `follow(path, -epoch)` (today's `announced_broadcast`). The immediate table lookup stays -private, `routed` and `routed_broadcast` are deleted with their callers -fixed, and the route-level `Follow` is private. - -## Plan - -Split from [Two broadcast resolutions](/quest/m1/api-audit/resolve/README.md) -on 2026-10-28 (maintainer); its Plan holds the behavior already landed in -[moq-dev/moq#6445](https://github.com/moq-dev/moq/pull/6445). - -- Preserve terminal selected-handler refusals, private deferred validity - checks, and instance identity across route churn. -- Move the remaining route-level `Follow` consumers before making it private: - the moq-hls server's resolve, with its hand-rolled discovery and - `RESOLVE_TIMEOUT`, and the tests that read its events. `moq play` and - `moqsrc` already follow through `moq_mux::Source::follow`. Add no new public - route API or compatibility shim to make the privatization pass. -- Fix the in-tree Rust callers of `routed` and `routed_broadcast` that this - deletion breaks (the CLI, gateway, mux binding, relay HTTP), keeping their - route-change retry where they need it. Reworking their resolution logic - beyond the rename belongs to [Callers resolve once](/quest/m1/api-audit/resolve/callers.md). - -Tests: an announced but unwatched path over lite-05, 06 and 07-wip; synced -absence; discovery retention and release; pinned follow return; unchanged -explicit refusal. - -Public API: breaking in moq-net, with an Impact migration note. Wire: none. diff --git a/rs/moq-mux/src/source.rs b/rs/moq-mux/src/source.rs index 131cd3a89f1..85078c86987 100644 --- a/rs/moq-mux/src/source.rs +++ b/rs/moq-mux/src/source.rs @@ -145,23 +145,22 @@ impl Source { Some(pinned) => Bound::Ready(pinned), // Unpinned even with an epoch: an epochless route still answers, best effort, and // the read refuses a route that proves another instance. - None => match self.origin.follow(path, None) { - Err(err) => Bound::Failed(err), + None => { + let mut following = self.origin.follow(path, None); // Issue the request now: a handler answers it whether or not anyone reads yet. - // The follower hands an instance out once, so an answer on hand is pinned here. - Ok(mut following) => match following.poll_available(&kio::Waiter::noop()) { + match poll_first(&mut following, &kio::Waiter::noop()) { + // The follower hands an instance out once, so an answer on hand is pinned now. Poll::Ready(Ok(broadcast)) => { let mut pins = self.pins.lock().expect("pins poisoned"); Bound::Ready(pins.entry(path.clone()).or_insert(broadcast).clone()) } - Poll::Ready(Err(err)) => Bound::Failed(err), - Poll::Pending => Bound::Requested { + _ => Bound::Requested { following: Box::new(Mutex::new(following)), pins: self.pins.clone(), path: path.clone(), }, - }, - }, + } + } }; Binding { bound, @@ -368,11 +367,10 @@ pub struct Binding { enum Bound { /// A broadcast the caller already holds. Ready(moq_net::broadcast::Consumer), - /// A request that failed when the binding was made. - Failed(moq_net::Error), - /// A request issued when the binding was made, resolved once something announces the path. + /// A request issued when the binding was made, resolved once something announces the path, + /// or the failure it ended with. Requested { - following: Box>, + following: Box>, /// Where the answer is pinned, the first for its path winning. pins: Pins, path: moq_net::Path, @@ -400,7 +398,6 @@ impl Binding { pub fn poll_broadcast(&self, waiter: &kio::Waiter) -> Poll> { let broadcast = match &self.bound { Bound::Ready(broadcast) => broadcast.clone(), - Bound::Failed(err) => return Poll::Ready(Err(err.clone().into())), Bound::Requested { following, pins, path } => { // Once a path is pinned, its pin is the answer: a request that raced another for // the path takes the one pinned first, and the follower is never polled again, since @@ -410,7 +407,7 @@ impl Binding { } else { let broadcast = { let mut following = following.lock().expect("following poisoned"); - ready!(following.poll_available(waiter))? + ready!(poll_first(&mut following, waiter))? }; // The path's first answer is pinned even when it fails this binding's epoch, so // no later reference resolves the path independently. @@ -430,6 +427,25 @@ impl Binding { } } +/// A binding's follower, or the failure it ended with. +type Following = Result; + +/// Poll a binding's follower for its first instance, keeping the failure it ends with so every +/// later read answers the same. +fn poll_first( + following: &mut Following, + waiter: &kio::Waiter, +) -> Poll> { + let result = match following { + Ok(following) => ready!(following.poll_available(waiter)), + Err(err) => Err(err.clone()), + }; + if let Err(err) = &result { + *following = Err(err.clone()); + } + Poll::Ready(result) +} + /// Test helper: build an origin producer, spawning its driver on the ambient runtime. #[cfg(test)] pub(crate) fn produce_origin() -> moq_net::origin::Producer { diff --git a/rs/moq-net/src/client.rs b/rs/moq-net/src/client.rs index 80cb7c5e7b3..02d5afe38ab 100644 --- a/rs/moq-net/src/client.rs +++ b/rs/moq-net/src/client.rs @@ -860,7 +860,7 @@ mod tests { /// `connect` must not depend on the peer answering. A peer that opens the announce /// stream and then says nothing (or promises a count it never delivers) used to hold /// `connect` for the life of the session, since it waited for the initial announce - /// set. Resolving a path you need is `routed`'s job, which waits for + /// set. Resolving a path you need is `request`'s job, which waits for /// that path rather than for the peer to finish talking. #[moq_clock::test] async fn connect_does_not_wait_for_the_peer_to_announce() { diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index f3601232a45..188f8187bf6 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -6278,7 +6278,7 @@ impl Consumer { } /// A clone of this consumer with its stats context cleared, so an internal - /// lookup stream (e.g. [`Self::routed`]) doesn't drive the egress + /// lookup stream (e.g. [`Self::routes`]) doesn't drive the egress /// announce guards; the caller re-attributes the result itself. fn untagged(&self) -> Self { Self { diff --git a/rs/moq-rtmp/src/server.rs b/rs/moq-rtmp/src/server.rs index 0ceab89108b..ec2147a84e5 100644 --- a/rs/moq-rtmp/src/server.rs +++ b/rs/moq-rtmp/src/server.rs @@ -1878,7 +1878,13 @@ mod tests { let (client, server) = tokio::io::duplex(64 * 1024); let start = tokio::time::Instant::now(); let accept = tokio::spawn(accept_publish(server, origin.clone(), Duration::from_secs(10))); - let broadcast = async { consumer.follow("live/cam0", None).unwrap().available().await.unwrap() }; + // A hangup ends the instance at once, before a follower would hand it out, so this + // requests it on its announcement instead. + let mut announced = consumer.announced(); + let broadcast = async { + announced.next().await.unwrap(); + consumer.request("live/cam0", None).await.unwrap() + }; let (broadcast, ()) = tokio::join!(broadcast, publish_one_keyframe(client, leave)); accept.await.unwrap(); diff --git a/rs/moq-srt/src/server.rs b/rs/moq-srt/src/server.rs index cff326f0cd3..7adc61c3439 100644 --- a/rs/moq-srt/src/server.rs +++ b/rs/moq-srt/src/server.rs @@ -583,7 +583,7 @@ pub(crate) async fn serve_subscribe( mut socket: SrtSocket, options: crate::ts::Options, ) -> Result<()> { - // Resolve the broadcast, but watch the socket while we wait: `routed` + // Resolve the broadcast, but watch the socket while we wait: following it // parks forever for a stream that is never published, and nothing else polls the // socket during that wait, so without this a caller who requests a non-existent // stream (or hangs up before it starts) would leak this task and its socket. From 55c90406ce315064bb863a4196d62ba9722b1662 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 28 Oct 2026 19:23:08 -0700 Subject: [PATCH 5/5] fix: close the follower handoff races in mux and moq-hls The mux Binding now holds its follower locked until the answer is pinned. The follower hands each instance out once, so a concurrent read that polled it between the two would wait for the next instance. The moq-hls follow task ends when the served instance closes before the follower hands it out. The follower folds away an instance that started and ended before its first poll, so nothing else would end the follow. Drops callers.md's now-empty Required section, since its JS blocker merged in main. Co-Authored-By: Claude Opus 5.5 --- quest/m1/api-audit/resolve/callers.md | 3 --- rs/moq-hls/src/server/mod.rs | 30 +++++++++++++++++++++++++-- rs/moq-mux/src/source.rs | 8 +++---- 3 files changed, 32 insertions(+), 9 deletions(-) diff --git a/quest/m1/api-audit/resolve/callers.md b/quest/m1/api-audit/resolve/callers.md index d954e9beef5..3d686658a7f 100644 --- a/quest/m1/api-audit/resolve/callers.md +++ b/quest/m1/api-audit/resolve/callers.md @@ -25,6 +25,3 @@ List every caller in the PR with what it now uses. Run the affected packages' tests and `just test interop --all`. Public API: none beyond the callers' own surfaces. Wire: none. - -## Required - diff --git a/rs/moq-hls/src/server/mod.rs b/rs/moq-hls/src/server/mod.rs index 3e3e4f50f7b..bc5e2430816 100644 --- a/rs/moq-hls/src/server/mod.rs +++ b/rs/moq-hls/src/server/mod.rs @@ -262,7 +262,7 @@ impl Inner { /// Follow `name`'s instances into `followed` until nothing serves the path, then forget it, so the /// next request follows the path afresh. Holds both weakly, so it never keeps the server's state /// alive; dropping `followed` aborts it. `served` is the instance `followed` starts on, which the -/// follower hands out first unless another took over since. +/// follower hands out first unless another took over since, or folds away if it closed first. async fn run_follow( inner: Weak, name: String, @@ -277,7 +277,15 @@ async fn run_follow( return Poll::Ready(None); }; followed.forget_closed(waiter); - instances.poll_next(waiter).map(Some) + if let Poll::Ready(next) = instances.poll_next(waiter) { + return Poll::Ready(Some(next)); + } + // The follower folds away an instance that started and ended before its first poll, + // so the served instance closing before it is handed out means nothing serves the path. + match &served { + Some(served) => served.poll_closed(waiter).map(|()| Some(Ok(follow::Event::End))), + None => Poll::Pending, + } }) .await; let (Some(inner), Some(followed)) = (inner.upgrade(), followed.upgrade()) else { @@ -527,6 +535,24 @@ mod tests { eventually(async || server.inner.broadcasts.lock().unwrap().is_empty()).await; } + /// An instance that goes before the follower first runs is folded away by it, so the served + /// instance closing is what tells the server that nothing serves the path. + #[tokio::test(start_paused = true)] + async fn an_instance_gone_before_the_follower_runs_is_forgotten() { + let origin = produce_origin(); + let server = Server::new(origin.consume(), Config::default()); + let publication = origin + .publish("live", moq_net::origin::Route::default()) + .expect("publish allowed"); + settle().await; + + // Nothing yields between spawning the follower and returning, so it has not run yet. + let broadcaster = server.broadcaster("live").await.expect("broadcast announced"); + drop(publication); + eventually(async || server.inner.broadcasts.lock().unwrap().is_empty()).await; + assert!(broadcaster.is_closed()); + } + /// A request that finds the listed instance closed before the follower does resolves the path /// afresh, yet a replaced instance still open keeps its URLs. An epochless one gets a new id /// when resolved again, so its old URLs would never serve otherwise. diff --git a/rs/moq-mux/src/source.rs b/rs/moq-mux/src/source.rs index 85078c86987..4b342a9c2d5 100644 --- a/rs/moq-mux/src/source.rs +++ b/rs/moq-mux/src/source.rs @@ -399,16 +399,16 @@ impl Binding { let broadcast = match &self.bound { Bound::Ready(broadcast) => broadcast.clone(), Bound::Requested { following, pins, path } => { + // The follower stays locked until its answer is pinned: it hands each instance + // out once, so a concurrent read that polled it in between would wait for the next. + let mut following = following.lock().expect("following poisoned"); // Once a path is pinned, its pin is the answer: a request that raced another for // the path takes the one pinned first, and the follower is never polled again, since // it would wait out the gap after the pinned instance goes. if let Some(pinned) = pins.lock().expect("pins poisoned").get(path) { pinned.clone() } else { - let broadcast = { - let mut following = following.lock().expect("following poisoned"); - ready!(poll_first(&mut following, waiter))? - }; + let broadcast = ready!(poll_first(&mut following, waiter))?; // The path's first answer is pinned even when it fails this binding's epoch, so // no later reference resolves the path independently. let mut pins = pins.lock().expect("pins poisoned");