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 2a3ed97631f..05ca0456213 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 `follow(path)`. 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, like JS `follow(path)`. 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 06bbee60d73..c8abbf82d77 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 - [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 0326463498a..3d686658a7f 100644 --- a/quest/m1/api-audit/resolve/callers.md +++ b/quest/m1/api-audit/resolve/callers.md @@ -11,17 +11,17 @@ 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`. 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 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/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-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-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-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-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..bc5e2430816 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,22 +261,42 @@ 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, or folds away if it closed first. +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 { 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 { 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"); @@ -526,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-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/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-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..4b342a9c2d5 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,18 +140,25 @@ 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(); + let mut following = self.origin.follow(path, None); // 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(), + 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()) + } + _ => Bound::Requested { + following: Box::new(Mutex::new(following)), + pins: self.pins.clone(), + path: path.clone(), + }, } } }; @@ -342,7 +349,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 +367,10 @@ pub struct Binding { enum Bound { /// A broadcast the caller already holds. Ready(moq_net::broadcast::Consumer), - /// 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 { - routing: Box>, + following: Box>, /// Where the answer is pinned, the first for its path winning. pins: Pins, path: moq_net::Path, @@ -390,17 +398,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::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 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 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"); @@ -419,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 { @@ -437,10 +464,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 +571,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 +601,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-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/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/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 6e61644669e..8199a9ffbf5 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -5101,7 +5101,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"); @@ -5153,7 +5153,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()); @@ -5215,7 +5215,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()); @@ -5416,7 +5416,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() @@ -5462,7 +5462,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..188f8187bf6 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. @@ -6280,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 { @@ -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 978ede720cd..5d09630c418 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 f137c999bfd..1264fd07afd 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 975e1cb926a..7d77ced22aa 100644 --- a/rs/moq-net/tests/integration/warm_backfill.rs +++ b/rs/moq-net/tests/integration/warm_backfill.rs @@ -36,8 +36,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 d6ecfdabdd0..b2df58aaa21 100644 --- a/rs/moq-net/tests/integration/widened_max_age.rs +++ b/rs/moq-net/tests/integration/widened_max_age.rs @@ -96,8 +96,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()]); @@ -266,8 +265,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"); 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..ec2147a84e5 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,9 +1878,12 @@ 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))); + // 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 { - consumer.routed("live/cam0").await.unwrap(); - consumer.request_broadcast("live/cam0", None).await.unwrap() + announced.next().await.unwrap(); + consumer.request("live/cam0", None).await.unwrap() }; let (broadcast, ()) = tokio::join!(broadcast, publish_one_keyframe(client, leave)); @@ -1895,8 +1902,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 +1931,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 +2212,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 +2802,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 +2832,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/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. 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 b98f8e56682..32d7378741c 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 929c57efeb6..c2bce789aee 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,