From 3d557d57199e001df7c5f47febb226c1a1aaff8e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 19:54:26 -0800 Subject: [PATCH 01/19] chore(quest): claim quest/m1/api-audit/route/handle.md Quest-Claim: f9fb7474d21c4d61 From 06b1b0d28239eff91d806e0e8605d1060815c26b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 20:10:36 -0800 Subject: [PATCH 02/19] wip: Route handle core in moq-net (tests not yet migrated) --- rs/moq-net/benches/announce.rs | 2 +- rs/moq-net/benches/auth.rs | 13 +- rs/moq-net/benches/memory.rs | 8 +- rs/moq-net/benches/origin.rs | 78 +- rs/moq-net/benches/path.rs | 8 +- rs/moq-net/benches/retirement.rs | 4 +- rs/moq-net/benches/session/mod.rs | 4 +- rs/moq-net/benches/stats.rs | 4 +- rs/moq-net/benches/viewers.rs | 6 +- rs/moq-net/src/auth.rs | 4 +- rs/moq-net/src/fuzz.rs | 32 +- rs/moq-net/src/ietf/cluster.rs | 6 +- rs/moq-net/src/ietf/publisher.rs | 206 +- rs/moq-net/src/ietf/session.rs | 8 +- rs/moq-net/src/ietf/subscriber.rs | 40 +- rs/moq-net/src/lite/fetch.rs | 2 +- rs/moq-net/src/lite/ietf.rs | 24 +- rs/moq-net/src/lite/publisher.rs | 150 +- rs/moq-net/src/lite/subscribe.rs | 2 +- rs/moq-net/src/lite/subscriber.rs | 34 +- rs/moq-net/src/lite/track.rs | 2 +- rs/moq-net/src/lite/tracks.rs | 2 +- rs/moq-net/src/model/broadcast.rs | 118 +- rs/moq-net/src/model/follow.rs | 54 +- rs/moq-net/src/model/mod.rs | 6 +- rs/moq-net/src/model/origin.rs | 2035 +++++++++-------- rs/moq-net/src/model/resume_model.rs | 6 +- rs/moq-net/src/server.rs | 4 +- rs/moq-net/src/util.rs | 2 +- .../integration/announce_covering_route.rs | 16 +- .../tests/integration/announce_takeover.rs | 14 +- .../tests/integration/announce_to_serve.rs | 12 +- rs/moq-net/tests/integration/auth.rs | 166 +- .../tests/integration/broadcast_close.rs | 10 +- .../tests/integration/catalog_acquisition.rs | 6 +- rs/moq-net/tests/integration/catalog_churn.rs | 6 +- .../tests/integration/catalog_handover.rs | 8 +- rs/moq-net/tests/integration/compress.rs | 22 +- rs/moq-net/tests/integration/control_stats.rs | 6 +- rs/moq-net/tests/integration/datagram.rs | 20 +- .../tests/integration/dial_split_horizon.rs | 6 +- rs/moq-net/tests/integration/drained_claim.rs | 14 +- rs/moq-net/tests/integration/empty_group.rs | 6 +- rs/moq-net/tests/integration/errored_end.rs | 6 +- rs/moq-net/tests/integration/extensions.rs | 4 +- .../tests/integration/fastest_reader.rs | 8 +- rs/moq-net/tests/integration/fetch_cancel.rs | 12 +- .../tests/integration/fetch_from_feed.rs | 8 +- rs/moq-net/tests/integration/fetch_only.rs | 22 +- .../tests/integration/fetch_pipeline.rs | 14 +- .../integration/finished_broadcast_mock.rs | 8 +- rs/moq-net/tests/integration/finite_relay.rs | 6 +- rs/moq-net/tests/integration/goaway.rs | 12 +- rs/moq-net/tests/integration/group_order.rs | 12 +- .../tests/integration/history_groups.rs | 12 +- .../tests/integration/idle_cancel_refetch.rs | 6 +- rs/moq-net/tests/integration/idle_session.rs | 4 +- rs/moq-net/tests/integration/instance.rs | 6 +- .../tests/integration/late_lower_group.rs | 16 +- .../tests/integration/lazy_discovery.rs | 14 +- rs/moq-net/tests/integration/mesh_withdraw.rs | 30 +- rs/moq-net/tests/integration/model.rs | 12 +- rs/moq-net/tests/integration/multi_cdn.rs | 8 +- rs/moq-net/tests/integration/partial_group.rs | 6 +- rs/moq-net/tests/integration/quiet_catalog.rs | 8 +- rs/moq-net/tests/integration/range_anchors.rs | 6 +- rs/moq-net/tests/integration/range_read.rs | 6 +- .../tests/integration/received_rewind.rs | 12 +- rs/moq-net/tests/integration/rejoin.rs | 60 +- .../tests/integration/relay_upstream_close.rs | 6 +- rs/moq-net/tests/integration/replacement.rs | 14 +- rs/moq-net/tests/integration/request_caps.rs | 22 +- rs/moq-net/tests/integration/route_change.rs | 54 +- rs/moq-net/tests/integration/route_health.rs | 12 +- .../tests/integration/segmented_frame.rs | 6 +- rs/moq-net/tests/integration/session_close.rs | 22 +- rs/moq-net/tests/integration/session_idle.rs | 8 +- rs/moq-net/tests/integration/session_panic.rs | 10 +- .../integration/settled_end_survives_abort.rs | 4 +- .../tests/integration/setup_negotiation.rs | 4 +- rs/moq-net/tests/integration/slow_joiner.rs | 6 +- rs/moq-net/tests/integration/source_errors.rs | 18 +- rs/moq-net/tests/integration/stream_credit.rs | 6 +- .../tests/integration/subscribe_priority.rs | 6 +- .../tests/integration/subscribe_ranges.rs | 28 +- .../tests/integration/subscribe_tracks.rs | 8 +- .../tests/integration/subscribe_with_track.rs | 6 +- .../tests/integration/subscriber_max_age.rs | 12 +- .../integration/subscription_end_integrity.rs | 18 +- rs/moq-net/tests/integration/support/mod.rs | 2 +- rs/moq-net/tests/integration/synced.rs | 16 +- .../integration/track_abort_over_session.rs | 14 +- .../tests/integration/track_info_cancel.rs | 14 +- .../tests/integration/track_stream_demand.rs | 12 +- rs/moq-net/tests/integration/track_tail.rs | 8 +- rs/moq-net/tests/integration/tracks.rs | 42 +- rs/moq-net/tests/integration/tracks_ietf.rs | 6 +- .../tests/integration/unannounce_release.rs | 6 +- rs/moq-net/tests/integration/untimed.rs | 24 +- rs/moq-net/tests/integration/warm_backfill.rs | 12 +- rs/moq-net/tests/integration/wide_hop.rs | 4 +- rs/moq-net/tests/integration/wide_sequence.rs | 22 +- .../tests/integration/widened_max_age.rs | 12 +- rs/moq-net/tests/integration/zero_copy.rs | 6 +- 104 files changed, 2037 insertions(+), 1927 deletions(-) diff --git a/rs/moq-net/benches/announce.rs b/rs/moq-net/benches/announce.rs index 898798cec81..f494c5ec8f7 100644 --- a/rs/moq-net/benches/announce.rs +++ b/rs/moq-net/benches/announce.rs @@ -55,7 +55,7 @@ fn initial(c: &mut Criterion) { announce::Event::Update(announce::Announce { prefix: moq_net::Path::new(&format!("route/{route}")).unwrap(), captures: None, - route: moq_net::origin::Route::default().with_cost(cost), + route: moq_net::origin::RouteInfo::default().with_cost(cost), }) }) }) diff --git a/rs/moq-net/benches/auth.rs b/rs/moq-net/benches/auth.rs index bcdf18e8916..d49a4a46f1c 100644 --- a/rs/moq-net/benches/auth.rs +++ b/rs/moq-net/benches/auth.rs @@ -194,12 +194,12 @@ fn renewal(c: &mut Criterion) { auths }); let broadcasts: Vec<_> = (0..routes) - .map(|route| origin.create_broadcast(format!("room/{route}").as_str()).unwrap()) + .map(|route| origin.route(format!("room/{route}").as_str(), moq_net::origin::RouteOptions::hidden()).unwrap()) .collect(); let mut swap = |next: usize, touched: usize| { for (index, broadcast) in broadcasts.iter().take(touched).enumerate() { broadcast - .announce(origin::Route::default().with_auth(auths[index][next].clone())) + .announce(origin::RouteInfo::default().with_auth(auths[index][next].clone())) .unwrap(); } runtime.block_on(async { @@ -275,8 +275,8 @@ fn waiting(c: &mut Criterion) { let broadcasts: Vec<_> = (0..paths) .map(|path| { let broadcast = - publish.create_broadcast(format!("{prefix}{path}").as_str()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + publish.route(format!("{prefix}{path}").as_str(), moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); broadcast }) .collect(); @@ -360,10 +360,7 @@ fn shared_requests(c: &mut Criterion) { for request in 0..requests { broadcasts.push( origin - .publish( - format!("{prefix}/{token}/{request}").as_str(), - origin::Route::default().with_auth(auth.clone()), - ) + .route(format!("{prefix}/{token}/{request}").as_str(), moq_net::origin::RouteOptions::default().with_auth(auth.clone())) .unwrap(), ); } diff --git a/rs/moq-net/benches/memory.rs b/rs/moq-net/benches/memory.rs index ab5f261b2b9..59ab2b41c08 100644 --- a/rs/moq-net/benches/memory.rs +++ b/rs/moq-net/benches/memory.rs @@ -103,7 +103,7 @@ struct Link { tracks: Vec, subscribers: Vec, payload: Bytes, - _broadcast: origin::Publication, + _broadcast: origin::Route, _sessions: (moq_net::Session, moq_net::Session), _origins: (origin::Producer, origin::Producer), } @@ -147,12 +147,12 @@ impl Link { } ); - let broadcast = publisher.create_broadcast("bench").unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); let tracks: Vec<_> = (0..streams) - .map(|index| broadcast.create_track(format!("{index}"), info.clone()).unwrap()) + .map(|index| broadcast.broadcast().create_track(format!("{index}"), info.clone()).unwrap()) .collect(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let consumer = subscriber.consume(); let remote = consumer.follow("bench", None).unwrap().available().await.unwrap(); diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index 31a74aa5ed5..d23c6bc0ebe 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -74,7 +74,7 @@ struct Fanout { producer: origin::Producer, consumer: origin::Consumer, driver: origin::Driver, - _publishers: Vec, + _publishers: Vec, subscribers: Vec, } @@ -82,7 +82,7 @@ fn fanout(publishers: usize, subscribers: usize) -> Fanout { let (producer, driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); let publishers = (0..publishers) - .map(|i| producer.publish(format!("room/{i}"), origin::Route::default()).unwrap()) + .map(|i| producer.route(format!("room/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) .collect(); let mut subscribers: Vec = (0..subscribers).map(|_| consumer.announced()).collect(); // Drain the replay so each iteration measures only what it adds. @@ -109,7 +109,7 @@ fn bench_announce(c: &mut Criterion) { b.iter(|| { let handle = fleet .producer - .publish("room/incoming", origin::Route::default()) + .route("room/incoming", moq_net::origin::RouteOptions::default()) .unwrap(); for cursor in &mut fleet.subscribers { cursor.next().now_or_never().flatten().expect("announce delivered"); @@ -134,7 +134,7 @@ fn bench_announce_covering(c: &mut Criterion) { group.bench_function(format!("{routes}routes_{readers}readers_covering{covering}"), |b| { let (producer, _driver) = origin::Producer::new(origin::Config::default()); let _routes: Vec<_> = (0..routes) - .map(|i| producer.requests(format!("room/{i}/mic.hang")).unwrap()) + .map(|i| producer.route_prefix(format!("room/{i}/mic.hang"), moq_net::origin::RouteOptions::default()).unwrap()) .collect(); let consumer = producer .consume() @@ -147,7 +147,7 @@ fn bench_announce_covering(c: &mut Criterion) { } b.iter(|| { for (name, delivered) in [("room/live.chat", true), ("room/mic.hang", covering)] { - let route = producer.requests(name).unwrap(); + let route = producer.route_prefix(name, moq_net::origin::RouteOptions::default()).unwrap(); for cursor in &mut cursors { assert_eq!(cursor.next().now_or_never().flatten().is_some(), delivered); } @@ -172,7 +172,7 @@ fn bench_pending_churn(c: &mut Criterion) { group.bench_function(format!("{routes}routes_{readers}readers"), |b| { let (producer, _driver) = origin::Producer::new(origin::Config::default()); let _routes: Vec<_> = (0..routes) - .map(|i| producer.publish(format!("z/{i}"), origin::Route::default()).unwrap()) + .map(|i| producer.route(format!("z/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) .collect(); let mut cursors: Vec<_> = (0..readers).map(|_| producer.consume().announced()).collect(); let mut sequence = 0u64; @@ -180,7 +180,7 @@ fn bench_pending_churn(c: &mut Criterion) { sequence += 1; drop( producer - .publish(format!("a/{sequence}"), origin::Route::default()) + .route(format!("a/{sequence}"), moq_net::origin::RouteOptions::default()) .unwrap(), ); }); @@ -256,7 +256,7 @@ fn bench_withdraw_wave(c: &mut Criterion) { for &hop in chain { hops.push(Hop::new(hop).unwrap()).unwrap(); } - origin::Route::default() + origin::RouteInfo::default() .with_instance(instance.clone(), 0) .with_hops(hops) }; @@ -380,7 +380,7 @@ fn bench_announce_mounted(c: &mut Criterion) { let _publishers: Vec<_> = (0..publishers) .map(|i| { producer - .publish(format!(".svc/p0/{i}"), origin::Route::default()) + .route(format!(".svc/p0/{i}"), moq_net::origin::RouteOptions::default()) .unwrap() }) .collect(); @@ -401,7 +401,7 @@ fn bench_announce_mounted(c: &mut Criterion) { } b.iter(|| { - let handle = producer.publish(".svc/p0/incoming", origin::Route::default()).unwrap(); + let handle = producer.route(".svc/p0/incoming", moq_net::origin::RouteOptions::default()).unwrap(); for cursor in &mut cursors { cursor.next().now_or_never().flatten().expect("announce delivered"); } @@ -431,7 +431,7 @@ fn bench_announce_fleet(c: &mut Criterion) { .flat_map(|project| (0..nodes).map(move |node| (project, node))) .map(|(project, node)| { producer - .publish(format!(".stats/p{project}/node/edge{node}"), origin::Route::default()) + .route(format!(".stats/p{project}/node/edge{node}"), moq_net::origin::RouteOptions::default()) .unwrap() }) .collect(); @@ -445,7 +445,7 @@ fn bench_announce_fleet(c: &mut Criterion) { .collect(); b.iter(|| { let handle = producer - .publish(".stats/p0/node/incoming", origin::Route::default()) + .route(".stats/p0/node/incoming", moq_net::origin::RouteOptions::default()) .unwrap(); drop(handle); }); @@ -595,10 +595,10 @@ const PATH: &str = ".stats/p0/node/edge0"; const INCUMBENT_COST: u64 = 2; /// A route as `peer` would have announced it: one hop, at `cost`. -fn peer_route(peer: u64, cost: u64) -> origin::Route { +fn peer_route(peer: u64, cost: u64) -> origin::RouteInfo { let mut hops = Hops::new(); hops.push(Hop::new(peer).expect("peer id")).expect("hop chain"); - origin::Route::default().with_hops(hops).with_cost(cost) + origin::RouteInfo::default().with_hops(hops).with_cost(cost) } /// An announcement of an unrelated prefix with `fronts` remote fronts parked on @@ -612,7 +612,7 @@ fn bench_announce_fronts(c: &mut Criterion) { let (producer, mut driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); // Served but never answered: every request under it parks a front. - let _served = producer.requests("room").unwrap(); + let _served = producer.route_prefix("room", moq_net::origin::RouteOptions::default()).unwrap(); let _requests: Vec<_> = (0..fronts) .map(|i| consumer.request(format!("room/{i}"), None)) .collect(); @@ -620,7 +620,7 @@ fn bench_announce_fronts(c: &mut Criterion) { // Run each front once so it parks on its upstream request. driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); b.iter(|| { - let handle = producer.publish("other/incoming", origin::Route::default()).unwrap(); + let handle = producer.route("other/incoming", moq_net::origin::RouteOptions::default()).unwrap(); driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); drop(handle); driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); @@ -631,15 +631,15 @@ fn bench_announce_fronts(c: &mut Criterion) { } /// Answer the claim's request for `path`, dropping any other it queued. -fn answer(claim: &origin::Requests, path: &str) -> origin::Publication { +fn answer(claim: &origin::Route, path: &str) -> origin::Route { loop { let request = claim - .requested_broadcast() + .requested() .now_or_never() .expect("the request reached the claim") .unwrap(); if request.path().as_str() == path { - return request.prepare().unwrap().publish().unwrap(); + return request.route(moq_net::origin::RouteOptions::hidden()).unwrap().announce().unwrap(); } } } @@ -656,7 +656,7 @@ fn bench_takeover(c: &mut Criterion) { |b| { let (producer, mut driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); - let claim = producer.requests("room").unwrap(); + let claim = producer.route_prefix("room", moq_net::origin::RouteOptions::default()).unwrap(); let waiter = kio::Waiter::noop(); let mut ask = |path: &str| { let request = consumer.request(path, None); @@ -710,7 +710,7 @@ fn bench_serve_idle(c: &mut Criterion) { let (producer, _driver) = origin::Producer::new(origin::Config::default()); // One route per announced path, exactly as a session lands a peer's. let dynamics: Vec<_> = (0..routes) - .map(|i| producer.requests(format!(".stats/p{}/node/edge{i}", i % 8)).unwrap()) + .map(|i| producer.route_prefix(format!(".stats/p{}/node/edge{i}", i % 8), moq_net::origin::RouteOptions::default()).unwrap()) .collect(); b.iter(|| { // A fresh waiter per sweep, so every poll pays a real registration: a @@ -756,7 +756,7 @@ fn bench_request(c: &mut Criterion) { for publishers in [100, 1_000] { for requesters in [1, 8, 32] { let mut fleet = fanout(publishers, 0); - let _covering = fleet.producer.publish("room", origin::Route::default()).unwrap(); + let _covering = fleet.producer.route("room", moq_net::origin::RouteOptions::default()).unwrap(); let waiter = kio::Waiter::noop(); let shape = format!("{publishers}p_{requesters}r"); group.throughput(Throughput::Elements(requesters)); @@ -839,7 +839,7 @@ const POOL_HOP: u64 = 1_000; struct Pool { producer: origin::Producer, driver: origin::Driver, - _members: Vec, + _members: Vec, _producers: Vec, _consumers: Vec, cursors: Vec, @@ -902,7 +902,7 @@ fn pool(members: usize, paths: usize, cursors: usize) -> Pool { } /// A pool member's claim: one hop, at the same cost as every other member. -fn pool_route(hop: u64) -> origin::Route { +fn pool_route(hop: u64) -> origin::RouteInfo { peer_route(hop, 3) } @@ -1066,14 +1066,14 @@ fn bench_handoff(c: &mut Criterion) { runtime.spawn(moq_net::time::run(driver)); let consumer = producer.consume(); let _others: Vec<_> = (0..publishers) - .map(|i| producer.publish(format!("room/{i}"), origin::Route::default()).unwrap()) + .map(|i| producer.route(format!("room/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) .collect(); b.iter_custom(|iterations| { runtime.block_on(async { let mut total = Duration::ZERO; for _ in 0..iterations { - let incumbent = producer.publish("room/live", origin::Route::default()).unwrap(); + let incumbent = producer.route("room/live", moq_net::origin::RouteOptions::default()).unwrap(); let track = incumbent.create_track("video", timed()).unwrap(); let mut first = track.append_group().unwrap(); first.write_frame(Timestamp::ZERO, b"one".as_ref()).unwrap(); @@ -1084,13 +1084,13 @@ fn bench_handoff(c: &mut Criterion) { subscription.recv_group().await.unwrap().expect("first group"); let started = std::time::Instant::now(); - let standby = producer.create_broadcast("room/live").unwrap(); + let standby = producer.route("room/live", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = standby.create_track("video", timed()).unwrap(); let mut second = track.create_group(moq_net::group::Info { sequence: 1 }).unwrap(); second.write_frame(Timestamp::ZERO, b"two".as_ref()).unwrap(); second.finish().unwrap(); // Announcing is what makes the standby a route the front can take. - standby.announce(origin::Route::default()).unwrap(); + standby.announce().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"); @@ -1125,7 +1125,7 @@ struct Watching { pair: MockPair, tracks: Vec, subscriptions: Vec, - _broadcasts: Vec, + _broadcasts: Vec, _origins: [origin::Producer; 2], } @@ -1148,7 +1148,7 @@ async fn watching(routes: usize, subscribers: usize) -> Watching { let mut broadcasts = Vec::new(); let mut tracks = Vec::new(); for index in 0..routes { - let broadcast = relay.publish(watched_path(index), origin::Route::default()).unwrap(); + let broadcast = relay.route(watched_path(index), moq_net::origin::RouteOptions::default()).unwrap(); tracks.push(broadcast.create_track("video", timed()).unwrap()); broadcasts.push(broadcast); } @@ -1287,7 +1287,7 @@ fn bench_relay(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.publish("room/live", origin::Route::default()).unwrap(); + let broadcast = producer.route("room/live", moq_net::origin::RouteOptions::default()).unwrap(); let sources: Vec<_> = (0..tracks) .map(|i| broadcast.create_track(format!("{i}"), timed()).unwrap()) .collect(); @@ -1347,7 +1347,7 @@ fn bench_passthrough(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.publish("room/live", origin::Route::default()).unwrap(); + let broadcast = producer.route("room/live", moq_net::origin::RouteOptions::default()).unwrap(); let source = broadcast.create_track("0", timed()).unwrap(); let mut subscriptions = runtime.block_on(async { let resolved = producer.consume().request("room/live", None).await.unwrap(); @@ -1402,7 +1402,7 @@ fn bench_parked(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.publish("room/live", origin::Route::default()).unwrap(); + let broadcast = producer.route("room/live", moq_net::origin::RouteOptions::default()).unwrap(); let sources: Vec<_> = (0..tracks) .map(|i| broadcast.create_track(format!("{i}"), None).unwrap()) .collect(); @@ -1447,7 +1447,7 @@ const COPY_WAIT: Duration = Duration::from_secs(5); /// One generation at [`COPY_PATH`], held so its copies stay subscribed. struct Generation { - broadcast: origin::Publication, + broadcast: origin::Route, tracks: Vec, } @@ -1455,7 +1455,7 @@ impl Generation { /// Create a hidden generation and leave a finished group on every track, so a /// reader that does look has something to resume. fn build(producer: &origin::Producer, tracks: usize) -> Self { - let broadcast = producer.create_broadcast(COPY_PATH).unwrap(); + let broadcast = producer.route(COPY_PATH, moq_net::origin::RouteOptions::hidden()).unwrap(); let mut held = Vec::with_capacity(tracks); for i in 0..tracks { let track = broadcast.create_track(format!("{i}"), timed()).unwrap(); @@ -1473,7 +1473,7 @@ impl Generation { /// Route the front to this generation without waiting. fn route(&self, instance: &Instance) { self.broadcast - .announce(origin::Route::default().with_instance(instance.clone(), 0)) + .announce(origin::RouteInfo::default().with_instance(instance.clone(), 0)) .unwrap(); } @@ -1610,7 +1610,7 @@ const RESUME_OVERLAP: [(usize, usize, usize); 17] = [ /// groups, each replacement in reverse arrival order. struct ResumeOverlap { _producer: origin::Producer, - _generations: Vec<(origin::Publication, track::Producer)>, + _generations: Vec<(origin::Route, track::Producer)>, readers: Vec, } @@ -1660,7 +1660,7 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { tokio::spawn(moq_net::time::run(driver)); let instance = Instance::random(); let generation = |order: &mut dyn Iterator| { - let broadcast = producer.create_broadcast(COPY_PATH).unwrap(); + let broadcast = producer.route(COPY_PATH, moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast.create_track("0", timed()).unwrap(); for sequence in order { let mut group = track @@ -1672,7 +1672,7 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { group.finish().unwrap(); } broadcast - .announce(origin::Route::default().with_instance(instance.clone(), 0)) + .announce(origin::RouteInfo::default().with_instance(instance.clone(), 0)) .unwrap(); (broadcast, track) }; diff --git a/rs/moq-net/benches/path.rs b/rs/moq-net/benches/path.rs index 2b8f5bd2621..5dc23d29279 100644 --- a/rs/moq-net/benches/path.rs +++ b/rs/moq-net/benches/path.rs @@ -130,9 +130,9 @@ fn requests() { let (producer, mut driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); let _pubs: Vec<_> = (0..1000) - .map(|i| producer.publish(format!("{s}/{i}"), origin::Route::default()).unwrap()) + .map(|i| producer.route(format!("{s}/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) .collect(); - let _covering = producer.publish(s, origin::Route::default()).unwrap(); + let _covering = producer.route(s, moq_net::origin::RouteOptions::default()).unwrap(); let waiter = kio::Waiter::noop(); let mut local = |request: &dyn Fn() -> kio::Pending| { @@ -171,7 +171,7 @@ fn fanout() { let (producer, _driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); let _pubs: Vec<_> = (0..100) - .map(|i| producer.publish(format!("room/{i}"), origin::Route::default()).unwrap()) + .map(|i| producer.route(format!("room/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) .collect(); let mut cursors: Vec = (0..100).map(|_| consumer.announced()).collect(); for cursor in &mut cursors { @@ -180,7 +180,7 @@ fn fanout() { // Per cursor, per publish and retract. allocs(&format!("origin/announce_fanout/{name}"), 500, 100, || { - let publication = producer.publish(s, origin::Route::default()).unwrap(); + let publication = producer.route(s, moq_net::origin::RouteOptions::default()).unwrap(); for cursor in &mut cursors { cursor.next().now_or_never().flatten().expect("announce delivered"); } diff --git a/rs/moq-net/benches/retirement.rs b/rs/moq-net/benches/retirement.rs index 9981821d53b..1ffdcff1e7b 100644 --- a/rs/moq-net/benches/retirement.rs +++ b/rs/moq-net/benches/retirement.rs @@ -22,7 +22,7 @@ fn retirement(c: &mut Criterion) { || { let (origin, driver) = origin::Producer::new(origin::Config::default()); let routes: Vec<_> = (0..routes) - .map(|i| origin.requests(format!("route/{i}")).unwrap()) + .map(|i| origin.route_prefix(format!("route/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) .collect(); let mut watches = Vec::new(); let mut controls = Vec::new(); @@ -46,7 +46,7 @@ fn retirement(c: &mut Criterion) { (origin, driver, routes, watches, controls, pending) }, |fixture| { - let replacement = fixture.0.requests("route/0/jobs").unwrap(); + let replacement = fixture.0.route_prefix("route/0/jobs", moq_net::origin::RouteOptions::default()).unwrap(); let refused = fixture .5 .iter() diff --git a/rs/moq-net/benches/session/mod.rs b/rs/moq-net/benches/session/mod.rs index d8554982cdc..4746c48f195 100644 --- a/rs/moq-net/benches/session/mod.rs +++ b/rs/moq-net/benches/session/mod.rs @@ -577,7 +577,7 @@ struct Cluster { relays: Vec, /// One track per broadcast, indexed like [`path`]. tracks: Vec, - _broadcasts: Vec, + _broadcasts: Vec, _origins: Vec, _pairs: Vec, next_hop: u64, @@ -1394,7 +1394,7 @@ impl Dash { struct DashRoom { _cluster: Cluster, tracks: Vec, - _broadcasts: Vec, + _broadcasts: Vec, dash: Viewer, payload: Bytes, } diff --git a/rs/moq-net/benches/stats.rs b/rs/moq-net/benches/stats.rs index b35f04a31a8..d0719d2fddf 100644 --- a/rs/moq-net/benches/stats.rs +++ b/rs/moq-net/benches/stats.rs @@ -16,7 +16,7 @@ const SHAPES: [(usize, usize); 4] = [(100, 1), (1_000, 1), (100, 10), (1_000, 10 struct Registry { registry: stats::Registry, _driver: origin::Driver, - _publishers: Vec, + _publishers: Vec, _cursors: Vec, } @@ -24,7 +24,7 @@ fn registry(broadcasts: usize, tiers: usize) -> Registry { let registry = stats::Registry::new(stats::Config::new()); let (producer, driver) = origin::Producer::new(origin::Config::default()); let publishers = (0..broadcasts) - .map(|i| producer.publish(format!("room/{i}"), origin::Route::default()).unwrap()) + .map(|i| producer.route(format!("room/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) .collect(); let cursors = (0..tiers) .map(|t| { diff --git a/rs/moq-net/benches/viewers.rs b/rs/moq-net/benches/viewers.rs index e20ebd01a68..922a03483cd 100644 --- a/rs/moq-net/benches/viewers.rs +++ b/rs/moq-net/benches/viewers.rs @@ -67,7 +67,7 @@ struct Room { producer: origin::Producer, driver: origin::Driver, broadcasts: usize, - _sources: Vec<(origin::Publication, moq_net::track::Producer)>, + _sources: Vec<(origin::Route, moq_net::track::Producer)>, } impl Room { @@ -75,7 +75,7 @@ impl Room { let (producer, driver) = origin::Producer::new(origin::Config::default()); let _sources = (0..broadcasts) .map(|i| { - let broadcast = producer.publish(format!("room/{i}"), origin::Route::default()).unwrap(); + let broadcast = producer.route(format!("room/{i}"), moq_net::origin::RouteOptions::default()).unwrap(); let track = broadcast.create_track("video", timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"frame".as_ref()).unwrap(); @@ -181,7 +181,7 @@ fn bench_churn(c: &mut Criterion) { room.leave(subscription); } b.iter(|| { - let covering = room.producer.requests("room").unwrap(); + let covering = room.producer.route_prefix("room", moq_net::origin::RouteOptions::default()).unwrap(); room.poll(); drop(covering); room.poll(); diff --git a/rs/moq-net/src/auth.rs b/rs/moq-net/src/auth.rs index 9039c685aaa..cd09ddb50ae 100644 --- a/rs/moq-net/src/auth.rs +++ b/rs/moq-net/src/auth.rs @@ -6,7 +6,7 @@ //! returns the [`Handle`]: [`grant`](Handle::grant) is the union of every token //! this side presented, and `add` presents another without //! reconnecting. The returned [`Credential`] is cloneable; dropping its last clone withdraws it. -//! A [`Route`](crate::origin::Route) can name it, so the request advertising the route +//! A [`Route`](crate::origin::RouteInfo) can name it, so the request advertising the route //! carries it too, and swapping it renews that request in place. //! //! A handle passed to `Client::with_auth` outlives its sessions: each session built on it @@ -1385,7 +1385,7 @@ fn attached(links: &mut BTreeMap, id: u64) -> &mut Attached { /// /// Cheap to clone, and every clone names the same credential. It stays presented on /// every session of its handle until the last clone drops, which closes its streams and -/// removes its grant from the union. A [`Route`](crate::origin::Route) holding one keeps +/// removes its grant from the union. A [`Route`](crate::origin::RouteInfo) holding one keeps /// it presented while the route stands, across the handle's sessions. #[derive(Clone)] pub struct Credential { diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index 8872219ed52..7c7435c394c 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -407,13 +407,23 @@ pub fn excluding(origin: crate::origin::Consumer, peer: crate::Hop) -> crate::or origin.excluding(peer) } +/// A peer's wire route: its hop chain, cost, and instance at an epoch, as a session +/// decodes one, for benches and tests that land or update forwarded routes. +pub fn route_info(hops: crate::Hops, cost: u64, instance: Option<(crate::Instance, u64)>) -> crate::origin::RouteInfo { + let info = crate::origin::RouteInfo::default().with_hops(hops).with_cost(cost); + match instance { + Some((instance, epoch)) => info.with_instance(instance, epoch), + None => info, + } +} + /// Land a claim with a peer's wire route, as a session does, for the origin bench. pub fn requests_route( origin: &crate::origin::Producer, prefix: impl Into, - route: crate::origin::Route, -) -> Result { - origin.requests_route(prefix, route, None) + route: crate::origin::RouteInfo, +) -> Result { + origin.forward(prefix, route, None) } /// Land a claim taking over the peer's `predecessor` claim, as a session lands an @@ -421,15 +431,15 @@ pub fn requests_route( pub fn takeover_route( origin: &crate::origin::Producer, prefix: impl Into, - route: crate::origin::Route, - predecessor: &crate::origin::Requests, -) -> Result { - origin.requests_route(prefix, route, Some(predecessor)) + route: crate::origin::RouteInfo, + predecessor: &crate::origin::Route, +) -> Result { + origin.forward(prefix, route, Some(predecessor)) } /// Replace a peer claim's route in place, as a session does on a route update. -pub fn update_route(dynamic: &crate::origin::Requests, route: crate::origin::Route) -> Result<(), crate::Error> { - dynamic.update_route(route) +pub fn update_route(dynamic: &crate::origin::Route, route: crate::origin::RouteInfo) -> Result<(), crate::Error> { + dynamic.update(route) } /// A session's snapshot of its peer's initial announcements, for the synced bench. @@ -1848,7 +1858,7 @@ pub struct RequestValidity { impl RequestValidity { /// Watch which instance this route's peer selects for a path. - pub fn new(route: &crate::origin::Requests, path: &crate::Path) -> Self { + pub fn new(route: &crate::origin::Route, path: &crate::Path) -> Self { Self { watch: crate::model::broadcast::RequestValidity::for_source(route, path), periods: Vec::new(), @@ -1884,7 +1894,7 @@ mod tests { let _driver = driver; let tier = crate::stats::Tier::new(crate::Path::from_static("t")); let session = registry.tier(tier.clone()).session(crate::Path::from_static("root")); - let _broadcast = origin.publish("room/1", crate::origin::Route::default()).unwrap(); + let _broadcast = origin.route("room/1", crate::origin::RouteOptions::default()).unwrap(); let mut cursor = origin.consume().with_stats(session).announced(); while cursor.next().now_or_never().flatten().is_some() {} diff --git a/rs/moq-net/src/ietf/cluster.rs b/rs/moq-net/src/ietf/cluster.rs index e7555d54c5a..d3a633dee82 100644 --- a/rs/moq-net/src/ietf/cluster.rs +++ b/rs/moq-net/src/ietf/cluster.rs @@ -12,7 +12,7 @@ //! ROUTE_COST of that path, as Key-Value-Pair message parameters. //! //! The semantics are the same ones moq-lite carries natively (see -//! [`crate::origin::Route`]); this module is only the moq-transport binding. +//! [`crate::origin::RouteInfo`]); this module is only the moq-transport binding. use crate::coding::{Decode, DecodeError, Decoder, Encode, EncodeError, Encoder}; use crate::{Hop, Hops}; @@ -158,11 +158,11 @@ impl Advert { /// instead of overflowing to best. /// /// Add the arriving link price to the peer's static route cost. - pub fn route(&self, link_cost: u64) -> crate::origin::Route { + pub fn route(&self, link_cost: u64) -> crate::origin::RouteInfo { let advertised = crate::origin::Cost::new(self.cost); // The prefix travels separately: it is stamped where the advertisement // attaches (the namespace). - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_hops(self.hops.hops().clone()) .with_cost(advertised.charged(link_cost)) } diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 6b5de430b70..3b1836d48b6 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -444,7 +444,7 @@ async fn read_fetch( /// namespace becoming (un)advertisable, or its path or cost moving. struct Watched { /// The route last announced for this namespace, as the origin delivered it. - route: crate::origin::Route, + route: crate::origin::RouteInfo, /// The advertisement last buffered for this namespace, or [`Advert::None`] while /// filtered. A different selection needs another message once this one is answered. sent: Advert, @@ -497,7 +497,7 @@ impl Refused { } impl Watched { - fn new(route: crate::origin::Route) -> Self { + fn new(route: crate::origin::RouteInfo) -> Self { Self { route, sent: Advert::None, @@ -1085,7 +1085,7 @@ impl Publisher { /// /// The origin's announce cursor already filters routes through the peer /// (control-plane split horizon); this only shapes what the wire can carry. - fn select(&self, route: &crate::origin::Route, peer: &cluster::Peer) -> Advert { + fn select(&self, route: &crate::origin::RouteInfo, peer: &cluster::Peer) -> Advert { // A route that already passed through us is a reflection. The origin // filters these on receive, so this is defensive. if self.self_origin != crate::Hop::UNKNOWN && route.hops.contains(&self.self_origin) { @@ -1448,7 +1448,7 @@ impl Publisher { }; // We just received a subscribe for this exact namespace, so the peer must have // already seen the announcement. The immediate lookup resolves it at once, or - // falls back to the route covering it (an `origin::Requests`), if any. + // falls back to the route covering it (an `origin::Route`), if any. let broadcast = match self .resolve( &mut stream, @@ -7482,7 +7482,7 @@ mod serve_tests { log: Log, track: track::Producer, _origin: origin::Producer, - _broadcast: crate::origin::Publication, + _broadcast: crate::origin::Route, } fn serve(version: Version) -> Serve { @@ -7491,11 +7491,11 @@ mod serve_tests { /// The same, with the track described by `info`. fn serve_track(version: Version, info: crate::track::Info) -> Serve { - serve_route(version, info, crate::origin::Route::default()) + serve_route(version, info, crate::origin::RouteInfo::default()) } /// The same, with the broadcast announced on `route`. - fn serve_route(version: Version, info: crate::track::Info, route: crate::origin::Route) -> Serve { + fn serve_route(version: Version, info: crate::track::Info, route: crate::origin::RouteInfo) -> Serve { serve_session(version, info, route, ScriptedSession::per_stream(vec![Vec::new()])) } @@ -7503,7 +7503,7 @@ mod serve_tests { fn serve_session( version: Version, info: crate::track::Info, - route: crate::origin::Route, + route: crate::origin::RouteInfo, session: ScriptedSession, ) -> Serve { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); @@ -8015,7 +8015,7 @@ mod serve_tests { let h = serve_session( version, crate::track::Info::timed(), - crate::origin::Route::default(), + crate::origin::RouteInfo::default(), session, ); // Well past the cache window, which only dates idleness once a sweep passes. @@ -8941,11 +8941,11 @@ mod serve_tests { let h = serve(version); let _old = h ._origin - .announce("old/first", crate::origin::Route::default()) + .announce("old/first", crate::origin::RouteInfo::default()) .unwrap(); let _new = h ._origin - .announce("new/second", crate::origin::Route::default()) + .announce("new/second", crate::origin::RouteInfo::default()) .unwrap(); settle().await; let session = ScriptedSession::new(Vec::new()); @@ -9096,7 +9096,7 @@ mod serve_tests { session.push(&update_with_tokens(&[TOKEN])); let request = taken_token(&mut running, &mut requests).await; - let other = h._origin.announce("other", crate::origin::Route::default()).unwrap(); + let other = h._origin.announce("other", crate::origin::RouteInfo::default()).unwrap(); settle().await; assert!(futures::poll!(running.as_mut()).is_pending()); drop(other); @@ -9268,7 +9268,7 @@ mod serve_tests { let request = taken_token(&mut running, &mut requests).await; session.log.fail_writes(); - let _other = h._origin.announce("other", crate::origin::Route::default()).unwrap(); + let _other = h._origin.announce("other", crate::origin::RouteInfo::default()).unwrap(); for _ in 0..10 { assert!( futures::poll!(running.as_mut()).is_pending(), @@ -9511,7 +9511,7 @@ mod serve_tests { let h = serve_session( version, track::Info::timed(), - crate::origin::Route::default(), + crate::origin::RouteInfo::default(), ScriptedSession::per_stream_eof(vec![Vec::new()]), ); let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) @@ -9612,7 +9612,7 @@ mod serve_tests { let mut h = serve(version); let claim = h ._origin - .requests_route("live", crate::origin::Route::default(), None) + .forward("live", crate::origin::RouteInfo::default(), None) .unwrap(); let auth = crate::auth::Link::new(false); auth.handle().authorize(¬hing()); @@ -9626,7 +9626,7 @@ mod serve_tests { assert_eq!(code, Some(unauthorized(version)), "{version}: denied up front"); use futures::FutureExt; assert!( - claim.requested_broadcast().now_or_never().is_none(), + claim.requested().now_or_never().is_none(), "{version}: a denied request reached the origin" ); } @@ -9635,7 +9635,7 @@ mod serve_tests { let mut h = serve(version); let claim = h ._origin - .requests_route("live", crate::origin::Route::default(), None) + .forward("live", crate::origin::RouteInfo::default(), None) .unwrap(); let auth = crate::auth::Link::new(false); h.publisher = h.publisher.clone().with_auth(auth.clone()); @@ -9654,7 +9654,7 @@ mod serve_tests { assert!(futures::poll!(answer.as_mut()).is_pending(), "{version}"); // Parked resolving the broadcast when the grant narrows. - let request = claim.requested_broadcast().await.unwrap(); + let request = claim.requested().await.unwrap(); auth.handle().authorize(¬hing()); let output = crate::broadcast::Info::new().produce(); let _track = output.create_track("video", None).unwrap(); @@ -9698,8 +9698,8 @@ mod serve_tests { async fn track_status_narrowed_while_answering_is_reset() { for version in ALL_VERSIONS { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let _track = broadcast.create_track("video", None).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let _track = broadcast.broadcast().create_track("video", None).unwrap(); settle().await; let bi = kio::Producer::new(true); @@ -9951,7 +9951,7 @@ mod serve_tests { let h = serve(version); let claim = h ._origin - .requests_route("", crate::origin::Route::default(), None) + .forward("", crate::origin::RouteInfo::default(), None) .unwrap(); settle().await; let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) @@ -9967,7 +9967,7 @@ mod serve_tests { ); let done = futures::poll!(serving.as_mut()); assert!( - claim.requested_broadcast().now_or_never().is_none(), + claim.requested().now_or_never().is_none(), "{version}: {path} reached the application" ); assert!(done.is_ready(), "{version}: {path} was left waiting"); @@ -11329,7 +11329,7 @@ mod serve_tests { let mut h = serve_session( version, crate::track::Info::timed(), - crate::origin::Route::default(), + crate::origin::RouteInfo::default(), ScriptedSession::new(Vec::new()), ); publish_groups(&mut h, 5); @@ -11369,8 +11369,8 @@ mod serve_tests { async fn a_kept_join_ends_with_its_token_while_publish_done_waits() { for version in JOINING_DRAFTS { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), b"frame".to_vec()).unwrap(); group.finish().unwrap(); @@ -11990,7 +11990,7 @@ mod serve_tests { } Some( h._origin - .requests_route("lobby", crate::origin::Route::default(), None) + .forward("lobby", crate::origin::RouteInfo::default(), None) .unwrap(), ) } @@ -12164,7 +12164,7 @@ mod serve_tests { let opt_out = Filter::is_draft20(version).then_some(false); for wanted in [Some(true), opt_out].into_iter().flatten() { let h = serve(version); - let track = h._broadcast.create_track("timed", info.clone()).unwrap(); + let track = h._broadcast.broadcast().create_track("timed", info.clone()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(stamp, b"stamped".as_slice()).unwrap(); group.finish().unwrap(); @@ -12394,8 +12394,8 @@ mod serve_tests { /// published with `info`. async fn across_a_hop(info: track::Info) -> track::Info { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); - let _track = broadcast.create_track("video", info).unwrap(); + let broadcast = upstream.route("room", crate::origin::RouteOptions::default()).unwrap(); + let _track = broadcast.broadcast().create_track("video", info).unwrap(); let (downstream, _sessions) = crate::lite::ietf::test_hop(&upstream, "room", [true, true]).await; let broadcast = downstream.consume().request("room", None).await.unwrap(); broadcast.track("video").unwrap().info().await.unwrap() @@ -12691,7 +12691,7 @@ mod serve_tests { async fn a_draft22_fetch_of_a_fetch_only_cache_is_not_capped() { let version = Version::Draft22; let h = serve(version); - let request = h._broadcast.reserve_track("cam").unwrap(); + let request = h._broadcast.broadcast().reserve_track("cam").unwrap(); let dynamic = request.requests(); let fetching = request.consume().fetch_group(4, None); let mut fetched = dynamic.requested_fill_group().await.unwrap().accept(None).unwrap(); @@ -12999,8 +12999,8 @@ mod serve_tests { async fn a_standalone_fetch_narrowed_while_responding_stops() { for version in FETCH_DRAFTS { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), b"0-0".to_vec()).unwrap(); group.finish().unwrap(); @@ -13095,8 +13095,8 @@ mod serve_tests { }, ] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), PAYLOAD.to_vec()).unwrap(); settle().await; @@ -13226,8 +13226,8 @@ mod serve_tests { }) { let token = end != JoinEnd::Ended; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), PAYLOAD.to_vec()).unwrap(); settle().await; @@ -13561,14 +13561,14 @@ mod serve_tests { Parked::Resolving => ( Some( origin - .requests_route("room", crate::origin::Route::default(), None) + .forward("room", crate::origin::RouteInfo::default(), None) .unwrap(), ), None, ), Parked::Acking | Parked::Ending => { - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); match parked { // One published group, so the subscription parks at the live edge. Parked::Acking => { @@ -13618,7 +13618,7 @@ mod serve_tests { // Drive the subscription to where it parks. let _route = match &claim { Some(claim) => { - let requested = std::pin::pin!(claim.requested_broadcast()); + let requested = std::pin::pin!(claim.requested()); match futures::future::select(requested, subscription.as_mut()).await { futures::future::Either::Left((route, _)) => Some(route.unwrap()), futures::future::Either::Right((res, _)) => panic!("{version} {parked:?}: ended: {res:?}"), @@ -13798,10 +13798,10 @@ mod serve_tests { match setup { Setup::Resolving => { let route = origin - .requests_route("room", crate::origin::Route::default(), None) + .forward("room", crate::origin::RouteInfo::default(), None) .unwrap(); let request = { - let requested = std::pin::pin!(route.requested_broadcast()); + let requested = std::pin::pin!(route.requested()); match futures::future::select(requested, serving.as_mut()).await { futures::future::Either::Left((request, _)) => request.unwrap(), futures::future::Either::Right((res, _)) => panic!("{version} {setup:?}: ended: {res:?}"), @@ -13810,8 +13810,8 @@ mod serve_tests { claim = Some((route, request)); } Setup::Subscribing => { - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let mut dynamic = broadcast.requests(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); let request = { let requested = std::pin::pin!(dynamic.requested_track()); match futures::future::select(requested, serving.as_mut()).await { @@ -13822,8 +13822,8 @@ mod serve_tests { asked = Some((broadcast, dynamic, request)); } Setup::Live => { - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let mut track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let mut track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); track.set_idle(); serve_until(serving.as_mut(), "the upstream subscription", || { track.subscription().is_some() @@ -14279,8 +14279,8 @@ mod serve_tests { /// its script. fn serve_on(version: Version, auth: crate::auth::Link, session: ScriptedSession) -> Serve { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let log = session.log.clone(); @@ -15906,7 +15906,7 @@ mod tests { let echoed = origin .announce( "from/peer", - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_hops(echoed_hops) .with_via(assigned), ) @@ -15915,7 +15915,7 @@ mod tests { let mut local_hops = crate::Hops::new(); local_hops.push(other).unwrap(); let local = origin - .announce("from/us", crate::origin::Route::default().with_hops(local_hops)) + .announce("from/us", crate::origin::RouteInfo::default().with_hops(local_hops)) .unwrap(); (publisher, consumer, vec![echoed, local]) @@ -15965,7 +15965,7 @@ mod tests { let _echoed = origin .announce( "from/peer", - crate::origin::Route::default().with_hops(hops.clone()).with_via(r1), + crate::origin::RouteInfo::default().with_hops(hops.clone()).with_via(r1), ) .unwrap(); @@ -16037,7 +16037,7 @@ mod tests { let _echoed = origin .announce( "from/peer", - crate::origin::Route::default().with_hops(hops).with_via(assigned), + crate::origin::RouteInfo::default().with_hops(hops).with_via(assigned), ) .unwrap(); @@ -16081,13 +16081,13 @@ mod tests { let mut clean = crate::Hops::new(); clean.push(crate::Hop::new(778).unwrap()).unwrap(); let _clean = origin - .announce("cam-clean", crate::origin::Route::default().with_hops(clean)) + .announce("cam-clean", crate::origin::RouteInfo::default().with_hops(clean)) .unwrap(); // A chain with no room left for our own hop cannot be forwarded. let mut full = crate::Hops::new(); while full.push(crate::Hop::new(100 + full.len() as u64).unwrap()).is_ok() {} let _full = origin - .announce("cam-full", crate::origin::Route::default().with_hops(full)) + .announce("cam-full", crate::origin::RouteInfo::default().with_hops(full)) .unwrap(); settle().await; @@ -16156,7 +16156,7 @@ mod tests { let _tainted = origin .announce( "route-flip-cam", - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_hops(tainted_hops) .with_via(assigned), ) @@ -16184,7 +16184,7 @@ mod tests { let mut clean_hops = crate::Hops::new(); clean_hops.push(clean_publisher).unwrap(); let clean = origin - .announce("route-flip-cam", crate::origin::Route::default().with_hops(clean_hops)) + .announce("route-flip-cam", crate::origin::RouteInfo::default().with_hops(clean_hops)) .unwrap(); settle().await; assert!(futures::poll!(run.as_mut()).is_pending()); @@ -16239,7 +16239,7 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("lonely-cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce("lonely-cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; // Every stream is answered with the same refusal, so a retry would show up as a @@ -16311,7 +16311,7 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _local = origin.announce("local-cam", crate::origin::Route::default()).unwrap(); + let _local = origin.announce("local-cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; // The only stream is the PUBLISH_NAMESPACE request we open ourselves. @@ -16355,7 +16355,7 @@ mod tests { async fn publish_namespace_withdraws_by_reset() { for version in [Version::Draft18, Version::Draft20, Version::Draft22] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let local = origin.announce("local-cam", crate::origin::Route::default()).unwrap(); + let local = origin.announce("local-cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; let session = @@ -16419,7 +16419,7 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _local = origin.announce("local-cam", crate::origin::Route::default()).unwrap(); + let _local = origin.announce("local-cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; let ok = crate::lite::test_transport::Log::default(); @@ -16510,8 +16510,8 @@ mod tests { scoped, } = case; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); - let _stats = origin.announce(".stats/node", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce("cam", crate::origin::RouteInfo::default()).unwrap(); + let _stats = origin.announce(".stats/node", crate::origin::RouteInfo::default()).unwrap(); settle().await; // Stream 1 is the peer's SUBSCRIBE_NAMESPACE; stream 2, if opened at all, is our @@ -16657,7 +16657,7 @@ mod tests { async fn a_non_solicit_subscribe_namespace_carries_namespace() { for version in [Version::Draft18] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let early = origin.announce("early-cam", crate::origin::Route::default()).unwrap(); + let early = origin.announce("early-cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![Vec::new()]); @@ -16701,7 +16701,7 @@ mod tests { "{version:?}: existing match", ); - let _late = origin.announce("late-cam", crate::origin::Route::default()).unwrap(); + let _late = origin.announce("late-cam", crate::origin::RouteInfo::default()).unwrap(); for _ in 0..100 { assert!(futures::poll!(run.as_mut()).is_pending()); if occurrences(&log, b"late-cam") >= 1 { @@ -16748,7 +16748,7 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let first = origin.announce("first-cam", crate::origin::Route::default()).unwrap(); + let first = origin.announce("first-cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; // The first advertisement has send capacity, and the peer answers it. @@ -16783,7 +16783,7 @@ mod tests { // Send capacity runs out before the second advertisement can send its header. set_gate(&gate, false); - let _second = origin.announce("second-cam", crate::origin::Route::default()).unwrap(); + let _second = origin.announce("second-cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; // Retiring the first needs no new stream, so the loop has to reach @@ -16849,7 +16849,7 @@ mod tests { // The state a refused or failed offer leaves behind: the peer holds nothing, and // the loop is coming back to it on a timer. let suffix: crate::Path = crate::Path::from_static("from/peer"); - let mut watch = Watched::new(crate::origin::Route::default().with_hops(hops)); + let mut watch = Watched::new(crate::origin::RouteInfo::default().with_hops(hops)); watch.deferred = true; let mut ns = Namespaces::new(cluster::Peer::default(), Target::Requests); @@ -16876,7 +16876,7 @@ mod tests { let cam = origin .announce( "solo-cam", - crate::origin::Route::default().with_instance(instance.clone(), 0), + crate::origin::RouteInfo::default().with_instance(instance.clone(), 0), ) .unwrap(); settle().await; @@ -16912,7 +16912,7 @@ mod tests { let _standby = origin .announce( "solo-cam", - crate::origin::Route::default().with_instance(instance, 0).with_cost(0), + crate::origin::RouteInfo::default().with_instance(instance, 0).with_cost(0), ) .unwrap(); @@ -16980,7 +16980,7 @@ mod tests { let _cold = origin .announce( "cam", - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_instance(instance.clone(), 0) .with_cost(4), ) @@ -17017,7 +17017,7 @@ mod tests { let _warm = origin .announce( "cam", - crate::origin::Route::default().with_instance(instance, 0).with_cost(0), + crate::origin::RouteInfo::default().with_instance(instance, 0).with_cost(0), ) .unwrap(); @@ -17057,7 +17057,7 @@ mod tests { let _cold = origin .announce( "cam", - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_instance(instance.clone(), 0) .with_cost(4), ) @@ -17111,7 +17111,7 @@ mod tests { let _warm = origin .announce( "cam", - crate::origin::Route::default().with_instance(instance, 0).with_cost(0), + crate::origin::RouteInfo::default().with_instance(instance, 0).with_cost(0), ) .unwrap(); @@ -17144,7 +17144,7 @@ mod tests { let _from_a = origin .announce( "cam", - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_instance(instance.clone(), 0) .with_hops(publisher_a) .with_cost(4), @@ -17182,7 +17182,7 @@ mod tests { let _from_b = origin .announce( "cam", - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_instance(instance, 0) .with_hops(publisher_b) .with_cost(0), @@ -17285,7 +17285,7 @@ mod tests { .present(bytes::Bytes::from_static(b"second-secret"), false) .unwrap(); let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(first)) + .announce("cam", crate::origin::RouteInfo::default().with_auth(first)) .unwrap(); settle().await; @@ -17307,7 +17307,7 @@ mod tests { "{version}: PUBLISH_NAMESPACE carries the auth" ); - cam.update(crate::origin::Route::default().with_auth(second)).unwrap(); + cam.update(crate::origin::RouteInfo::default().with_auth(second)).unwrap(); let expected = request_update( version, &ietf::PublishNamespaceUpdate { @@ -17350,7 +17350,7 @@ mod tests { .present(bytes::Bytes::from_static(b"foreign-secret"), false) .unwrap(); let _cam = origin - .announce("cam", crate::origin::Route::default().with_auth(foreign)) + .announce("cam", crate::origin::RouteInfo::default().with_auth(foreign)) .unwrap(); settle().await; @@ -17376,7 +17376,7 @@ mod tests { let origin = unheld_origin(); let auth = crate::auth::Link::ietf(false); let token = auth.present(bytes::Bytes::from_static(b"late-secret"), false).unwrap(); - let cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let cam = origin.announce("cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; let ok = publish_namespace_ok(VERSION).await; @@ -17385,7 +17385,7 @@ mod tests { poll_until(&mut run, &log, b"cam", 1).await; assert_eq!(occurrences(&log, b"late-secret"), 0, "named before it had an auth"); - cam.update(crate::origin::Route::default().with_auth(token)).unwrap(); + cam.update(crate::origin::RouteInfo::default().with_auth(token)).unwrap(); poll_until(&mut run, &log, b"cam", 2).await; assert_eq!(occurrences(&log, b"cam"), 2, "the request was not made again"); @@ -17403,10 +17403,10 @@ mod tests { let auth = crate::auth::Link::ietf(false); let present = |token: &'static [u8]| auth.present(bytes::Bytes::from_static(token), false).unwrap(); let a = origin - .announce("cam-a", crate::origin::Route::default().with_auth(present(b"a-first"))) + .announce("cam-a", crate::origin::RouteInfo::default().with_auth(present(b"a-first"))) .unwrap(); let b = origin - .announce("cam-b", crate::origin::Route::default().with_auth(present(b"b-first"))) + .announce("cam-b", crate::origin::RouteInfo::default().with_auth(present(b"b-first"))) .unwrap(); settle().await; @@ -17418,9 +17418,9 @@ mod tests { assert_eq!(occurrences(&log, b"cam-a"), 1, "cam-a was never advertised"); assert_eq!(occurrences(&log, b"cam-b"), 1, "cam-b was never advertised"); - a.update(crate::origin::Route::default().with_auth(present(b"a-second"))) + a.update(crate::origin::RouteInfo::default().with_auth(present(b"a-second"))) .unwrap(); - b.update(crate::origin::Route::default().with_auth(present(b"b-second"))) + b.update(crate::origin::RouteInfo::default().with_auth(present(b"b-second"))) .unwrap(); poll_until(&mut run, &log, b"b-second", 1).await; assert_eq!(occurrences(&log, b"a-second"), 1, "cam-a's renewal never went out"); @@ -17430,7 +17430,7 @@ mod tests { "cam-b's renewal waited on cam-a's answer" ); - let _c = origin.announce("cam-c", crate::origin::Route::default()).unwrap(); + let _c = origin.announce("cam-c", crate::origin::RouteInfo::default()).unwrap(); poll_until(&mut run, &log, b"cam-c", 1).await; assert_eq!( occurrences(&log, b"cam-c"), @@ -17449,7 +17449,7 @@ mod tests { for fin in [true, false] { let origin = unheld_origin(); - let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce("cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; let (session, peer) = memory::pair(memory::Config::default()); @@ -17517,7 +17517,7 @@ mod tests { let origin = unheld_origin(); let mut cams: HashMap<&str, _> = ["a-cam", "b-cam"] .into_iter() - .map(|name| (name, origin.announce(name, crate::origin::Route::default()).unwrap())) + .map(|name| (name, origin.announce(name, crate::origin::RouteInfo::default()).unwrap())) .collect(); settle().await; @@ -17602,7 +17602,7 @@ mod tests { let auth = crate::auth::Link::ietf(false); let token = auth.present(bytes::Bytes::from(vec![0; 70_000]), false).unwrap(); let _cam = origin - .announce("cam", crate::origin::Route::default().with_auth(token)) + .announce("cam", crate::origin::RouteInfo::default().with_auth(token)) .unwrap(); settle().await; @@ -17649,7 +17649,7 @@ mod tests { let auth = crate::auth::Link::ietf(false); let present = |token: &'static [u8]| auth.present(bytes::Bytes::from_static(token), false).unwrap(); let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(present(b"first"))) + .announce("cam", crate::origin::RouteInfo::default().with_auth(present(b"first"))) .unwrap(); settle().await; @@ -17672,7 +17672,7 @@ mod tests { // The idle request has read its OK and parked, so the reset waits for the renewal // to wake it. peer.close(crate::lite::test_transport::Close::Reset); - cam.update(crate::origin::Route::default().with_auth(present(b"second"))) + cam.update(crate::origin::RouteInfo::default().with_auth(present(b"second"))) .unwrap(); poll_until(&mut run, &log, b"second", 1).await; assert!(futures::poll!(run.as_mut()).is_pending()); @@ -17702,7 +17702,7 @@ mod tests { let auth = crate::auth::Link::ietf(false); let present = |token: &'static [u8]| auth.present(bytes::Bytes::from_static(token), false).unwrap(); let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(present(b"first"))) + .announce("cam", crate::origin::RouteInfo::default().with_auth(present(b"first"))) .unwrap(); settle().await; @@ -17710,7 +17710,7 @@ mod tests { let (publisher, log) = auth_publisher(&origin, &auth, vec![ok.clone(), ok], version); let mut run = std::pin::pin!(publisher.run_publish_namespaces()); poll_until(&mut run, &log, b"first", 1).await; - cam.update(crate::origin::Route::default().with_auth(present(b"second"))) + cam.update(crate::origin::RouteInfo::default().with_auth(present(b"second"))) .unwrap(); poll_until(&mut run, &log, b"second", 1).await; assert_eq!(occurrences(&log, b"second"), 1, "the renewal never went out"); @@ -17742,7 +17742,7 @@ mod tests { } .produce(); let _old = origin - .announce("cam", crate::origin::Route::default().with_cost(4)) + .announce("cam", crate::origin::RouteInfo::default().with_cost(4)) .unwrap(); settle().await; @@ -17771,7 +17771,7 @@ mod tests { assert_eq!(occurrences(&log, b"cam"), 1, "the advertisement never went out"); let _new = origin - .announce("cam", crate::origin::Route::default().with_cost(0)) + .announce("cam", crate::origin::RouteInfo::default().with_cost(0)) .unwrap(); for _ in 0..100 { assert!(futures::poll!(run.as_mut()).is_pending()); @@ -17798,7 +17798,7 @@ mod tests { let _cold = origin .announce( "cam", - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_instance(instance.clone(), 0) .with_cost(4), ) @@ -17838,7 +17838,7 @@ mod tests { let _warm = origin .announce( "cam", - crate::origin::Route::default().with_instance(instance, 0).with_cost(0), + crate::origin::RouteInfo::default().with_instance(instance, 0).with_cost(0), ) .unwrap(); @@ -17871,8 +17871,8 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _first = origin.announce("first-cam", crate::origin::Route::default()).unwrap(); - let _second = origin.announce("second-cam", crate::origin::Route::default()).unwrap(); + let _first = origin.announce("first-cam", crate::origin::RouteInfo::default()).unwrap(); + let _second = origin.announce("second-cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; // Every stream opens and then goes silent: an exhausted script parks rather than @@ -17936,7 +17936,7 @@ mod tests { let first = auth.present(bytes::Bytes::from_static(b"first"), false).unwrap(); let mut first_grant = first.grant(); let cam = origin - .announce("cam", crate::origin::Route::default().with_auth(first)) + .announce("cam", crate::origin::RouteInfo::default().with_auth(first)) .unwrap(); settle().await; @@ -17977,7 +17977,7 @@ mod tests { assert!(futures::poll!(run.as_mut()).is_pending()); if matches!(stage, Stage::UpdateWrite) { let second = auth.present(bytes::Bytes::from_static(b"second"), false).unwrap(); - cam.update(crate::origin::Route::default().with_auth(second)).unwrap(); + cam.update(crate::origin::RouteInfo::default().with_auth(second)).unwrap(); settle().await; assert!(futures::poll!(run.as_mut()).is_pending()); assert!( @@ -18029,7 +18029,7 @@ mod tests { async fn an_unanswered_advertisement_is_withdrawn() { for version in [Version::Draft18] { let origin = unheld_origin(); - let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce("cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; // The peer takes the request and answers nothing. @@ -18070,7 +18070,7 @@ mod tests { use std::sync::atomic::Ordering; for version in [Version::Draft18] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("lonely-cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce("lonely-cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; let session = crate::lite::test_transport::ScriptedSession::new(publish_namespace_ok(version).await).without_credit(); @@ -18121,7 +18121,7 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("lonely-cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce("lonely-cam", crate::origin::RouteInfo::default()).unwrap(); settle().await; // No send capacity from the start: an admitted header cannot finish. diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index fba6ed0d5e0..16cf8637f41 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -2127,7 +2127,7 @@ mod tests { /// enough: the question is only whether the bytes went out unasked. async fn announce_occurrences(peer_declared: Option) -> usize { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("solo-cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce("solo-cam", crate::origin::RouteInfo::default()).unwrap(); // An open gate: an unsolicited PUBLISH_NAMESPACE can reach the wire. let gate = kio::Producer::new(true); @@ -2232,7 +2232,7 @@ mod tests { fn auth_session(auth: bool) -> AuthSession { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let cam = origin.announce("solo-cam", crate::origin::Route::default()).unwrap(); + let cam = origin.announce("solo-cam", crate::origin::RouteInfo::default()).unwrap(); let gate = kio::Producer::new(true); let session = crate::lite::test_transport::SinkSession::gated_bi(gate.consume()); @@ -2892,8 +2892,8 @@ mod tests { // Stall before the type, then after it while the body has not arrived. for stalled in [Vec::new(), vec![ietf::Subscribe::ID as u8]] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); - let mut track = broadcast.create_track("video", None).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let mut track = broadcast.broadcast().create_track("video", None).unwrap(); let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()) .with_incoming_bidis(vec![stalled, subscribe.clone()]); let driver = bidi_driver(session, Some(origin.consume())); diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index c259e5adc4d..781aefd51f4 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -864,18 +864,18 @@ impl TrackState { struct BroadcastState { // The route announced into our origin for this namespace, post-charge: the newest // live advertisement's. - route: crate::origin::Route, + route: crate::origin::RouteInfo, // Each live advertisement of the namespace with the route it describes, oldest first. // A publisher replacing its instance withdraws one advertisement and makes another, on // separate streams that can arrive in either order: the newest stands until it goes, // and an update to an older one changes nothing. - adverts: Vec<(u64, crate::origin::Route)>, + adverts: Vec<(u64, crate::origin::RouteInfo)>, // The served route: dropping it (and the serve task's clone) retracts the // route and rejects its queued requests. `None` while the session's limit holds // it back, though the peer still advertises it. - dynamic: Option, + dynamic: Option, // Bumped each time the route attaches, so a serve task outlived by a limit that // took the route away and gave it back ends rather than serve beside the new one. @@ -944,7 +944,7 @@ enum Withdraw { struct Advertised { /// The route it describes, with this link's price already charged. The prefix /// is stamped where the advertisement attaches (the namespace). - route: crate::origin::Route, + route: crate::origin::RouteInfo, } /// One NAMESPACE a SUBSCRIBE_NAMESPACE stream holds, live on the wire until its @@ -1283,11 +1283,11 @@ impl Subscriber { /// its true length. An anonymous route already ranks below every identified one, /// so that understatement cannot beat a real path. Price such a link with /// [`crate::Client::with_cost`] among other anonymous routes. - fn session_route(&self, peer: &cluster::Peer) -> crate::origin::Route { + fn session_route(&self, peer: &cluster::Peer) -> crate::origin::RouteInfo { let mut hops = crate::Hops::new(); hops.push(crate::Hop::UNKNOWN) .expect("an empty hop chain has room for one entry"); - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_hops(hops) .with_via(self.via(peer)) // A peer without Cluster contributes only the arriving link price. @@ -2467,7 +2467,7 @@ impl Subscriber { if self.going_away.is_set() { route.cost = crate::origin::Cost::DRAIN; } - entry.dynamic = Some(self.origin.requests_route(path, route, None)?); + entry.dynamic = Some(self.origin.forward(path, route, None)?); entry.generation += 1; tracing::info!(route = %crate::path::Rooted(self.origin.root(), path), "namespace authorized again"); Ok(Some(entry.generation)) @@ -2528,7 +2528,7 @@ impl Subscriber { if *newest == id { entry.route = route.clone(); if let Some(dynamic) = &entry.dynamic { - dynamic.update_route(entry.route.clone())?; + dynamic.update(entry.route.clone())?; } } Ok(()) @@ -2560,7 +2560,7 @@ impl Subscriber { return Ok(()); } // Propagates Error::Unauthorized if the namespace is out of scope. - let dynamic = self.origin.requests_route(&path, route.clone(), None)?; + let dynamic = self.origin.forward(&path, route.clone(), None)?; entry.insert(BroadcastState { route: route.clone(), @@ -2615,7 +2615,7 @@ impl Subscriber { if *newest != state.route { state.route = newest.clone(); if let Some(dynamic) = &state.dynamic { - dynamic.update_route(state.route.clone())?; + dynamic.update(state.route.clone())?; } } if state.tokens == 0 @@ -2697,7 +2697,7 @@ impl Subscriber { entry.live = Default::default(); } match &mut entry.dynamic { - Some(dynamic) => dynamic.poll_requested_broadcast(waiter).map(Some), + Some(dynamic) => dynamic.poll_requested(waiter).map(|request| Some(request.ok_or(crate::Error::Closed))), None => Poll::Ready(None), } }) @@ -2780,7 +2780,7 @@ impl Subscriber { route.cost = crate::origin::Cost::DRAIN; } if let Some(dynamic) = &entry.dynamic { - let _ = dynamic.update_route(entry.route.clone()); + let _ = dynamic.update(entry.route.clone()); } } @@ -8967,7 +8967,7 @@ mod tests { // What we are publishing to the peer: a real upstream route. let upstream = crate::Hops::try_from(vec![crate::Hop::new(7).unwrap()]).unwrap(); let _source = origin - .announce("room/host", crate::origin::Route::default().with_hops(upstream.clone())) + .announce("room/host", crate::origin::RouteInfo::default().with_hops(upstream.clone())) .unwrap(); announced.expect_next_active("room/host").await; let _advertised = publishing.expect_next_active("room/host").await; @@ -9081,7 +9081,7 @@ mod tests { } /// The current best route covering `path`, if any (synchronous peek). - fn routed_now(consumer: &crate::origin::Consumer, path: &str) -> Option { + fn routed_now(consumer: &crate::origin::Consumer, path: &str) -> Option { use futures::FutureExt; match consumer.routes(path).ok()?.next().now_or_never()?? { crate::announce::Event::End(_) => None, @@ -9582,7 +9582,7 @@ mod tests { let path = crate::Path::from_static("room/host"); let first = Advertised { - route: crate::origin::Route::default() + route: crate::origin::RouteInfo::default() .with_hops(hop_path(&[7, 9]).hops().clone()) .with_cost(4), }; @@ -9593,7 +9593,7 @@ mod tests { // A new chain and cost: the route updates in place. let rerouted = Advertised { - route: crate::origin::Route::default() + route: crate::origin::RouteInfo::default() .with_hops(hop_path(&[7, 11]).hops().clone()) .with_cost(2), }; @@ -13223,9 +13223,9 @@ mod stitch_tests { ) -> (Vec, crate::lite::test_transport::Log) { use crate::lite::test_transport::Sent; let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "video", accepted_info( &ietf::Properties { @@ -13750,9 +13750,9 @@ mod stitch_tests { .flat_map(|(version, ranged)| [(version, ranged, false), (version, ranged, true)]) { let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); let track = broadcast - .create_track("video", accepted_info(&Default::default(), version)) + .broadcast().create_track("video", accepted_info(&Default::default(), version)) .unwrap(); let mut h = Harness::with_timescale(Fill::Done, vec![], None); h.subscriber.version = version; diff --git a/rs/moq-net/src/lite/fetch.rs b/rs/moq-net/src/lite/fetch.rs index b52cf825afc..1aca15b4251 100644 --- a/rs/moq-net/src/lite/fetch.rs +++ b/rs/moq-net/src/lite/fetch.rs @@ -13,7 +13,7 @@ use super::{Message, Version}; #[derive(Clone, Debug)] pub struct Fetch<'a> { pub broadcast: Path, - /// The instance the subscriber expects; see [`crate::origin::Route::instance`]. + /// The instance the subscriber expects; see [`crate::origin::RouteInfo::instance`]. /// Lite07+ only. pub instance: Option, pub track: Cow<'a, str>, diff --git a/rs/moq-net/src/lite/ietf.rs b/rs/moq-net/src/lite/ietf.rs index 64d97ad40f5..16bb1e14138 100644 --- a/rs/moq-net/src/lite/ietf.rs +++ b/rs/moq-net/src/lite/ietf.rs @@ -1100,14 +1100,14 @@ mod hop_tests { for offer in [[true, true], [true, false], [false, true]] { let negotiated = offer == [true, true]; let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.route("room", crate::origin::RouteOptions::default()).unwrap(); let mut info = track::Info::timed().with_timescale(Timescale::MILLI); info.max_age = Some(Duration::from_secs(7)); info.priority = 9; info.refresh = Some(0); let track_properties = draft22(vec![property(0x40, 3)]); info.properties = track_properties.clone(); - let track = broadcast.create_track("video", info).unwrap(); + let track = broadcast.broadcast().create_track("video", info).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group @@ -1207,8 +1207,8 @@ mod hop_tests { /// Subscribe across a negotiated hop to a track with `info`. async fn subscribe_across_info(info: track::Info) -> Result<(), crate::Error> { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); - let _track = broadcast.create_track("video", info).unwrap(); + let broadcast = upstream.route("room", crate::origin::RouteOptions::default()).unwrap(); + let _track = broadcast.broadcast().create_track("video", info).unwrap(); let (downstream, _sessions) = test_hop(&upstream, "room", [true, true]).await; let broadcast = kio::clock::timeout(TIMEOUT, downstream.consume().request("room", None)) @@ -1316,9 +1316,9 @@ mod hop_tests { #[kio::test] async fn plain_media_crosses_unchanged() { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.route("room", crate::origin::RouteOptions::default()).unwrap(); let mut track = broadcast - .create_track("video", track::Info::timed().with_timescale(Timescale::MILLI)) + .broadcast().create_track("video", track::Info::timed().with_timescale(Timescale::MILLI)) .unwrap(); let (downstream, sessions) = test_hop(&upstream, "room", [true, true]).await; let (copy, mut subscriber) = subscribe(&downstream).await; @@ -1365,12 +1365,12 @@ mod hop_tests { for objects in [&[0, 1, 2][..], &[1, 2, 0], &[1, 2]] { let negotiated = offer == [true, true]; let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.route("room", crate::origin::RouteOptions::default()).unwrap(); let info = track::Info { properties: draft22(Vec::new()), ..track::Info::timed().with_timescale(Timescale::MILLI) }; - let mut track = broadcast.create_track("video", info).unwrap(); + let mut track = broadcast.broadcast().create_track("video", info).unwrap(); let (downstream, sessions) = test_hop(&upstream, "room", offer).await; let (_copy, mut subscriber) = subscribe(&downstream).await; // Receiving a group proves the subscription and its alias are bound before @@ -1441,12 +1441,12 @@ mod hop_tests { for offer in [[true, true], [true, false], [false, true]] { let negotiated = offer == [true, true]; let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.route("room", crate::origin::RouteOptions::default()).unwrap(); let info = track::Info { properties: draft22(Vec::new()), ..track::Info::timed() }; - let mut track = broadcast.create_track("video", info).unwrap(); + let mut track = broadcast.broadcast().create_track("video", info).unwrap(); let mut head = track.create_group(0u64.into()).unwrap(); head.write_frame(ts(100), b"frame".to_vec()).unwrap(); head.finish().unwrap(); @@ -1518,11 +1518,11 @@ mod hop_tests { #[kio::test] async fn compressed_media_crosses_a_negotiated_hop() { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = upstream.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = upstream.route("room", crate::origin::RouteOptions::default()).unwrap(); let info = track::Info::timed() .with_timescale(Timescale::MILLI) .with_compress(true); - let mut track = broadcast.create_track("video", info).unwrap(); + let mut track = broadcast.broadcast().create_track("video", info).unwrap(); let (downstream, sessions) = test_hop(&upstream, "room", [true, true]).await; let (_copy, mut subscriber) = subscribe(&downstream).await; assert!(subscriber.info().compress); diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index ff5974a230b..5b778e3ce6b 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -1012,7 +1012,7 @@ struct Advertised { type Served = (Option, u64); /// What `route` serves; see [`Served`]. -fn served(route: &crate::origin::Route) -> Served { +fn served(route: &crate::origin::RouteInfo) -> Served { (route.instance.clone(), route.epoch) } @@ -1093,7 +1093,7 @@ impl AnnounceRun { // whatever it has pending for the routes the peer holds (an update, a restart, an end // still waiting out its hold) arrives through the loop as usual. let mut snapshot = origin.announced(); - let mut current: HashMap = HashMap::new(); + let mut current: HashMap = HashMap::new(); while let Some(event) = snapshot.try_next() { match event { announce::Event::Start(update) @@ -1175,7 +1175,7 @@ impl AnnounceRun { /// The chain and cost to put on the wire for `route`, or `None` when it must /// not be forwarded. - fn outgoing(&self, route: &crate::origin::Route, absolute: &crate::Path) -> Option<(Hops, crate::origin::Cost)> { + fn outgoing(&self, route: &crate::origin::RouteInfo, absolute: &crate::Path) -> Option<(Hops, crate::origin::Cost)> { let mut hops = route.hops.clone(); // A route that already passed through us is a reflection. The origin @@ -1807,7 +1807,7 @@ impl RequestServe { if requesting.is_none() { // The peer requested this exact path, so it has already seen an // announcement for it. The immediate lookup resolves it at once, is - // served on demand by the route covering it (an `origin::Requests`), or + // served on demand by the route covering it (an `origin::Route`), or // errors when there is none. let origin = ready!(self.shared.poll_serving_origin(waiter)); let path = R::target(msg).0.clone(); @@ -2847,7 +2847,7 @@ mod announce_test { let update = |prefix: &'static str, cost| announce::Announce { prefix: crate::Path::try_from(prefix).unwrap(), captures: None, - route: origin::Route::default().with_cost(cost), + route: origin::RouteInfo::default().with_cost(cost), }; let events = [ announce::Event::Start(update("a", 1)), @@ -2875,8 +2875,8 @@ mod announce_test { #[test] fn synced_survives_a_removed_initial_route_and_live_churn() { let origin = Hop::new(1).unwrap().produce(); - let removed = origin.announce("z/removed", origin::Route::default()).unwrap(); - let _initial = origin.announce("z/retained", origin::Route::default()).unwrap(); + let removed = origin.announce("z/removed", origin::RouteInfo::default()).unwrap(); + let _initial = origin.announce("z/retained", origin::RouteInfo::default()).unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(0usize); @@ -2899,7 +2899,7 @@ mod announce_test { drop(removed); let mut churn = Vec::new(); for limit in 1..=4 { - churn.push(origin.announce(format!("a/{limit}"), origin::Route::default()).unwrap()); + churn.push(origin.announce(format!("a/{limit}"), origin::RouteInfo::default()).unwrap()); *budget.write().ok().unwrap() = limit; assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); } @@ -2917,8 +2917,8 @@ mod announce_test { #[test] fn a_partial_regrant_cannot_overtake_an_initial_route() { let origin = Hop::new(1).unwrap().produce(); - let _a = origin.announce("a", origin::Route::default()).unwrap(); - let _b = origin.announce("b", origin::Route::default()).unwrap(); + let _a = origin.announce("a", origin::RouteInfo::default()).unwrap(); + let _b = origin.announce("b", origin::RouteInfo::default()).unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(1usize); @@ -2959,8 +2959,8 @@ mod announce_test { #[test] fn synced_cuts_a_regrant_burst_at_the_initial_bound() { let origin = Hop::new(1).unwrap().produce(); - let _a = origin.announce("a", origin::Route::default()).unwrap(); - let _b = origin.announce("b", origin::Route::default()).unwrap(); + let _a = origin.announce("a", origin::RouteInfo::default()).unwrap(); + let _b = origin.announce("b", origin::RouteInfo::default()).unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(0usize); @@ -2986,7 +2986,7 @@ mod announce_test { panic!("the changed grant is ready"); }; run.regrant(&mut stream, &consumer, restricted).unwrap(); - let _live = origin.announce("c", origin::Route::default()).unwrap(); + let _live = origin.announce("c", origin::RouteInfo::default()).unwrap(); run.regrant(&mut stream, &consumer, crate::auth::Permit::default()) .unwrap(); *budget.write().ok().unwrap() = 4; @@ -3015,8 +3015,8 @@ mod announce_test { #[test] fn a_seen_retraction_can_precede_synced() { let origin = Hop::new(1).unwrap().produce(); - let first = origin.announce("a", origin::Route::default()).unwrap(); - let unseen = origin.announce("b", origin::Route::default()).unwrap(); + let first = origin.announce("a", origin::RouteInfo::default()).unwrap(); + let unseen = origin.announce("b", origin::RouteInfo::default()).unwrap(); let consumer = origin.consume(); let mut announced = consumer.announced(); let budget = kio::Producer::new(1usize); @@ -3171,7 +3171,7 @@ mod announce_test { #[kio::test] async fn a_silent_upstream_never_delays_the_answer() { let origin = Hop::new(1).unwrap().produce(); - let _route = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let _route = origin.announce("cam", crate::origin::RouteInfo::default()).unwrap(); // An upstream that never answers its announce request. let _silent = origin.clone().with_link(crate::origin::Link::Upstream).snapshot(""); @@ -3205,7 +3205,7 @@ mod announce_test { let announcement = origin .announce( "cam", - crate::origin::Route::default().with_hops(pub_hops()).with_cost(7), + crate::origin::RouteInfo::default().with_hops(pub_hops()).with_cost(7), ) .unwrap(); @@ -3262,7 +3262,7 @@ mod announce_test { let late = h .origin - .announce("mic", crate::origin::Route::default().with_hops(pub_hops())) + .announce("mic", crate::origin::RouteInfo::default().with_hops(pub_hops())) .unwrap(); settle().await; match h.wire.take_announces().as_slice() { @@ -3286,7 +3286,7 @@ mod announce_test { let mut h = harness().await; h.announcement - .update(crate::origin::Route::default().with_hops(pub_hops()).with_cost(3)) + .update(crate::origin::RouteInfo::default().with_hops(pub_hops()).with_cost(3)) .unwrap(); kio::clock::sleep(crate::origin::Config::default().update_hold).await; settle().await; @@ -3305,7 +3305,7 @@ mod announce_test { async fn identical_update_is_quiet() { let h = harness().await; h.announcement - .update(crate::origin::Route::default().with_hops(pub_hops()).with_cost(7)) + .update(crate::origin::RouteInfo::default().with_hops(pub_hops()).with_cost(7)) .unwrap(); settle().await; h.assert_idle(); @@ -3319,7 +3319,7 @@ mod announce_test { async fn source_flip_restarts() { for version in [Version::Lite06, Version::Lite07] { let mut h = harness_on(version).await; - let route = crate::origin::Route::default().with_hops(pub_hops()).with_cost(7); + let route = crate::origin::RouteInfo::default().with_hops(pub_hops()).with_cost(7); let newer = h.origin.announce("cam", route.clone()).unwrap(); // A restart waits out the update hold like an update. kio::clock::sleep(crate::origin::Config::default().update_hold).await; @@ -3366,7 +3366,7 @@ mod announce_test { let mut h = harness_on(Version::Lite07).await; let instance = crate::Instance::random(); let route = |epoch| { - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_instance(instance.clone(), epoch) .with_hops(pub_hops()) .with_cost(7) @@ -3409,7 +3409,7 @@ mod announce_test { let mut h = harness_with(Version::Lite07, Some(auth.clone())).await; // Same chain and cost, so only the instance changed. Both land before the loop polls. - let route = crate::origin::Route::default().with_hops(pub_hops()).with_cost(7); + let route = crate::origin::RouteInfo::default().with_hops(pub_hops()).with_cost(7); let named = (!anonymous).then(crate::Instance::random); let route = match &named { Some(instance) => route.with_instance(instance.clone(), 0), @@ -3439,7 +3439,7 @@ mod announce_test { #[kio::test] async fn clamped_cost_change_is_quiet() { let mut h = harness().await; - let route = |cost| crate::origin::Route::default().with_hops(pub_hops()).with_cost(cost); + let route = |cost| crate::origin::RouteInfo::default().with_hops(pub_hops()).with_cost(cost); h.announcement.update(route(u64::MAX)).unwrap(); kio::clock::sleep(crate::origin::Config::default().update_hold).await; settle().await; @@ -3460,10 +3460,10 @@ mod announce_test { let tainted = Hops::try_from(vec![peer]).unwrap(); let _tainted = origin - .announce("echoed", crate::origin::Route::default().with_hops(tainted)) + .announce("echoed", crate::origin::RouteInfo::default().with_hops(tainted)) .unwrap(); let _clean = origin - .announce("local", crate::origin::Route::default().with_hops(pub_hops())) + .announce("local", crate::origin::RouteInfo::default().with_hops(pub_hops())) .unwrap(); let log = Log::default(); @@ -3499,7 +3499,7 @@ mod announce_test { let mut h = harness().await; let _late = h .origin - .announce("mic", crate::origin::Route::default().with_hops(pub_hops())) + .announce("mic", crate::origin::RouteInfo::default().with_hops(pub_hops())) .unwrap(); settle().await; match h.wire.take_announces().as_slice() { @@ -3515,7 +3515,7 @@ mod announce_test { let mut h = harness().await; h.announcement .update( - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_hops(pub_hops()) .with_cost(u64::MAX), ) @@ -6457,7 +6457,7 @@ mod serve_group_test { for objects in [&[1, 2][..], &[0, 1, 2]] { for max in [1, 1200] { let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); - let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); let info = track::Info { properties: Some(Arc::new(crate::model::object::TrackProperties { version: crate::ietf::Version::Draft22, @@ -6465,7 +6465,7 @@ mod serve_group_test { })), ..track::Info::timed() }; - let _track = broadcast.create_track("test", info).unwrap(); + let _track = broadcast.broadcast().create_track("test", info).unwrap(); let registry = crate::stats::Registry::new(Default::default()); let tagged = origin.consume().with_stats( registry @@ -7180,10 +7180,10 @@ mod serve_group_test { let mut starts = Vec::new(); for warm in [false, true] { let publisher = origin(1); - let broadcast = publisher.create_broadcast("room").unwrap(); - let mut track = broadcast.create_track("test", crate::track::Info::timed()).unwrap(); + let broadcast = publisher.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + let mut track = broadcast.broadcast().create_track("test", crate::track::Info::timed()).unwrap(); track.start_at(0).unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let relay = origin(2); let _upstream = connect(version, &publisher, &relay).await; let remote = relay.consume().follow("room", None).unwrap().available().await.unwrap(); @@ -7957,9 +7957,9 @@ mod tests { let mut echoed_hops = Hops::new(); echoed_hops.push(crate::Hop::UNKNOWN).unwrap(); let _echoed = origin - .requests_route( + .forward( "echoed", - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_hops(echoed_hops) .with_via(assigned), None, @@ -7969,7 +7969,7 @@ mod tests { let mut local_hops = Hops::new(); local_hops.push(upstream).unwrap(); let _local = origin - .requests_route("local", crate::origin::Route::default().with_hops(local_hops), None) + .forward("local", crate::origin::RouteInfo::default().with_hops(local_hops), None) .unwrap(); // A SETUP that declares no origin of its own, so only the assigned one applies. @@ -8020,7 +8020,7 @@ mod tests { let _tainted = origin .announce( "echoed", - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_hops(tainted_hops) .with_via(assigned), ) @@ -8029,7 +8029,7 @@ mod tests { let mut clean_hops = Hops::new(); clean_hops.push(clean_publisher).unwrap(); let _clean = origin - .announce("local", crate::origin::Route::default().with_hops(clean_hops)) + .announce("local", crate::origin::RouteInfo::default().with_hops(clean_hops)) .unwrap(); let gate = kio::Producer::new(true); @@ -8074,7 +8074,7 @@ mod tests { let _broadcasts: Vec<_> = (0..max / 500 + 1) .map(|i| { origin - .announce(format!("{name}{i}"), crate::origin::Route::default()) + .announce(format!("{name}{i}"), crate::origin::RouteInfo::default()) .unwrap() }) .collect(); @@ -8105,7 +8105,7 @@ mod tests { async fn announce_init_broadcast_ends() { let self_origin = crate::Hop::new(1).unwrap(); let origin = crate::origin::Config::new(self_origin).produce(); - let cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let cam = origin.announce("cam", crate::origin::RouteInfo::default()).unwrap(); let gate = kio::Producer::new(true); let session = SinkSession::gated_bi(gate.consume()); @@ -8141,7 +8141,7 @@ mod tests { async fn withdraw_before_init_sends_the_initial_burst() { let self_origin = crate::Hop::new(1).unwrap(); let origin = crate::origin::Config::new(self_origin).produce(); - let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + let _cam = origin.announce("cam", crate::origin::RouteInfo::default()).unwrap(); let gate = kio::Producer::new(true); let session = SinkSession::gated_bi(gate.consume()); @@ -8512,14 +8512,14 @@ mod tests { Wait::Broadcast => { _route = Some( origin - .requests_route("room", crate::origin::Route::default(), None) + .forward("room", crate::origin::RouteInfo::default(), None) .unwrap(), ) } Wait::Track => { - let broadcast = origin.create_broadcast("room").unwrap(); - let dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + let dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); held = Some((broadcast, dynamic)); } } @@ -8711,9 +8711,9 @@ mod tests { async fn track_info_outranks_the_track_groups() { let version = Version::Lite07; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); - let _track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + let _track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + broadcast.announce().unwrap(); let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); peer_setup.set(crate::lite::Setup::default()); let (_, goaway) = crate::goaway::Handle::new(true); @@ -8768,9 +8768,9 @@ mod tests { for blocked in [false, true] { let case = format!("{version:?}, {close:?}, blocked {blocked}"); let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); - let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + broadcast.announce().unwrap(); let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); peer_setup.set(crate::lite::Setup::default()); @@ -8862,9 +8862,9 @@ mod tests { #[kio::test] async fn a_subscribe_update_is_not_a_close() { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); peer_setup.set(crate::lite::Setup::default()); @@ -8966,7 +8966,7 @@ mod tests { serve: RequestServe, session: ScriptedSession, track: track::Producer, - _broadcast: crate::origin::Publication, + _broadcast: crate::origin::Route, _origin: crate::origin::Producer, } @@ -8984,9 +8984,9 @@ mod tests { async fn running() -> Running { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); peer_setup.set(crate::lite::Setup::default()); @@ -9237,8 +9237,8 @@ mod tests { #[kio::test] async fn a_cold_bounded_fetch_requests_the_prefix() { let origin = crate::origin::Config::new(Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); - let track = broadcast.create_track("video", track::Info::timed()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", track::Info::timed()).unwrap(); let dynamic = track.requests(); let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); peer_setup.set(crate::lite::Setup::default()); @@ -9270,7 +9270,7 @@ mod tests { end_frame: Some(3), }, "video", - broadcast.consume(), + broadcast.broadcast().consume(), ) .unwrap(); let request = dynamic.requested_fill_group().await.unwrap(); @@ -9284,9 +9284,9 @@ mod tests { async fn an_expired_fetch_resets_rather_than_finishing() { const VERSION: Version = Version::Lite07; let origin = crate::origin::Config::new(Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); - let track = broadcast.create_track("video", track::Info::timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", track::Info::timed()).unwrap(); + broadcast.announce().unwrap(); let mut open = track.append_group().unwrap(); open.write_frame(crate::Timestamp::ZERO, b"a".to_vec()).unwrap(); @@ -9427,9 +9427,9 @@ mod tests { use kio::Task; for version in [Version::Lite05, Version::Lite06, Version::Lite07] { let origin = crate::origin::Config::new(Hop::random()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); - let _dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + let _dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let request = lite::Subscribe { order: crate::track::Order::Descending, instance: None, @@ -9486,8 +9486,8 @@ mod tests { use kio::Task; let version = Version::Lite07; let origin = crate::origin::Config::new(Hop::random()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let request = lite::Tracks { broadcast: crate::Path::from_static("room"), instance: None, @@ -9539,9 +9539,9 @@ mod tests { use kio::Task; for version in [Version::Lite05, Version::Lite06, Version::Lite07] { let origin = crate::origin::Config::new(Hop::random()).produce(); - let broadcast = origin.create_broadcast("room").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let request = lite::Subscribe { order: crate::track::Order::Descending, instance: None, @@ -9725,9 +9725,9 @@ mod tests { #[kio::test] async fn send_group_ranks_by_the_subscriber_then_the_publisher() { let origin = crate::origin::Config::new(Hop::new(1).unwrap()).produce(); - let broadcast = origin.create_broadcast("a").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("a", crate::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let (publisher, log) = grouped_publisher(origin.consume()); let video = track::Info::timed().with_priority(60); diff --git a/rs/moq-net/src/lite/subscribe.rs b/rs/moq-net/src/lite/subscribe.rs index 2872f075f44..49a68b7deb1 100644 --- a/rs/moq-net/src/lite/subscribe.rs +++ b/rs/moq-net/src/lite/subscribe.rs @@ -15,7 +15,7 @@ use crate::track::Order; pub struct Subscribe<'a> { pub id: u64, pub broadcast: Path, - /// The instance the subscriber expects; see [`crate::origin::Route::instance`]. + /// The instance the subscriber expects; see [`crate::origin::RouteInfo::instance`]. /// Lite07+ only. pub instance: Option, pub track: Cow<'a, str>, diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 66269e56cf0..5faad339f75 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -692,10 +692,10 @@ impl Subscriber { link_cost: u64, responder: Option, announced: &Announced, - ) -> crate::origin::Route { + ) -> crate::origin::RouteInfo { let mut route = match announced.instance(path) { - Some((instance, epoch)) => crate::origin::Route::default().with_instance(instance, epoch), - None => crate::origin::Route::default(), + Some((instance, epoch)) => crate::origin::RouteInfo::default().with_instance(instance, epoch), + None => crate::origin::RouteInfo::default(), } .with_hops(hops) .with_cost(cost.charged(link_cost)) @@ -6533,8 +6533,8 @@ mod tests { let origin = origin::Config::new(relay).produce(); let assigned = crate::Hop::new(777).unwrap(); - let local = origin.publish("room/host", origin::Route::default()).unwrap(); - let track = local.create_track("video", crate::track::Info::timed()).unwrap(); + let local = origin.route("room/host", crate::origin::RouteOptions::default()).unwrap(); + let track = local.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"local".as_ref()).unwrap(); group.finish().unwrap(); @@ -7656,7 +7656,7 @@ enum Held { Declined, /// Outside the session's limit: the route as advertised, attached once a /// limit allows it. - Withheld(crate::origin::Route), + Withheld(crate::origin::RouteInfo), /// In the origin, serving requests. Attached(Box), } @@ -7696,7 +7696,7 @@ impl Announced { } /// Attach a route, queued for its first serve pass. - fn attach(&mut self, path: Path, route: crate::origin::Route, dynamic: crate::origin::Requests) { + fn attach(&mut self, path: Path, route: crate::origin::RouteInfo, dynamic: crate::origin::Route) { let wake = crate::util::QueueWake::new(path.clone(), self.ready.clone()); let route = AnnouncedRoute::new(route, dynamic, wake); route.waker.wake_by_ref(); @@ -7711,7 +7711,7 @@ impl Announced { &mut self, subscriber: &Subscriber, path: Path, - route: crate::origin::Route, + route: crate::origin::RouteInfo, predecessor: Option<&Path>, ) -> bool { if !subscriber @@ -7728,7 +7728,7 @@ impl Announced { Held::Attached(attached) => Some(&attached.dynamic), _ => None, }); - match subscriber.origin.requests_route(&path, route.clone(), predecessor) { + match subscriber.origin.forward(&path, route.clone(), predecessor) { Ok(dynamic) => { // In place, the successor continues the instance the predecessor's sources // serve: they live on with it rather than closing with the advertisement. @@ -7832,7 +7832,7 @@ impl Announced { entry.wake.popped(); let cx = std::task::Context::from_waker(&entry.waker); let route_waiter = entry.park.hold(&cx); - while let Poll::Ready(Ok(request)) = entry.dynamic.poll_requested_broadcast(route_waiter) { + while let Poll::Ready(Some(request)) = entry.dynamic.poll_requested(route_waiter) { // The request path is absolute; the wire (and our origin handle) // speak paths relative to the session's root. let Some(path) = request.path().strip_prefix(root) else { @@ -7914,9 +7914,9 @@ impl Announced { struct AnnouncedRoute { /// The route as last announced (post-charge), so a drain can re-price it /// without recomputing the chain. - route: crate::origin::Route, + route: crate::origin::RouteInfo, /// Dropping it retracts the route and rejects its queued requests. - dynamic: crate::origin::Requests, + dynamic: crate::origin::Route, /// Closes as the route goes, which closes every source it minted. live: kio::Producer<()>, /// Whether the GOAWAY drain already re-priced this route. @@ -7930,8 +7930,8 @@ struct AnnouncedRoute { impl AnnouncedRoute { fn new( - route: crate::origin::Route, - dynamic: crate::origin::Requests, + route: crate::origin::RouteInfo, + dynamic: crate::origin::Route, wake: Arc>, ) -> Self { Self { @@ -7946,10 +7946,10 @@ impl AnnouncedRoute { } /// Update the route metadata without changing its content identity. - fn update(&mut self, route: crate::origin::Route) { + fn update(&mut self, route: crate::origin::RouteInfo) { self.route = route.clone(); self.drained = false; - let _ = self.dynamic.update_route(route); + let _ = self.dynamic.update(route); } /// Re-price the route to [`crate::origin::Cost::DRAIN`] (the peer sent a @@ -7962,7 +7962,7 @@ impl AnnouncedRoute { self.drained = true; let mut route = self.route.clone(); route.cost = crate::origin::Cost::DRAIN; - let _ = self.dynamic.update_route(route); + let _ = self.dynamic.update(route); } } diff --git a/rs/moq-net/src/lite/track.rs b/rs/moq-net/src/lite/track.rs index 63770eb4bd4..09c0472edc0 100644 --- a/rs/moq-net/src/lite/track.rs +++ b/rs/moq-net/src/lite/track.rs @@ -17,7 +17,7 @@ const LEGACY_UNLIMITED: u64 = (1u64 << 53) - 1; #[derive(Clone, Debug)] pub struct Track<'a> { pub broadcast: Path, - /// The instance the subscriber expects; see [`crate::origin::Route::instance`]. + /// The instance the subscriber expects; see [`crate::origin::RouteInfo::instance`]. /// Lite07+ only. pub instance: Option, pub track: Cow<'a, str>, diff --git a/rs/moq-net/src/lite/tracks.rs b/rs/moq-net/src/lite/tracks.rs index 9aa4e8818c7..6a581efe9b3 100644 --- a/rs/moq-net/src/lite/tracks.rs +++ b/rs/moq-net/src/lite/tracks.rs @@ -19,7 +19,7 @@ const SYNCED: u64 = 0x4; #[derive(Clone, Debug)] pub struct Tracks { pub broadcast: Path, - /// The instance the subscriber expects; see [`crate::origin::Route::instance`]. + /// The instance the subscriber expects; see [`crate::origin::RouteInfo::instance`]. pub instance: Option, } diff --git a/rs/moq-net/src/model/broadcast.rs b/rs/moq-net/src/model/broadcast.rs index c0a836556e1..968ec9b5815 100644 --- a/rs/moq-net/src/model/broadcast.rs +++ b/rs/moq-net/src/model/broadcast.rs @@ -18,9 +18,7 @@ use std::{ }; use crate::Error; -use crate::origin::Route; -use super::origin_impl::Announcer; use super::{RequestQueue, WeakCache, WeakEntry}; #[path = "listing.rs"] @@ -256,11 +254,19 @@ impl Producer { self } - /// Attach the advertisement of this broadcast's exact path. Set by - /// `origin::Producer::create_broadcast`; a standalone broadcast has none. - pub(super) fn with_announcer(self, announcer: Announcer) -> Self { - *self.alive.announcer.lock() = Some(announcer); - self + /// Run `hook` once the broadcast closes: on [`Self::close`], an abort, or the last + /// producer-side handle dropping. Runs at once on a broadcast already closed. One hook + /// per broadcast: the route that owns it, which retracts when it closes. + pub(super) fn on_close(&self, hook: Box) { + { + let mut slot = self.alive.on_close.lock(); + debug_assert!(slot.is_none(), "a close hook was already installed"); + if !self.alive.state.lock().closing { + *slot = Some(hook); + return; + } + } + hook(); } /// Answer track requests only while `validity` holds, ending the broadcast once it @@ -272,74 +278,6 @@ impl Producer { self } - /// The route this broadcast is announced with, or `None` while it is not. - pub(super) fn route(&self) -> Option { - self.alive.announcer.lock().as_ref()?.route() - } - - /// Advertise this broadcast's exact path as a route, or replace the standing - /// advertisement's route. A route naming no instance keeps the broadcast's, so - /// `broadcast.announce(Route::default().with_cost(cost))` re-prices it; one naming - /// another instance announces a new stream. - /// - /// Until this is called the broadcast exists for nobody: announce cursors do - /// not list it and requests for its path fail with [`Error::Unroutable`], for - /// local consumers and peers alike. Call it once the tracks a subscriber needs - /// first (a catalog) exist, so the advertisement lands with them in place: - /// consumers act on it immediately. The route retracts on [`unannounce`](Self::unannounce), - /// [`close`](Self::close), or the last producer dropping. - /// - /// Fails with [`Error::Closed`] on a standalone broadcast (one not created - /// through an origin, so there is nothing to announce into), on a claim answer - /// still being [prepared](super::origin::Request::prepare), once the broadcast - /// has closed, or once the origin's driver has been dropped. - pub(super) fn announce(&self, route: Route) -> Result<(), Error> { - let mut announcer = self.alive.announcer.lock(); - let announcer = announcer.as_mut().ok_or(Error::Closed)?; - announcer.announce(route) - } - - /// Hand back an announcer withheld at creation and announce `route` once `admit` - /// agrees, decided under the origin's table lock. The announcer is installed only - /// when admitted; otherwise it drops, so this broadcast can never announce. - pub(super) fn announce_withheld( - &self, - mut announcer: Announcer, - route: Route, - predecessor: Option<&kio::Shared>, - admit: impl FnOnce() -> bool, - ) -> Result { - let refused = { - let mut slot = self.alive.announcer.lock(); - debug_assert!(slot.is_none(), "an announcer was already installed"); - // A close already retracted the slot, so an announcer installed now would - // outlive the broadcast. - if self.alive.state.lock().closing { - Err(Error::Closed) - } else { - match announcer.announce_if(route, predecessor, admit) { - Ok(true) => { - *slot = Some(announcer); - return Ok(true); - } - refused => refused, - } - } - }; - // Dropped outside the announcer lock, as in `Alive::retract`. - drop(announcer); - refused - } - - /// Retract this broadcast's advertisement, if any, from local consumers and - /// peers alike. New requests for the path fail with [`Error::Unroutable`] and - /// the broadcast the origin served from it ends, while tracks already in - /// flight carry on to their own end. [`announce`](Self::announce) brings it - /// back. - pub(super) fn unannounce(&self) { - self.alive.unannounce(); - } - /// The broadcast's static metadata, fixed when it was created. pub fn info(&self) -> &Info { &self.info @@ -468,7 +406,7 @@ impl Producer { /// End the broadcast for good, whether or not other clones are still alive. /// - /// Retracts its announcement and local discovery; a later [`super::origin::Publication::announce`] fails + /// Retracts its announcement and local discovery; a later [`super::origin::Route::announce`] fails /// with [`Error::Closed`]. Tracks already handed out carry on and end with their /// own finish or abort. Every later [`Consumer::track`], and every name reserved or /// still queued for a handler, answers [`Error::Unroutable`]: the same answer an @@ -516,9 +454,9 @@ impl Producer { struct Alive { token: kio::Producer<()>, state: kio::Shared, - // The advertisement of the broadcast's exact path, owned here so it retracts - // with the broadcast: on close or the last producer-side handle dropping. `None` for a standalone broadcast. - announcer: kio::Lock>, + // Run once the broadcast ends: on close or the last producer-side handle dropping. + // The route owning the broadcast retracts through it. `None` for a standalone broadcast. + on_close: kio::Lock>>, // How long a session's source still names the instance that minted it. Held on the // producer side, never by a consumer, so the selection it may hold is dropped by its // session rather than wherever the last consumer goes. @@ -530,18 +468,11 @@ impl Alive { Arc::new(Self { token: kio::Producer::default(), state, - announcer: kio::Lock::new(None), + on_close: kio::Lock::new(None), validity: RequestValidity::default(), }) } - /// Withdraw the path's advertisement, if any; the broadcast stays alive. - fn unannounce(&self) { - if let Some(announcer) = self.announcer.lock().as_mut() { - announcer.withdraw(); - } - } - /// End the broadcast. See [`Producer::close`]. fn close(&self) { { @@ -587,12 +518,13 @@ impl Alive { true } - /// Drop the announcer for good, so a later `announce` fails with `Closed`. Dropped - /// outside the announcer lock: the entry's removal re-syncs the origin's cursors under - /// the origin's own lock. + /// Run the close hook, if any. Outside the hook's lock: the route's retraction + /// re-syncs the origin's cursors under the origin's own lock. fn retract(&self) { - let announcer = self.announcer.lock().take(); - drop(announcer); + let hook = self.on_close.lock().take(); + if let Some(hook) = hook { + hook(); + } } } @@ -627,7 +559,7 @@ impl RequestValidity { } #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] - pub(crate) fn for_source(route: &crate::origin::Requests, path: &crate::Path) -> Self { + pub(crate) fn for_source(route: &crate::origin::Route, path: &crate::Path) -> Self { route .request_validity(path) .map(|selected| Self::Selected(std::sync::Arc::new(selected))) diff --git a/rs/moq-net/src/model/follow.rs b/rs/moq-net/src/model/follow.rs index 65f0f324d90..f19656d6fed 100644 --- a/rs/moq-net/src/model/follow.rs +++ b/rs/moq-net/src/model/follow.rs @@ -357,7 +357,7 @@ mod tests { use super::*; use crate::{ Error, Hop, Instance, Pattern, Patterns, - origin::{Cost, Route}, + origin::{Cost, RouteInfo}, }; /// The follower's next event, which must arrive within the origin's update hold. @@ -382,8 +382,8 @@ mod tests { } } - fn route(instance: &Instance) -> Route { - Route::default().with_instance(instance.clone(), 0) + fn route(instance: &Instance) -> RouteInfo { + RouteInfo::default().with_instance(instance.clone(), 0) } #[kio::test] @@ -393,11 +393,11 @@ mod tests { let instance = Instance::random(); // A prefix above the path covers it. - let pool = origin.requests_route("pool", route(&instance), None).unwrap(); + let pool = origin.forward("pool", route(&instance), None).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool".into())); // A route beneath the path serves another broadcast. - let _beneath = origin.publish("pool/job/thumbnail", Route::default()).unwrap(); + let _beneath = origin.route("pool/job/thumbnail", crate::origin::RouteOptions::default()).unwrap(); quiet(&mut follow).await; // The path itself, from the same instance, takes over without a restart. @@ -405,7 +405,7 @@ mod tests { assert_eq!(followed(&mut follow).await, ("update", "pool/job".into())); // The covering prefix no longer serves the path, so its changes are not seen. - pool.update_route(pool.route().with_cost(5)).unwrap(); + pool.update(pool.route().with_cost(5)).unwrap(); quiet(&mut follow).await; // Another instance at the path. @@ -416,7 +416,7 @@ mod tests { drop(exact); assert_eq!(followed(&mut follow).await, ("restart", "pool".into())); - pool.update_route(pool.route().with_cost(9)).unwrap(); + pool.update(pool.route().with_cost(9)).unwrap(); assert_eq!(followed(&mut follow).await, ("update", "pool".into())); drop(pool); @@ -428,8 +428,8 @@ mod tests { #[kio::test] async fn follow_starts_on_the_serving_route_when_joining_late() { let origin = Hop::new(1).unwrap().produce(); - let _pool = origin.requests_route("pool", Route::default(), None).unwrap(); - let _exact = origin.publish("pool/job", Route::default()).unwrap(); + let _pool = origin.forward("pool", RouteInfo::default(), None).unwrap(); + let _exact = origin.route("pool/job", crate::origin::RouteOptions::default()).unwrap(); let mut follow = origin.consume().routes("pool/job").unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); @@ -449,7 +449,7 @@ mod tests { // Both land before the follower reads again, and the cursor delivers the prefix's start // ahead of the path's end, but the path went unserved in between. drop(exact); - let _pool = origin.requests_route("pool", route(&instance), None).unwrap(); + let _pool = origin.forward("pool", route(&instance), None).unwrap(); assert_eq!(followed(&mut follow).await, ("end", "pool/job".into())); assert_eq!(followed(&mut follow).await, ("start", "pool".into())); @@ -470,7 +470,7 @@ mod tests { assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); let instance = Instance::random(); - let _pool = origin.requests_route("pool", route(&instance), None).unwrap(); + let _pool = origin.forward("pool", route(&instance), None).unwrap(); exact.announce(route(&instance)).unwrap(); assert_eq!(followed(&mut follow).await, ("restart", "pool/job".into())); @@ -484,10 +484,10 @@ mod tests { let origin = Hop::new(1).unwrap().produce(); let mut follow = origin.consume().routes("pool/job").unwrap(); - let _pool = origin.requests_route("pool", Route::default(), None).unwrap(); + let _pool = origin.forward("pool", RouteInfo::default(), None).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool".into())); - let _exact = origin.publish("pool/job", Route::default()).unwrap(); + let _exact = origin.route("pool/job", crate::origin::RouteOptions::default()).unwrap(); assert_eq!(followed(&mut follow).await, ("restart", "pool/job".into())); } @@ -500,11 +500,11 @@ mod tests { let _chat = origin .scope("", &chat) .unwrap() - .requests_route("room/alice", Route::default(), None) + .forward("room/alice", RouteInfo::default(), None) .unwrap(); let mut follow = origin.consume().routes("room/alice").unwrap(); - let first = origin.publish("room/alice", Route::default().with_cost(5)).unwrap(); + let first = origin.route("room/alice", crate::origin::RouteOptions::default().with_cost(5)).unwrap(); let event = kio::clock::timeout(Duration::from_secs(1), follow.next()) .await .unwrap() @@ -515,7 +515,7 @@ mod tests { ); // A republish is another instance of the route that serves the path. - let _second = origin.publish("room/alice", Route::default().with_cost(5)).unwrap(); + let _second = origin.route("room/alice", crate::origin::RouteOptions::default().with_cost(5)).unwrap(); drop(first); let event = kio::clock::timeout(Duration::from_secs(1), follow.next()) .await @@ -547,8 +547,8 @@ mod tests { } /// The next request a dynamic route receives for its path. - async fn requested(dynamic: &crate::origin::Requests) -> crate::origin::Request { - kio::clock::timeout(Duration::from_secs(1), dynamic.requested_broadcast()) + async fn requested(dynamic: &crate::origin::Route) -> crate::origin::Request { + kio::clock::timeout(Duration::from_secs(1), dynamic.requested()) .await .expect("never asked") .expect("the route closed") @@ -559,13 +559,13 @@ mod tests { #[kio::test] async fn announced_hands_out_a_held_takeover_once() { let origin = Hop::new(1).unwrap().produce(); - let dynamic = origin.requests("live").unwrap(); + let dynamic = origin.route_prefix("live", crate::origin::RouteOptions::default()).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 under another instance. let (_takeover, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; - origin.publish("live", Route::default()).unwrap() + origin.route("live", crate::origin::RouteOptions::default()).unwrap() }); none(&mut announced).await; } @@ -576,14 +576,14 @@ mod tests { #[kio::test] async fn announced_hands_out_a_gap_while_resolving_once() { let origin = Hop::new(1).unwrap().produce(); - let dynamic = origin.requests("").unwrap(); + let dynamic = origin.route_prefix("", crate::origin::RouteOptions::default()).unwrap(); let mut announced = origin.consume().follow("live", None).unwrap(); let (_arrival, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; drop(dynamic); kio::clock::sleep(super::super::origin_impl::DEFAULT_UPDATE_HOLD * 2).await; - origin.publish("live", Route::default()).unwrap() + origin.route("live", crate::origin::RouteOptions::default()).unwrap() }); none(&mut announced).await; } @@ -599,8 +599,8 @@ mod tests { let exact = origin.publish("live", route(&instance)).unwrap(); let first = available(&mut announced).await; - let dynamic = origin.requests_route("", route(&instance), None).unwrap(); - exact.unannounce(); + let dynamic = origin.forward("", route(&instance), None).unwrap(); + exact.withdraw(); let served = broadcast::Info::new().produce(); let (again, ()) = futures::join!(available(&mut announced), async { requested(&dynamic).await.serve(&served); @@ -638,7 +638,7 @@ mod tests { available(&mut announced).await.info().instance.as_ref(), Some(&instance) ); - first.unannounce(); + first.withdraw(); none(&mut announced).await; first.announce(route(&instance)).unwrap(); assert_eq!( @@ -650,12 +650,12 @@ mod tests { #[kio::test] async fn announced_reports_a_dropped_prepared_answer() { let origin = Hop::new(1).unwrap().produce(); - let claim = origin.requests("live").unwrap(); + let claim = origin.route_prefix("live", crate::origin::RouteOptions::default()).unwrap(); let mut announced = origin.consume().follow("live", None).unwrap(); let (result, ()) = futures::join!( kio::clock::timeout(Duration::from_secs(1), announced.available()), async { - let prepared = requested(&claim).await.prepare().unwrap(); + let prepared = requested(&claim).await.route(crate::origin::RouteOptions::hidden()).unwrap(); drop(prepared); } ); diff --git a/rs/moq-net/src/model/mod.rs b/rs/moq-net/src/model/mod.rs index d554e1c48e5..2a83d477c90 100644 --- a/rs/moq-net/src/model/mod.rs +++ b/rs/moq-net/src/model/mod.rs @@ -50,15 +50,15 @@ pub use datagram::*; pub use time::*; pub use timed::Timed; -/// Publishing broadcasts, announcing routes, and consuming both through an origin. +/// Routing broadcasts into an origin, and consuming them through it. pub mod origin { pub use super::follow::Following; #[cfg(feature = "async")] // private: capability gap pub(crate) use super::origin_impl::Lookup; pub use super::origin_impl::{ - Config, Consumer, Cost, Driver, HopLimit, Link, Preference, Prepared, Producer, Publication, Request, - Requesting, Requests, Route, Source, + Config, Consumer, Cost, Driver, HopLimit, Link, Preference, Producer, Request, Requesting, Route, RouteInfo, + RouteOptions, Source, }; } diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 3753d041fbe..ae169661ba9 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -460,45 +460,34 @@ impl From for Preference { } } -/// The stream a route serves, the path it took through the mesh, and what using it costs. +/// The stream a received route serves, the path it took through the mesh, and what +/// using it costs: read-only facts on an announcement. /// -/// The metadata half of an advertisement: [`Producer::requests`] pairs it with -/// the prefix it covers, [`Publication::announce`] with the -/// broadcast's exact path, and [`Consumer::announced`] yields both. A route -/// claims capability, not inventory: it says paths under its prefix are -/// servable, never that any specific broadcast exists. The common convention is -/// that a publisher announces each broadcast's exact path, so subscribers can -/// enumerate broadcasts; a service instead announces one short prefix and -/// answers whatever is requested beneath it. +/// Carried by [`Announce::route`]. A route claims capability, not inventory: it says +/// paths under its prefix are servable, never that any specific broadcast exists. The +/// common convention is that a publisher announces each broadcast's exact path with +/// [`Producer::route`], so subscribers can enumerate broadcasts; a service instead +/// announces one short prefix with [`Producer::route_prefix`] and answers whatever is +/// requested beneath it. +/// +/// Applications never build one: a [`Route`] takes [`RouteOptions`], and the origin +/// and the relays fill in the rest. #[derive(Clone, Debug, PartialEq, Eq)] -#[non_exhaustive] -pub struct Route { - /// The stream the route serves: routes with one instance serve one continuous - /// sequence space, so a subscription resumes from one to another. Changing it on a - /// standing advertisement is an [`AnnounceEvent::Restart`]. - /// - /// Always set on a route the origin delivers. Given to an announcing handle, `None` - /// keeps the instance its route already has: a fresh random one, minted when the - /// handle was made, unless [`Self::with_instance`] set another. - pub instance: Option, +pub struct RouteInfo { + /// The stream the route serves; see [`Self::instance`]. Always set on a route the + /// origin delivers. Given to a route a session lands, `None` mints one. + pub(crate) instance: Option, /// Orders the incarnations of one instance: among its routes at one prefix only the /// highest epoch is eligible. Never compared across instances, and never shown to /// readers. pub(crate) epoch: u64, - /// The chain of origins the route has traversed, oldest first. Each relay - /// appends its own [`crate::Hop`] when forwarding; used for loop detection - /// and as the selection tie-break. A 0 entry is the anonymous mark and - /// travels unchanged; see [`Self::is_anonymous`]. - pub hops: Hops, + /// The chain of origins the route has traversed, oldest first; see [`Self::hops`]. + pub(crate) hops: Hops, - /// What pulling content via this route costs, accumulated per link: lower wins - /// among routes of the same anonymity, with ties broken by a broadcast published - /// on this origin, then hop length, then a hash of the instance and the requested - /// path (except for a route that entered here, at its own path), and finally the - /// most recently announced route. See [`Cost`]. - pub cost: Cost, + /// What pulling content via this route costs; see [`Self::cost`]. + pub(crate) cost: Cost, /// The credential the request advertising this route carries, from /// `auth::Handle::add`, or `None` for the session's scope. @@ -510,7 +499,7 @@ pub struct Route { /// REQUEST_UPDATE. A handle passed to /// `Client::with_auth` presents it on every session it backs, so the route keeps it /// across a reconnect. Local, like [`Self::source`]: a relay never forwards it. - pub auth: Option, + pub(crate) auth: Option, /// The announcing session's declared or assigned identity. /// @@ -523,7 +512,7 @@ pub struct Route { pub(crate) source: Source, } -impl Default for Route { +impl Default for RouteInfo { fn default() -> Self { Self { instance: None, @@ -552,39 +541,56 @@ pub enum Source { Peer(Hop), } -impl Route { - /// Serve a stable `instance` at `epoch`, in place of the one the handle minted. - /// - /// Only for a publisher that continues the instance's sequence space across restarts, - /// announcing a higher `epoch` each time, such as a counter persisted on disk. Readers - /// stitch every route of one instance together, so a publisher that restarts its - /// group sequences under an old instance splices unrelated groups into their tracks. - /// The highest epoch wins over every older one of the instance, cheaper or not. - /// - /// Do not start a named instance with `~`: that marks one a relay minted - /// ([`Instance::is_minted`]), which moq-crypto's signing refuses to bind and a catalog's instance - /// check skips. The mark is not refused, since a relay forwarding a route keeps the - /// instance it received. - pub fn with_instance(mut self, instance: Instance, epoch: u64) -> Self { +impl RouteInfo { + /// The stream the route serves: routes with one instance serve one continuous + /// sequence space, so a subscription resumes from one to another. Pass it to + /// [`Consumer::request`] to pin this stream. + pub fn instance(&self) -> &Instance { + self.instance.as_ref().expect("a delivered route has an instance") + } + + /// The chain of origins the route has traversed, oldest first. Each relay + /// appends its own hop when forwarding; used for loop detection and as the + /// selection tie-break. A 0 entry is the anonymous mark and travels unchanged; + /// see [`Self::is_anonymous`]. A route announced on this origin has none. + pub fn hops(&self) -> &Hops { + &self.hops + } + + /// What pulling content via this route costs, accumulated per link: lower wins + /// among routes of the same anonymity, with ties broken by a broadcast published + /// on this origin, then hop length, then a hash of the instance and the requested + /// path (except for a route that entered here, at its own path), and finally the + /// most recently announced route. See [`Cost`]. + pub fn cost(&self) -> Cost { + self.cost + } + + /// Serve a stable `instance` at `epoch`; see [`RouteOptions::with_instance`]. + #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] + pub(crate) fn with_instance(mut self, instance: Instance, epoch: u64) -> Self { self.instance = Some(instance); self.epoch = epoch; self } /// Replace the hop chain. - pub fn with_hops(mut self, hops: Hops) -> Self { + #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] + pub(crate) fn with_hops(mut self, hops: Hops) -> Self { self.hops = hops; self } /// Set the cost: lower wins among routes covering the same prefix and anonymity. - pub fn with_cost(mut self, cost: impl Into) -> Self { + #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] + pub(crate) fn with_cost(mut self, cost: impl Into) -> Self { self.cost = cost.into(); self } /// Set the credential the advertising request carries; see [`Self::auth`]. - pub fn with_auth(mut self, auth: crate::auth::Credential) -> Self { + #[cfg(test)] + pub(crate) fn with_auth(mut self, auth: crate::auth::Credential) -> Self { self.auth = Some(auth); self } @@ -610,15 +616,84 @@ impl Route { self.hops.iter().any(|hop| *hop == Hop::UNKNOWN) } - /// Where the route entered this origin, as delivered by [`Consumer::announced`]. - /// - /// Set by the origin, not the announcer: a route handed to - /// [`Producer::requests`] reports [`Source::Local`] until the origin delivers it. + /// Where the route entered this origin. pub fn source(&self) -> Source { self.source } } +/// How an application advertises a [`Route`]: its visibility at creation, its price, +/// its credential, and, rarely, a stable instance. +/// +/// The default announces at once, at cost 0, under the session's scope, serving a +/// fresh random instance minted when the route is created. +#[derive(Clone, Debug, Default)] +pub struct RouteOptions { + hidden: bool, + cost: Cost, + auth: Option, + instance: Option<(Instance, u64)>, +} + +impl RouteOptions { + /// Create the route hidden: it exists for nobody until [`Route::announce`]. + /// + /// For a publisher that fills its catalog first, or answers a negotiation, before + /// readers may find it. + pub fn hidden() -> Self { + Self { + hidden: true, + ..Self::default() + } + } + + /// Set the cost: lower wins among routes covering the same prefix and anonymity. + /// A publisher prices content it already produces at zero, and content it would + /// have to start producing on demand higher. + pub fn with_cost(mut self, cost: impl Into) -> Self { + self.cost = cost.into(); + self + } + + /// Set the credential the advertising request carries, from `auth::Handle::add`. + /// + /// Only a session built on the handle that issued it presents it, as the token on + /// its moq-transport PUBLISH_NAMESPACE; every other session advertises the route + /// under its own scope. + pub fn with_auth(mut self, auth: crate::auth::Credential) -> Self { + self.auth = Some(auth); + self + } + + /// Serve a stable `instance` at `epoch`, in place of a freshly minted one. + /// + /// Only for a publisher that continues the instance's sequence space across restarts, + /// announcing a higher `epoch` each time, such as a counter persisted on disk. Readers + /// stitch every route of one instance together, so a publisher that restarts its + /// group sequences under an old instance splices unrelated groups into their tracks. + /// The highest epoch wins over every older one of the instance, cheaper or not. + /// Naming an instance grants nothing: publishing still needs the path's grant. + /// + /// Do not start a named instance with `~`: that marks one a relay minted + /// ([`Instance::is_minted`]), which moq-crypto's signing refuses to bind and a catalog's instance + /// check skips. + pub fn with_instance(mut self, instance: Instance, epoch: u64) -> Self { + self.instance = Some((instance, epoch)); + self + } + + /// The route metadata these options advertise, under `instance` at `epoch`. + fn info(&self, instance: &Instance, epoch: u64) -> RouteInfo { + RouteInfo { + instance: Some(instance.clone()), + epoch, + cost: self.cost, + auth: self.auth.clone(), + ..RouteInfo::default() + } + } +} + static NEXT_CONSUMER_ID: AtomicU64 = AtomicU64::new(0); #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] @@ -1199,7 +1274,7 @@ impl OriginConsumerState { let announce = Announce { prefix, captures, - route: Route { + route: RouteInfo { hops: meta.0, cost: meta.1, via: Hop::UNKNOWN, @@ -1223,9 +1298,9 @@ impl OriginConsumerState { /// One announced route in the origin's table, absolute prefix. struct RouteEntry { id: u64, - /// The stream this route serves; see [`Route::instance`]. + /// The stream this route serves; see [`RouteInfo::instance`]. instance: Instance, - /// Which incarnation of the instance; see [`Route::epoch`]. + /// Which incarnation of the instance; see [`RouteInfo::epoch`]. epoch: u64, prefix: Path, /// The absolute patterns the announcing producer may serve. The prefix is @@ -1233,7 +1308,7 @@ struct RouteEntry { scope: Patterns, hops: Hops, cost: Cost, - /// The auth the request advertising the route carries; see [`Route::auth`]. + /// The auth the request advertising the route carries; see [`RouteInfo::auth`]. auth: Option, /// The rank of the link the entry arrived on; see [`Producer::with_preference`]. preference: Preference, @@ -2032,7 +2107,7 @@ pub struct Announce { pub captures: Option>, /// The route serving the prefix. On a retraction this carries its last /// advertised metadata. - pub route: Route, + pub route: RouteInfo, } /// Publishes broadcasts and announces routes into an origin. @@ -2223,29 +2298,28 @@ impl Producer { } } - /// Create an unannounced publication at `path` and its broadcast fill surface. + /// Create a route at exactly `path`, owning a new broadcast to fill. /// - /// This is how local content enters an origin. The returned [`Publication`] - /// controls its advertisement; [`Publication::broadcast`] borrows the fill producer. - /// It serves a fresh random [`Route::instance`], kept across announce, unannounce - /// and re-announce since its sequences continue, so a new publication is a new - /// stream that never splices into an old one. A publisher that continues one - /// sequence space across restarts may name a stable instance instead - /// ([`Route::with_instance`]). + /// This is how local content enters an origin. Fill the broadcast through + /// [`Route::broadcast`]. The route serves a fresh random instance, minted here and + /// kept for its lifetime, across [`Route::withdraw`] and [`Route::announce`], since + /// its sequences continue: a new route is a new stream that never splices into an + /// old one. A publisher that continues one sequence space across restarts may name + /// a stable instance instead ([`RouteOptions::with_instance`]). /// - /// The broadcast exists for nobody until [`Publication::announce`]: - /// until then no announce cursor lists it and a request for its path fails - /// with [`Error::Unroutable`], for a consumer of this origin exactly as for a - /// peer. Announce once the tracks a subscriber needs first exist. To serve - /// paths on demand without publishing each one, use [`Self::requests`]. + /// Announced at once unless created [`RouteOptions::hidden`]. A hidden route exists + /// for nobody until [`Route::announce`]: until then no announce cursor lists it and + /// a request for its path fails with [`Error::Unroutable`], for a consumer of this + /// origin exactly as for a peer. Create it hidden when the tracks a subscriber needs + /// first, such as a catalog, are not there yet. To serve paths on demand without + /// publishing each one, use [`Self::route_prefix`]. /// - /// Announcing is visible to local consumers before it returns; only - /// lifecycle work (track serving, teardown) waits for the [`Driver`] to be - /// polled. Register a [`broadcast::Producer::requests`] handler before - /// announcing, so the first consumer finds the tracks it serves. + /// Announcing is visible to local consumers before it returns; only lifecycle work + /// (track serving, teardown) waits for the [`Driver`] to be polled. Register a + /// [`broadcast::Producer::requests`] handler before announcing, so the first + /// consumer finds the tracks it serves. /// - /// End the broadcast with [`broadcast::Producer::close`] or by dropping it; - /// either way the path closes once it was the last source. + /// Dropping the last clone of the route retracts it, as does closing its broadcast. /// /// Fails with [`Error::Unauthorized`] if `path` is outside the prefixes this /// producer may publish under (after [`scope`](Self::scope)) or beneath a @@ -2255,17 +2329,14 @@ impl Producer { /// pattern can spell (`*` or `**`), [`Error::NavigationSegment`] for a literal `.` or `..`, /// or [`Error::Closed`] once the origin's /// [`Driver`] has been dropped. - pub fn create_broadcast(&self, path: impl TryInto>) -> Result { + pub fn route(&self, path: impl TryInto>, options: RouteOptions) -> Result { let full = self.root.join(&path::convert(path)?)?; - let (broadcast, announcer) = self.create_withheld(full)?; - Ok(Publication { - broadcast: broadcast.with_announcer(announcer), - }) + self.exact(full, options, None) } - /// A new broadcast at `full` with its announcer withheld, so it cannot announce - /// until the announcer is handed back. - fn create_withheld(&self, full: Path) -> Result<(broadcast::Producer, Announcer), Error> { + /// An exact route at the absolute `full` path, answering `request` on its first + /// announce when it is a job's. + fn exact(&self, full: Path, options: RouteOptions, request: Option) -> Result { publish_path(&full)?; if !self.scope.permits(&full) || !self.scope.publishes(&full) { return Err(Error::Unauthorized); @@ -2285,8 +2356,7 @@ impl Producer { // The broadcast is a route table entry at its exact path from the start, // hidden from cursors and requests until it announces. The entry lives - // as long as the broadcast: its announcer drops on close, abort, or the - // last handle. + // as long as the route, or until the broadcast closes. let announcing = Announcing { hop: self.hop, shared: self.shared.clone(), @@ -2305,9 +2375,10 @@ impl Producer { instance: None, frames: self.frames.clone(), }; - let source = info.produce().with_stats(ingress.clone()); + let source = info.produce().with_stats(ingress); + let (instance, epoch) = options.instance.clone().unwrap_or_else(|| (Instance::random(), 0)); let entry = announcing.announce( - Route::default(), + options.info(&instance, epoch), Serving { server: None, source: Some(source.consume()), @@ -2315,19 +2386,33 @@ impl Producer { }, None, )?; - let announcer = Announcer { - entry, - ingress, + let hidden = options.hidden; + let route = Route::new(RouteState { + announcement: entry, + broadcast: Some(source.clone()), + server: None, + publisher: None, + control: kio::Lock::new(RouteControl { + options, + instance, + epoch, + request, + }), _keepalive: self.tasks.keepalive(), - }; - Ok((source, announcer)) - } - - /// Create and advertise a broadcast in one call. - pub fn publish(&self, path: impl TryInto>, route: Route) -> Result { - let broadcast = self.create_broadcast(path)?; - broadcast.announce(route)?; - Ok(broadcast) + }); + // Closing the broadcast retracts the route, and refuses the request a job's route + // has not answered yet. The broadcast holds only a weak reference, so it never + // keeps the route alive. + let weak = Arc::downgrade(&route.state); + source.on_close(Box::new(move || { + if let Some(state) = weak.upgrade() { + state.ended(); + } + })); + if !hidden { + route.announce()?; + } + Ok(route) } /// Mint a standalone source broadcast for a served-route request: it carries @@ -2369,7 +2454,7 @@ impl Producer { pub(crate) fn announce( &self, prefix: impl TryInto>, - route: Route, + route: RouteInfo, ) -> Result { Announcing::new(self, prefix)?.announce( route, @@ -2445,70 +2530,97 @@ impl Producer { self.link != Link::Local } - /// Advertise a route over `prefix` and serve the requests beneath it. + /// Create a route over `prefix` that serves the requests beneath it. /// - /// A route is always a prefix: it claims `prefix` and every path beneath it - /// (the empty prefix claims every path). A service that only serves some of + /// A route is always a prefix on the wire: it claims `prefix` and every path beneath + /// it (the empty prefix claims every path). A service that only serves some of /// them, say `pid/*.hang`, advertises the covering prefix and refuses the /// rest as they are requested; consumers narrow with a [`Pattern`] locally. /// This is the one shape every wire carries, so a route means the same /// thing on every hop. /// - /// The advertisement is visible to [`Consumer::announced`] and forwarded by - /// sessions for as long as the returned [`Requests`] (and every clone) lives. - /// A consumer resolving a path under it through this route is handed to the - /// handler as a [`Request`] to materialize on demand: [`Request::prepare`] - /// under a new instance, fill, then [`Prepared::publish`] the exact path. Each - /// answer is its own stream, so restarting one output never splices into a copy - /// of the last. The route itself serves a random instance, minted here. This is how a service answers a whole + /// A consumer resolving a path under it through this route is handed to + /// [`Route::requested`] as a [`Request`]: answer it by serving a broadcast already + /// held ([`Request::serve`]), under this route's instance, or by creating the path's + /// own exact route ([`Request::route`]), under a fresh instance, so restarting one + /// job never splices into a copy of the last. This is how a service answers a whole /// subtree without publishing each path ahead of time; a publisher that - /// knows its broadcasts advertises each one's exact path with - /// [`Publication::announce`] instead, so subscribers can enumerate - /// them. + /// knows its broadcasts creates each one's exact route with [`Self::route`] + /// instead, so subscribers can enumerate them. + /// + /// The route is priced, credentialed and shown like an exact one. It is visible + /// for as long as the returned [`Route`] (and every clone) lives, unless withdrawn. /// /// The prefix must overlap this producer's pattern scope. Individual requests /// remain authoritative and are refused when they do not match the scope. - pub fn requests(&self, prefix: impl TryInto>) -> Result { - self.requests_inner(prefix, Route::default(), true, None) + pub fn route_prefix( + &self, + prefix: impl TryInto>, + options: RouteOptions, + ) -> Result { + let (instance, epoch) = options.instance.clone().unwrap_or_else(|| (Instance::random(), 0)); + let info = options.info(&instance, epoch); + let advertised = !options.hidden; + self.serving_route(prefix, info, Some(self.clone()), advertised, None, options) } - /// Land a peer's claim with its wire route metadata, continuing what the peer's - /// `predecessor` claim served beneath it when the peer took it over. + /// Land a peer's route with its wire metadata, continuing what the peer's + /// `predecessor` route served beneath it when the peer took it over. #[cfg(any(feature = "async", test))] - pub(crate) fn requests_route( + pub(crate) fn forward( &self, prefix: impl TryInto>, - route: Route, - predecessor: Option<&Requests>, - ) -> Result { - self.requests_inner(prefix, route, false, predecessor.map(|claim| &claim.state)) + mut info: RouteInfo, + predecessor: Option<&Route>, + ) -> Result { + // A handle that names no instance serves one of its own. + let instance = info.instance.get_or_insert_with(Instance::random).clone(); + let options = RouteOptions { + hidden: false, + cost: info.cost, + auth: info.auth.clone(), + instance: Some((instance, info.epoch)), + }; + let predecessor = predecessor.and_then(|route| route.state.server.as_ref()); + self.serving_route(prefix, info, None, true, predecessor, options) } - fn requests_inner( + fn serving_route( &self, prefix: impl TryInto>, - route: Route, - publishes: bool, + info: RouteInfo, + publisher: Option, + advertised: bool, predecessor: Option<&kio::Shared>, - ) -> Result { + options: RouteOptions, + ) -> Result { let announcing = Announcing::new(self, prefix)?; let serve = kio::Shared::::default(); serve.lock().requests.add_handler(); + let instance = info.instance.clone().expect("the caller names the instance"); + let epoch = info.epoch; let announcement = announcing.announce( - route, + info, Serving { server: Some(serve.clone()), source: None, - advertised: true, + advertised, }, predecessor, )?; - Ok(Requests { + Ok(Route::new(RouteState { announcement, - state: serve, - publisher: publishes.then(|| self.clone()), + broadcast: None, + server: Some(serve), + publisher, + control: kio::Lock::new(RouteControl { + options, + instance, + epoch, + request: None, + }), _keepalive: self.tasks.keepalive(), - }) + })) } /// Returns a producer rooted at `root` and restricted to matching `patterns`. @@ -2681,7 +2793,7 @@ impl Announcing { /// beneath it, when it is one. fn announce( &self, - route: Route, + route: RouteInfo, serving: Serving, predecessor: Option<&kio::Shared>, ) -> Result { @@ -2733,14 +2845,14 @@ impl Announcing { drop(shared); // Ingress announce guard: held while the route is advertised. - let guard = serving - .advertised - .then(|| self.stats.ingress(&self.requested).announce()); + let ingress = self.stats.ingress(&self.requested); + let guard = serving.advertised.then(|| ingress.announce()); Ok(AnnounceProducer { shared: self.shared.clone(), entries, - guard, + ingress, + guard: kio::Lock::new(guard), }) } } @@ -2752,122 +2864,341 @@ struct Serving { advertised: bool, } -/// An origin-owned broadcast publication, with a fill surface and its announcement capability. +/// A route on an origin: an exact path owning one broadcast, or a prefix serving the +/// requests beneath it. /// -/// Clones share one broadcast and route. Closing the fill broadcast retracts the -/// route for every clone. Dropping the last fill handle does the same; a cloned -/// fill handle retains the publication even after the last `Publication` handle -/// drops. Use [`Self::unannounce`] to withdraw earlier. +/// On the publishing side ownership runs origin → route → broadcast → track → group → +/// frame. Created by [`Producer::route`] (exact), [`Producer::route_prefix`] (prefix), +/// or [`Request::route`] (the path's own exact route, answering a request). +/// +/// A route mints its instance when it is created and keeps it for its lifetime, across +/// [`withdraw`](Self::withdraw), [`announce`](Self::announce) and reconnects, since it +/// owns the same broadcast and its sequences continue. A new run is a new route. +/// +/// ``` +/// # fn run(origin: moq_net::origin::Producer) -> Result<(), moq_net::Error> { +/// use moq_net::origin::RouteOptions; +/// +/// // Fill the catalog before readers can find it. +/// let route = origin.route("live/alice", RouteOptions::hidden())?; +/// let _catalog = route.broadcast().create_track("catalog.json", Default::default())?; +/// route.announce()?; // visible now, same instance +/// route.set_cost(5)?; // re-prices in place +/// route.withdraw(); // hidden; announce() again continues the same stream +/// # Ok(()) +/// # } +/// ``` +/// +/// Clones share one route. Dropping the last clone retracts it, and so does closing +/// its broadcast. The broadcast lives on for the subscriptions already on it for as +/// long as another of its producer handles does. It keeps the origin's [`Driver`] +/// running, so a publisher can drop every [`Producer`] and keep serving. #[derive(Clone)] -pub struct Publication { - broadcast: broadcast::Producer, +#[must_use = "dropping the last clone of a route retracts it"] +pub struct Route { + state: Arc, } -impl Publication { - /// The broadcast to fill, without announcement control. +struct RouteState { + /// The advertisement, retracted on drop. + announcement: AnnounceProducer, + /// The broadcast an exact route owns. + broadcast: Option, + /// The queue a prefix route's requests arrive on. + server: Option>, + /// Present for an application's prefix route, whose requests may create their own + /// exact routes. A session-forwarded request can only serve its peer's broadcast. + publisher: Option, + control: kio::Lock, + /// A route is lifecycle work: the origin's driver keeps running for as long as one + /// lives, even once every producer handle is gone. + _keepalive: Keepalive, +} + +/// What a route advertises when it announces, changed under one lock so concurrent +/// announces, withdrawals and re-prices land in order. +struct RouteControl { + options: RouteOptions, + instance: Instance, + epoch: u64, + /// The request a job's route answers when it first announces. + request: Option, +} + +impl RouteControl { + fn info(&self) -> RouteInfo { + self.options.info(&self.instance, self.epoch) + } +} + +impl RouteState { + /// The broadcast closed: retract the route for good and refuse a job's unanswered + /// request. + fn ended(&self) { + let request = self.control.lock().request.take(); + self.announcement.retract(false); + // Dropped outside every lock: refusing it wakes the requesters. + drop(request); + } +} + +impl Route { + fn new(state: RouteState) -> Self { + Self { state: Arc::new(state) } + } + + /// The broadcast this exact route owns, to fill with tracks. + /// + /// # Panics + /// + /// On a prefix route ([`Producer::route_prefix`]), which owns none: answer its + /// requests instead. pub fn broadcast(&self) -> &broadcast::Producer { - &self.broadcast + self.state + .broadcast + .as_ref() + .expect("a prefix route owns no broadcast; answer its requests") } - /// Advertise this publication's path or replace its route. - pub fn announce(&self, route: Route) -> Result<(), Error> { - self.broadcast.announce(route) + /// The stream this route serves, minted when it was created unless + /// [`RouteOptions::with_instance`] named one. + pub fn instance(&self) -> Instance { + self.state.control.lock().instance.clone() } - /// Withdraw this publication while keeping its filled tracks alive. - pub fn unannounce(&self) { - self.broadcast.unannounce(); + /// Make the route visible, or keep it so. Idempotent. + /// + /// Visible to local consumers before it returns. A job's route ([`Request::route`]) + /// also answers the requesters waiting on its path. + /// + /// Fails with [`Error::Closed`] once the route's broadcast closed or the origin's + /// [`Driver`] was dropped, and with [`Error::Unroutable`], announcing nothing, when a + /// job's request was released or its prefix route retracted meanwhile: that route can + /// never announce. + pub fn announce(&self) -> Result<(), Error> { + let mut control = self.state.control.lock(); + let info = control.info(); + let Some(request) = control.request.take() else { + return self.state.announcement.update_if(info, None, || true).map(|_| ()); + }; + let answer = self.broadcast().consume(); + let mut resolved = None; + // Answered under the table lock that every release takes first, so the route + // lands only for a request still pending and no release can slip in between. + // The answer continues what the prefix route served for the path: requesters + // waiting on it, and whatever resolved through the prefix route's current instance + // beneath it. Answered and taken over under one lock, so nothing resolves in between. + let admitted = self.state.announcement.update_if(info, Some(&request.home), || { + // The exact route owns this answer's availability. Caching it under the + // prefix would keep serving it after this route is withdrawn. + resolved = request + .home + .lock() + .take(&request.path, &request.producer) + .map(|()| Ok(answer)); + resolved.is_some() + }); + drop(control); + let Some(resolved) = resolved.filter(|_| matches!(admitted, Ok(true))) else { + // A failed answer can never announce. + self.state.announcement.retract(false); + return Err(admitted.err().unwrap_or(Error::Unroutable)); + }; + // Woken outside every lock: a front re-entering the table must not find it held. + if let Ok(mut pending) = request.producer.write() { + pending.resolved.get_or_insert(resolved); + } + Ok(()) } - /// The route this publication currently advertises, if any. - pub fn route(&self) -> Option { - self.broadcast.route() + /// Hide the route from everyone, local and remote alike, keeping its broadcast and + /// instance: [`Self::announce`] brings the same stream back. Requests for the path + /// fail with [`Error::Unroutable`] meanwhile, while tracks already in flight carry + /// on to their own end. Idempotent. + pub fn withdraw(&self) { + let _control = self.state.control.lock(); + self.state.announcement.withdraw(); } -} -impl std::ops::Deref for Publication { - type Target = broadcast::Producer; + /// Whether the route is visible. + pub fn is_announced(&self) -> bool { + self.state.announcement.route().is_some() + } - fn deref(&self) -> &Self::Target { - &self.broadcast + /// Re-price the route: lower wins among routes covering the same prefix and anonymity. + /// A visible route changes in place, as an update to its readers; a hidden one + /// announces at this price. + /// + /// Fails with [`Error::Closed`] once the route's broadcast closed or the origin's + /// [`Driver`] was dropped. + pub fn set_cost(&self, cost: impl Into) -> Result<(), Error> { + let cost = cost.into(); + self.change(|options| options.cost = cost) } -} -/// The table entry a broadcast owns: its exact path, advertised and withdrawn -/// through [`Publication::announce`] and -/// [`Publication::unannounce`], and removed when the broadcast ends. -/// -/// Handed to the broadcast by [`Producer::create_broadcast`], so a standalone -/// broadcast has none and cannot announce. -pub(super) struct Announcer { - entry: AnnounceProducer, - /// The ingress counters an advertised interval's announce guard comes from. - ingress: stats::Scope, - /// A published broadcast is lifecycle work: the origin's driver keeps - /// running for as long as one lives, even once every producer handle is - /// gone, so a session handed a producer can drop it and keep serving. - _keepalive: Keepalive, -} + /// Swap the credential the advertising request carries; see [`RouteOptions::with_auth`]. + /// `None` advertises under the session's scope. + /// + /// Fails with [`Error::Closed`] once the route's broadcast closed or the origin's + /// [`Driver`] was dropped. + pub fn set_auth(&self, auth: Option) -> Result<(), Error> { + self.change(|options| options.auth = auth) + } -impl Announcer { - /// Advertise the broadcast's path with `route`, or re-price it in place. - pub(super) fn announce(&mut self, route: Route) -> Result<(), Error> { - self.announce_if(route, None, || true).map(|_| ()) + fn change(&self, update: impl FnOnce(&mut RouteOptions)) -> Result<(), Error> { + let mut control = self.state.control.lock(); + update(&mut control.options); + if !self.state.announcement.is_live()? { + return Ok(()); + } + self.state.announcement.update_if(control.info(), None, || true).map(|_| ()) } - /// [`Self::announce`] once `admit` agrees; see [`AnnounceProducer::update_if`]. - pub(super) fn announce_if( - &mut self, - route: Route, - predecessor: Option<&kio::Shared>, - admit: impl FnOnce() -> bool, - ) -> Result { - if !self.entry.update_if(route, predecessor, admit)? { - return Ok(false); + /// Block until a consumer requests a path under this prefix route, returning a + /// [`Request`] to answer. + /// + /// Takes `&self` so a handler can answer from one task while another re-prices the + /// route; concurrent callers each receive distinct requests. Returns `None` once the + /// route is retracted or the origin's [`Driver`] was dropped, so handler loops end, + /// and at once on an exact route, which yields no requests. + #[cfg(feature = "async")] + pub async fn requested(&self) -> Option { + kio::wait(|waiter| self.poll_requested(waiter)).await + } + + /// Poll for the next requested path under this prefix route, without blocking. + /// See [`Self::requested`]. + pub fn poll_requested(&self, waiter: &kio::Waiter) -> Poll> { + let Some(server) = &self.state.server else { + return Poll::Ready(None); + }; + let mut state = ready!(server.poll(waiter, |state| { + if state.closed || state.requests.has_queued() { + Poll::Ready(()) + } else { + Poll::Pending + } + })); + + // The teardown already drained the queue, so there is nothing left to pop. + if state.closed { + return Poll::Ready(None); } - if self.entry.guard.is_none() { - self.entry.guard = Some(self.ingress.announce()); + + let path = state.requests.pop().expect("predicate guaranteed a request"); + // The popped request stays pending, so a repeat request in the window between + // hand-off and answer coalesces onto it instead of re-invoking the handler. The + // producer is a shared clone; answering or dropping the `Request` removes the + // entry. This mirrors how `poll_requested_track` keeps a served track + // discoverable via the weak cache across the same window. + let producer = state.requests.get(&path).expect("popped key must be pending").clone(); + Poll::Ready(Some(Request { + path, + producer, + home: server.clone(), + publisher: self.state.publisher.clone(), + })) + } + + /// The route metadata as advertised, or `None` while hidden. + #[cfg(test)] + pub(crate) fn route(&self) -> Option { + self.state.announcement.route() + } + + /// Announce with `info` as given, instance included when it names one, as a + /// session's update does: for tests that shape an exact route's metadata. + #[cfg(test)] + pub(crate) fn announce_info(&self, mut info: RouteInfo) -> Result<(), Error> { + let mut control = self.state.control.lock(); + match &info.instance { + Some(instance) => { + control.instance = instance.clone(); + control.epoch = info.epoch; + } + None => { + info.instance = Some(control.instance.clone()); + info.epoch = control.epoch; + } } - Ok(true) + control.options.cost = info.cost; + control.options.auth = info.auth.clone(); + self.state.announcement.update_if(info, None, || true).map(|_| ()) } - /// Withdraw the advertisement from local and remote consumers alike. - pub(super) fn withdraw(&mut self) { - self.entry.withdraw(); - self.entry.guard = None; + /// The queue a prefix route's requests arrive on, for tests that inspect it. + #[cfg(test)] + pub(crate) fn server(&self) -> &kio::Shared { + self.state.server.as_ref().expect("a prefix route has a server") } - /// The route the broadcast's path is advertised with, if it is. - pub(super) fn route(&self) -> Option { - self.entry.route() + /// Replace a forwarded route's metadata in place, taken as given. + /// + /// A route naming no [`RouteInfo::instance`], or the same one, re-prices: consumers + /// observe an update and every handle survives. Another instance is another stream: + /// consumers see a restart, and a re-request never joins what was resolved under the + /// old one. Requests still waiting on this handle carry over: the handler is asked + /// again under the new instance, and its answer to a request asked before the change + /// is dropped, never served under the new one. A request pinned to the old instance + /// is refused with [`Error::Unroutable`]. The answers already served are forgotten, + /// so the next request for one of those paths asks the handler again too. The + /// broadcasts it served keep running for the subscriptions already on them. + /// + /// Fails with [`Error::Closed`] once the origin's [`Driver`] has been dropped. + #[cfg(any(feature = "async", test))] + pub(crate) fn update(&self, info: RouteInfo) -> Result<(), Error> { + let mut control = self.state.control.lock(); + if let Some(instance) = &info.instance { + control.instance = instance.clone(); + control.epoch = info.epoch; + } + control.options.cost = info.cost; + control.options.auth = info.auth.clone(); + self.state.announcement.update(info) + } + + /// Retire an explicit peer withdrawal, hiding derived paths only once its + /// last live advertisement at the prefix is gone. A lost session just drops. + #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] + pub(crate) fn withdrawn(self) { + self.state.announcement.retract(true); + } +} + +impl Drop for RouteState { + fn drop(&mut self) { + // Retract before a job's unanswered request drops, so its requesters are refused + // rather than asked again through this route. + self.announcement.retract(false); } } /// The write half of an advertisement: a live claim that paths under a /// [`Pattern`] can be served. /// -/// Held by a [`Requests`] and by a broadcast's [`Announcer`]; dropping it -/// retracts the route, which [`AnnounceConsumer`]s observe and sessions withdraw -/// from their peers. +/// Held by a [`Route`]; dropping it retracts the route, which [`AnnounceConsumer`]s +/// observe and sessions withdraw from their peers. #[must_use = "dropping an announcement retracts the route"] pub(crate) struct AnnounceProducer { shared: SendCell>, /// The table entries this advertisement created, by prefix and id. A prefix /// remains unchanged; pattern scopes only filter its visibility and requests. entries: Vec<(Path, u64)>, + /// The ingress counters an advertised interval's announce guard comes from. + ingress: stats::Scope, /// Ingress announce stats guard, held only while the entries are advertised. - guard: Option, + guard: kio::Lock>, } impl AnnounceProducer { /// Replace the route in place, instance included when it names one; see - /// [`Requests::update_route`]. + /// [`Route::update`]. /// - /// The prefix is fixed at announce time and a [`Route`] cannot name one: to + /// The prefix is fixed at announce time and a [`RouteInfo`] cannot name one: to /// move an advertisement, drop this and announce again. Fails with /// [`Error::Closed`] once the origin's [`Driver`] has been dropped. #[cfg(any(feature = "async", test))] - pub fn update(&self, route: Route) -> Result<(), Error> { + pub fn update(&self, route: RouteInfo) -> Result<(), Error> { self.update_if(route, None, || true).map(|_| ()) } @@ -2879,7 +3210,7 @@ impl AnnounceProducer { /// served route, served beneath it; see [`Takeover`]. pub(super) fn update_if( &self, - route: Route, + route: RouteInfo, predecessor: Option<&kio::Shared>, admit: impl FnOnce() -> bool, ) -> Result { @@ -2944,6 +3275,7 @@ impl AnnounceProducer { shared.prune_withdrawn(prefix); } drop(shared); + self.guard.lock().get_or_insert_with(|| self.ingress.announce()); for producer in released { if let Ok(mut request) = producer.write() { request.resolved.get_or_insert(Err(Error::Unroutable)); @@ -2952,12 +3284,25 @@ impl AnnounceProducer { Ok(true) } + /// Whether the entries are advertised, or [`Error::Closed`] once they are gone. + fn is_live(&self) -> Result { + let shared = self.shared.lock(); + if shared.closed { + return Err(Error::Closed); + } + let mut advertised = false; + for (prefix, id) in &self.entries { + advertised |= shared.routes.entry(prefix, *id).ok_or(Error::Closed)?.advertised; + } + Ok(advertised) + } + /// The route as last given, while advertised: every entry carries the same one. - pub(crate) fn route(&self) -> Option { + pub(crate) fn route(&self) -> Option { let shared = self.shared.lock(); let (prefix, id) = self.entries.first()?; let entry = shared.routes.entry(prefix, *id).filter(|entry| entry.advertised)?; - Some(Route { + Some(RouteInfo { instance: Some(entry.instance.clone()), epoch: entry.epoch, hops: entry.hops.clone(), @@ -2970,9 +3315,9 @@ impl AnnounceProducer { /// Hide the entries from everyone, local and remote alike: cursors see a /// retraction and requests stop resolving through them. The entries stay, - /// so announcing again restores the same route. What - /// [`Publication::unannounce`] does. + /// so announcing again restores the same route. What [`Route::withdraw`] does. fn withdraw(&self) { + *self.guard.lock() = None; let mut shared = self.shared.lock(); for (prefix, id) in &self.entries { let Some(entry) = shared.routes.entry_mut(prefix, *id) else { @@ -2990,6 +3335,7 @@ impl AnnounceProducer { /// Retract the route now: remove its table entries and reject anything still /// waiting on its queue. Idempotent, and what dropping the advertisement does. fn retract(&self, withdrawn: bool) { + *self.guard.lock() = None; let mut shared = self.shared.lock(); let mut servers = Vec::new(); for (prefix, id) in &self.entries { @@ -3044,7 +3390,7 @@ impl Drop for AnnounceProducer { /// Drives origin lifecycle work and cache expiration with caller-supplied time. /// /// Returned by [`Producer::new`]. Poll on external activity or at the deadline -/// it returns, supplying nondecreasing instants. Route changes, track serving, linger, +/// it returns, supplying nondecreasing instants. RouteInfo changes, track serving, linger, /// failover, and teardown run here; the route table and announce cursors update /// synchronously when a route is announced or retracted. /// @@ -5119,7 +5465,7 @@ struct OriginState { // The announced routes, keyed by prefix. The table holds one entry per live // advertisement, not one per broadcast consumer. routes: RouteTable, - // Route ids. + // RouteInfo ids. next_route: u64, next_watch: u64, next_snapshot: u64, @@ -5687,46 +6033,17 @@ impl FrontWatch { } } -/// A served route, from [`Producer::requests`]: advertises a path prefix and -/// 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 -/// an origin. A relay holds one per route a peer announces to it, materializing -/// a requested path from that peer; an application holds one to answer a -/// subtree it never publishes ahead of time. -/// -/// Drop it to retract the route and reject the requests still waiting to be -/// served. -/// -/// It keeps the origin's [`Driver`] running, like a published broadcast: a -/// handler can drop every [`Producer`] and keep serving. -#[must_use = "dropping an origin::Requests retracts the route"] -pub struct Requests { - /// The advertisement, retracted on drop. - announcement: AnnounceProducer, - state: kio::Shared, - /// Present for application claims, which publish each answer as an exact route. - publisher: Option, - /// Producer-side children pin their parent where no cycle exists. The - /// origin's state holds only the [`ServeState`], never this handle, so the - /// driver cannot keep itself alive. - _keepalive: Keepalive, -} - -impl Requests { +impl Route { #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] pub(super) fn request_validity(&self, path: &Path) -> Option { - let shared = &self.announcement.shared; + let shared = &self.state.announcement.shared; + let server = self.state.server.as_ref()?; let mut table = shared.lock(); if table.closed { return None; } let entry = table.best_route(path, Horizon::default(), &HashSet::new(), |entry| { - entry - .server - .as_ref() - .is_some_and(|server| server.same_channel(&self.state)) + entry.server.as_ref().is_some_and(|entry| entry.same_channel(server)) })?; let via = entry.via; let instance = entry.instance.clone(); @@ -5759,84 +6076,6 @@ impl Requests { signal, }) } - - /// Retire an explicit peer withdrawal, hiding derived paths only once its - /// last live advertisement at the prefix is gone. A lost session just drops. - #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] - pub(crate) fn withdrawn(self) { - self.announcement.retract(true); - } - - /// The route this handle advertises, as last given. - pub fn route(&self) -> Route { - self.announcement - .route() - .expect("a dynamic route stands until its handle drops") - } - - /// Replace the route in place, taken as given. - /// - /// A route naming no [`Route::instance`], or the same one, re-prices: consumers observe - /// an update and every handle survives. Another instance is another stream: consumers - /// see an [`AnnounceEvent::Restart`], and a re-request never joins what was resolved - /// under the old one. Requests still waiting on this handle carry over: the handler is - /// asked again under the new instance, and its answer to a request asked before the - /// change is dropped, never served under the new one. A request pinned to the old - /// instance is refused with [`Error::Unroutable`]. The answers already served are - /// forgotten, so the next request for one of those paths asks the handler again too. - /// The broadcasts it served keep running for the subscriptions already on them; close - /// them to end those too. - /// - /// The prefix is fixed at announce time: to move a route, drop this and call - /// [`Producer::requests`] again. Fails with [`Error::Closed`] once the origin's - /// [`Driver`] has been dropped. - #[cfg(any(feature = "async", test))] - pub(crate) fn update_route(&self, route: Route) -> Result<(), Error> { - self.announcement.update(route) - } - - /// Poll for the next requested path under this route, without blocking. - /// - /// Returns [`Error::Closed`] once the origin's [`Driver`] has been dropped: - /// no request will ever arrive again, so handler loops should end. - pub fn poll_requested_broadcast(&self, waiter: &kio::Waiter) -> Poll> { - let mut state = ready!(self.state.poll(waiter, |state| { - if state.closed || state.requests.has_queued() { - Poll::Ready(()) - } else { - Poll::Pending - } - })); - - // The teardown already drained the queue, so there is nothing left to pop. - if state.closed { - return Poll::Ready(Err(Error::Closed)); - } - - let path = state.requests.pop().expect("predicate guaranteed a request"); - // The popped request stays pending, so a repeat request in the window between - // hand-off and accept coalesces onto it instead of re-invoking the handler. The - // producer is a shared clone; `Request::{accept, reject, drop}` removes the - // entry. This mirrors how `poll_requested_track` keeps a served track - // discoverable via the weak cache across the same window. - let producer = state.requests.get(&path).expect("popped key must be pending").clone(); - Poll::Ready(Ok(Request { - path, - producer, - home: self.state.clone(), - publisher: self.publisher.clone(), - })) - } - - /// Block until a consumer requests a path under this route, returning a - /// [`Request`] to serve. - /// - /// Takes `&self` so a handler can serve from one task while another re-prices - /// the route; concurrent callers each receive distinct requests. - #[cfg(feature = "async")] - pub async fn requested_broadcast(&self) -> Result { - kio::wait(|waiter| self.poll_requested_broadcast(waiter)).await - } } impl ServeState { @@ -5931,10 +6170,11 @@ 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`]; [`prepare`](Self::prepare) then [`Prepared::publish`] -/// resolves it with a new exact-path broadcast, [`serve`](Self::serve) answers with a held -/// broadcast, and [`reject`](Self::reject) resolves it with an error. Dropping it rejects it. +/// Yielded by [`Route::requested`]. The requester is awaiting inside +/// [`Consumer::request`]. Answer it one of three ways: [`serve`](Self::serve) a +/// broadcast already held, under the prefix route's instance; create the path's own +/// exact route with [`route`](Self::route), under a fresh instance; or +/// [`reject`](Self::reject) it with an error. Dropping it rejects it. /// /// Serve a held broadcast without announcing an exact route: /// @@ -5955,7 +6195,7 @@ pub struct Request { // broadcast for repeat requests. home: kio::Shared, - // Applications can prepare answers in this origin; a session-forwarded request + // Applications can create routes in this origin; a session-forwarded request // can only serve its peer's already-routed broadcast. publisher: Option, } @@ -5966,15 +6206,24 @@ impl Request { &self.path } - /// Start an answer under a fresh random instance, hidden until it is published. - pub fn prepare(self) -> Result { + /// Answer with the path's own exact route, owning a new broadcast. + /// + /// The route serves a fresh instance unless `options` names one, so a job that ends + /// and restarts beneath the same prefix is a new stream for its restarted sequences. + /// Ending the route withdraws only this path: the prefix route keeps answering later + /// requests. Created visible, the route announces now and answers the requesters + /// waiting on its path. Created [`RouteOptions::hidden`], they wait until + /// [`Route::announce`], so the job can fill its catalog first; dropping the route + /// before then refuses them. + /// + /// Fails with [`Error::Unroutable`] on a request a session forwarded, which can only + /// [`serve`](Self::serve) its peer's broadcast, and, announcing nothing, once the + /// request was released or its prefix route retracted. Otherwise it fails as + /// [`Producer::route`] does. + pub fn route(self, options: RouteOptions) -> Result { let publisher = self.publisher.clone().ok_or(Error::Unroutable)?; - let (broadcast, announcer) = publisher.create_withheld(self.path.clone())?; - Ok(Prepared { - request: self, - broadcast, - announcer, - }) + let path = self.path.clone(); + publisher.exact(path, options, Some(self)) } /// Serve a held broadcast under this prefix route without announcing an exact route. @@ -5982,7 +6231,7 @@ impl Request { /// The answer belongs to the prefix route's instance at this path: every answer for /// that path must continue the same sequence space and bytes. Start a new prefix /// route to serve different content there. For a job that may restart independently, - /// use [`Self::prepare`] and [`Prepared::publish`] to announce its own instance. + /// use [`Self::route`] to announce its own instance. pub fn serve(self, broadcast: impl Consume) { let broadcast = broadcast.consume(); let _ = ServeState::resolve(&self.home, &self.path, &self.producer, Ok(broadcast)); @@ -5995,63 +6244,6 @@ impl Request { } } -/// A claim answer being filled before its exact route is announced. -/// -/// Dropping it unpublished refuses the request, as dropping a [`Request`] does. -pub struct Prepared { - request: Request, - broadcast: broadcast::Producer, - // Withheld from the broadcast until `publish`, so the answer cannot announce - // itself under another instance or skip the request's admission. - announcer: Announcer, -} - -impl Prepared { - /// The unannounced fill surface; only [`Self::publish`] can announce the answer. - pub fn broadcast(&self) -> &broadcast::Producer { - &self.broadcast - } - - /// Announce the filled broadcast and resolve every requester waiting for it. - /// - /// Fails with [`Error::Unroutable`], announcing nothing, once the request was - /// released or its claim retracted, or with [`Error::Closed`] once the broadcast - /// closed. A failed answer can never announce. - pub fn publish(self) -> Result { - let Self { - request, - broadcast, - announcer, - } = self; - let route = Route::default(); - let answer = broadcast.consume(); - let mut resolved = None; - // Answered under the table lock that every release takes first, so the route - // lands only for a request still pending and no release can slip in between. - // The answer continues what the claim served for the path: requesters waiting on it, - // and whatever resolved through the claim's current instance beneath it. Answered - // and taken over under one lock, so nothing resolves in between. - let admitted = broadcast.announce_withheld(announcer, route, Some(&request.home), || { - // The exact route owns this answer's availability. Caching it under the - // prefix would keep serving it after that route is withdrawn. - resolved = request - .home - .lock() - .take(&request.path, &request.producer) - .map(|()| Ok(answer)); - resolved.is_some() - })?; - let Some(resolved) = resolved.filter(|_| admitted) else { - return Err(Error::Unroutable); - }; - // Woken outside every lock: a front re-entering the table must not find it held. - if let Ok(mut pending) = request.producer.write() { - pending.resolved.get_or_insert(resolved); - } - Ok(Publication { broadcast }) - } -} - impl Drop for Request { fn drop(&mut self) { // Handed off but neither accepted nor rejected: drop the still-pending entry so its @@ -7156,7 +7348,7 @@ impl AnnounceConsumer { } #[cfg(test)] - pub(crate) async fn expect_next_active(&mut self, expected: impl TryInto) -> Route { + pub(crate) async fn expect_next_active(&mut self, expected: impl TryInto) -> RouteInfo { let event = self.expect_next().await; Self::active(event, &expected.try_into().expect("expected path")) } @@ -7165,7 +7357,7 @@ impl AnnounceConsumer { pub(crate) async fn expect_next_restarted( &mut self, expected: impl TryInto, - ) -> Route { + ) -> RouteInfo { match self.expect_next().await { AnnounceEvent::Restart(announce) => { assert_eq!( @@ -7550,7 +7742,7 @@ use futures::FutureExt; #[expect(missing_docs, reason = "test-only assertion helpers")] impl AnnounceConsumer { /// The route of an active event at `expected`. - fn active(event: AnnounceEvent, expected: &Path) -> Route { + fn active(event: AnnounceEvent, expected: &Path) -> RouteInfo { match event { AnnounceEvent::Start(announce) | AnnounceEvent::Update(announce) | AnnounceEvent::Restart(announce) => { assert_eq!(announce.prefix, *expected, "wrong prefix"); @@ -7561,7 +7753,7 @@ impl AnnounceConsumer { } /// The next update must be an active route at `expected`; returns it. - pub fn assert_next_active(&mut self, expected: impl TryInto) -> Route { + pub fn assert_next_active(&mut self, expected: impl TryInto) -> RouteInfo { let event = kio::wait(|waiter| self.poll_next(waiter)) .now_or_never() .expect("next blocked") @@ -7570,13 +7762,13 @@ impl AnnounceConsumer { } /// The `try_next` counterpart of [`Self::assert_next_active`]. - pub fn assert_try_next_active(&mut self, expected: impl TryInto) -> Route { + pub fn assert_try_next_active(&mut self, expected: impl TryInto) -> RouteInfo { let event = self.try_next().expect("no next"); Self::active(event, &expected.try_into().expect("expected path")) } /// The next update must be a restart at `expected`; returns its route. - pub fn assert_next_restarted(&mut self, expected: impl TryInto) -> Route { + pub fn assert_next_restarted(&mut self, expected: impl TryInto) -> RouteInfo { match kio::wait(|waiter| self.poll_next(waiter)) .now_or_never() .expect("next blocked") @@ -7674,7 +7866,7 @@ impl TestSelection { pub(crate) fn new() -> Self { let origin = Hop::new(1).unwrap().produce(); let route = origin - .requests_route("room", Route::default().with_via(Hop::new(Self::PEER).unwrap()), None) + .forward("room", RouteInfo::default().with_via(Hop::new(Self::PEER).unwrap()), None) .unwrap(); Self { origin, @@ -7695,8 +7887,8 @@ impl TestSelection { /// Another instance of the peer takes the path. pub(crate) fn replace(&mut self) { - let route = Route::default().with_via(Hop::new(Self::PEER).unwrap()); - self.replacement = Some(self.origin.requests_route("room/a", route, None).unwrap()); + let route = RouteInfo::default().with_via(Hop::new(Self::PEER).unwrap()); + self.replacement = Some(self.origin.forward("room/a", route, None).unwrap()); } } @@ -7862,7 +8054,7 @@ mod tests { let mut announced = consumer.announced(); announced.assert_next_wait(); - let announcement = producer.announce("room/alice", Route::default()).unwrap(); + let announcement = producer.announce("room/alice", RouteInfo::default()).unwrap(); let route = announced.expect_next_active("room/alice").await; assert!(route.hops.is_empty()); assert_eq!(route.cost, Cost::default()); @@ -7881,7 +8073,7 @@ mod tests { let mut announced = producer.consume().announced(); assert!(!announced.is_synced(), "a snapshot in flight holds it"); - let _alice = producer.announce("room/alice", Route::default()).unwrap(); + let _alice = producer.announce("room/alice", RouteInfo::default()).unwrap(); drop(snapshot); assert!(!announced.is_synced(), "never before an earlier event is read"); @@ -7889,7 +8081,7 @@ mod tests { assert!(announced.is_synced()); // A later announcement is news, not part of what it synced with. - let _bob = producer.announce("room/bob", Route::default()).unwrap(); + let _bob = producer.announce("room/bob", RouteInfo::default()).unwrap(); assert!(announced.is_synced()); } @@ -7901,7 +8093,7 @@ mod tests { assert!(empty.is_synced(), "nothing to wait on"); empty.assert_next_wait(); - let _alice = producer.announce("room/alice", Route::default()).unwrap(); + let _alice = producer.announce("room/alice", RouteInfo::default()).unwrap(); let mut announced = producer.consume().announced(); assert!(!announced.is_synced(), "the replay is owed"); announced.assert_next_active("room/alice"); @@ -7911,9 +8103,9 @@ mod tests { #[test] fn initial_routes_precede_live_prefixes() { let producer = origin(1).produce(); - let _initial = producer.announce("z/initial", Route::default()).unwrap(); + let _initial = producer.announce("z/initial", RouteInfo::default()).unwrap(); let mut announced = producer.consume().announced(); - let _live = producer.announce("a/live", Route::default()).unwrap(); + let _live = producer.announce("a/live", RouteInfo::default()).unwrap(); announced.assert_next_active("z/initial"); assert!(announced.is_synced()); } @@ -7921,11 +8113,11 @@ mod tests { #[test] fn stalled_initial_replay_collapses_churn_without_a_backlog() { let producer = origin(1).produce(); - let initial = producer.announce("z/initial", Route::default()).unwrap(); + let initial = producer.announce("z/initial", RouteInfo::default()).unwrap(); let mut announced = producer.consume().announced(); for i in 0..1_000 { - let transient = producer.announce(format!("a/{i}"), Route::default()).unwrap(); - initial.update(Route::default().with_cost(i)).unwrap(); + let transient = producer.announce(format!("a/{i}"), RouteInfo::default()).unwrap(); + initial.update(RouteInfo::default().with_cost(i)).unwrap(); drop(transient); assert_eq!(announced.state.read().pending.len(), 1); } @@ -7941,7 +8133,7 @@ mod tests { let snapshot = producer.snapshot(""); let mut announced = producer.consume().announced(); - let alice = producer.announce("room/alice", Route::default()).unwrap(); + let alice = producer.announce("room/alice", RouteInfo::default()).unwrap(); drop(snapshot); assert!(!announced.is_synced()); drop(alice); @@ -7954,11 +8146,11 @@ mod tests { fn an_update_is_not_owed() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let alice = producer.announce("room/alice", Route::default()).unwrap(); + let alice = producer.announce("room/alice", RouteInfo::default()).unwrap(); announced.assert_next_active("room/alice"); let snapshot = producer.snapshot(""); - alice.update(Route::default().with_cost(5)).unwrap(); + alice.update(RouteInfo::default().with_cost(5)).unwrap(); drop(snapshot); assert!(announced.is_synced()); } @@ -8089,11 +8281,11 @@ mod tests { async fn hidden_routes_need_an_opt_in() { let producer = origin(1).produce(); let consumer = producer.consume(); - let _visible = producer.announce("room/alice", Route::default()).unwrap(); - let _stats = producer.announce(".stats/node", Route::default()).unwrap(); - let _nested = producer.announce("room/.internal", Route::default()).unwrap(); + let _visible = producer.announce("room/alice", RouteInfo::default()).unwrap(); + let _stats = producer.announce(".stats/node", RouteInfo::default()).unwrap(); + let _nested = producer.announce("room/.internal", RouteInfo::default()).unwrap(); // Only a leading dot hides: a suffix is part of the name. - let _suffix = producer.announce("room/catalog.pro", Route::default()).unwrap(); + let _suffix = producer.announce("room/catalog.pro", RouteInfo::default()).unwrap(); let mut announced = consumer.announced(); announced.expect_next_active("room/alice").await; @@ -8125,8 +8317,8 @@ mod tests { async fn hidden_broadcast_resolves_by_path() { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.create_broadcast(".stats/node").unwrap(); - broadcast.announce(Route::default()).unwrap(); + let broadcast = producer.route(".stats/node", RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); consumer.announced().assert_next_wait(); let resolved = consumer.request(".stats/node", None).await.expect("resolves"); @@ -8139,10 +8331,10 @@ mod tests { #[cfg(feature = "async")] async fn exclude_hides_and_refuses_the_subtree() { let producer = origin(1).produce(); - let _claim = producer.announce("p1", Route::default()).unwrap(); - let _cam = producer.publish("p1/cam", Route::default()).unwrap(); - let _private = producer.publish("p1/.private/cam", Route::default()).unwrap(); - let _overlay = producer.publish("p1/.pro/cam", Route::default()).unwrap(); + let _claim = producer.announce("p1", RouteInfo::default()).unwrap(); + let _cam = producer.route("p1/cam", RouteOptions::default()).unwrap(); + let _private = producer.route("p1/.private/cam", RouteOptions::default()).unwrap(); + let _overlay = producer.route("p1/.pro/cam", RouteOptions::default()).unwrap(); let consumer = producer .consume() .scope("p1", &Patterns::from(Pattern::all())) @@ -8167,7 +8359,7 @@ mod tests { ); } // Only whole segments: a sibling sharing the prefix text is untouched. - let _sibling = producer.publish("p1/.prod", Route::default()).unwrap(); + let _sibling = producer.route("p1/.prod", RouteOptions::default()).unwrap(); announced.expect_next_active(".prod").await; } @@ -8176,9 +8368,9 @@ mod tests { #[kio::test] async fn exclude_reaches_into_a_mount() { let producer = origin(1).produce(); - let _foo = producer.publish(".svc/p1/foo", Route::default()).unwrap(); - let _bar = producer.publish(".svc/p1/bar", Route::default()).unwrap(); - let _cam = producer.publish("p1/cam", Route::default()).unwrap(); + let _foo = producer.route(".svc/p1/foo", RouteOptions::default()).unwrap(); + let _bar = producer.route(".svc/p1/bar", RouteOptions::default()).unwrap(); + let _cam = producer.route("p1/cam", RouteOptions::default()).unwrap(); let project = mounted(&producer, "p1", &["**"]).with_hidden(true); let mut announced = project.exclude(".svc/foo").unwrap().announced(); @@ -8218,7 +8410,7 @@ mod tests { #[cfg(feature = "async")] async fn mount_resolves_on_the_target_front() { let producer = origin(1).produce(); - let server = producer.requests_route(".svc", Route::default(), None).unwrap(); + let server = producer.forward(".svc", RouteInfo::default(), None).unwrap(); let project = mounted(&producer, "p1", &["**"]); let through = project.request(".svc/foo", None); @@ -8243,11 +8435,11 @@ mod tests { #[cfg(feature = "async")] async fn mount_presents_target_routes_under_the_mount() { let producer = origin(1).produce(); - let _claim = producer.announce(".svc", Route::default()).unwrap(); - let foo = producer.publish(".svc/p1/foo", Route::default()).unwrap(); - let _other = producer.publish(".svc/p2/bar", Route::default()).unwrap(); - let _cam = producer.publish("p1/cam", Route::default()).unwrap(); - let _shadowed = producer.publish("p1/.svc/forged", Route::default()).unwrap(); + let _claim = producer.announce(".svc", RouteInfo::default()).unwrap(); + let foo = producer.route(".svc/p1/foo", RouteOptions::default()).unwrap(); + let _other = producer.route(".svc/p2/bar", RouteOptions::default()).unwrap(); + let _cam = producer.route("p1/cam", RouteOptions::default()).unwrap(); + let _shadowed = producer.route("p1/.svc/forged", RouteOptions::default()).unwrap(); let project = mounted(&producer, "p1", &["**"]); // A dot segment hides the mount like any other. @@ -8287,8 +8479,8 @@ mod tests { #[cfg(feature = "async")] async fn mount_authorizes_the_named_path() { let producer = origin(1).produce(); - let _foo = producer.publish(".svc/p1/foo", Route::default()).unwrap(); - let _bar = producer.publish(".svc/p1/bar", Route::default()).unwrap(); + let _foo = producer.route(".svc/p1/foo", RouteOptions::default()).unwrap(); + let _bar = producer.route(".svc/p1/bar", RouteOptions::default()).unwrap(); let granted = mounted(&producer, "p1", &["foo", ".svc/foo"]); granted.request(".svc/foo", None).await.expect("granted"); @@ -8321,7 +8513,7 @@ mod tests { #[kio::test] async fn mount_captures_the_named_path() { let producer = origin(1).produce(); - let _foo = producer.publish(".svc/p1/foo", Route::default()).unwrap(); + let _foo = producer.route(".svc/p1/foo", RouteOptions::default()).unwrap(); let project = mounted(&producer, "p1", &["**"]).with_hidden(true); let Some(AnnounceEvent::Start(update)) = project.announced().try_next() else { @@ -8345,7 +8537,7 @@ mod tests { async fn mount_keeps_a_max_depth_target() { let producer = origin(1).produce(); let deep = vec!["d"; Path::MAX_PARTS].join("/"); - let _leaf = producer.publish(deep.as_str(), Route::default()).unwrap(); + let _leaf = producer.route(deep.as_str(), RouteOptions::default()).unwrap(); let project = producer .mount("p1/.svc", deep.as_str()) .unwrap() @@ -8370,9 +8562,9 @@ mod tests { #[kio::test] async fn mount_bounds_the_named_path() { let producer = origin(1).produce(); - let _near = producer.publish("t/x", Route::default()).unwrap(); + let _near = producer.route("t/x", RouteOptions::default()).unwrap(); let deep = format!("t/{}", vec!["d"; Path::MAX_PARTS - 1].join("/")); - let _deep = producer.publish(deep.as_str(), Route::default()).unwrap(); + let _deep = producer.route(deep.as_str(), RouteOptions::default()).unwrap(); let project = producer .mount("p1/a/b", "t") .unwrap() @@ -8400,16 +8592,16 @@ mod tests { .unwrap() .scope("p1", &Patterns::from(Pattern::all())) .unwrap(); - assert!(matches!(project.create_broadcast(".svc/foo"), Err(Error::Unauthorized))); + assert!(matches!(project.route(".svc/foo", RouteOptions::hidden()), Err(Error::Unauthorized))); assert!(matches!( - project.requests_route(".svc", Route::default(), None), + project.forward(".svc", RouteInfo::default(), None), Err(Error::Unauthorized) )); assert!(matches!( - project.requests_route(".svc/foo", Route::default(), None), + project.forward(".svc/foo", RouteInfo::default(), None), Err(Error::Unauthorized) )); - project.publish("cam", Route::default()).unwrap(); + project.route("cam", RouteOptions::default()).unwrap(); } /// A mount reaches only what the handle already reaches, and mounts never nest. @@ -8459,7 +8651,7 @@ mod tests { async fn mount_egress_counts_under_the_named_path() { let registry = stats::Registry::new(stats::Config::new()); let producer = origin(1).produce(); - let _foo = producer.publish(".svc/p1/foo", Route::default()).unwrap(); + let _foo = producer.route(".svc/p1/foo", RouteOptions::default()).unwrap(); let project = mounted(&producer, "p1", &["**"]) .with_stats( registry @@ -8490,7 +8682,7 @@ mod tests { let mut announced = consumer.announced(); let mut opted = consumer.clone().with_hidden(true).announced(); - let hidden = producer.announce(".stats/node", Route::default()).unwrap(); + let hidden = producer.announce(".stats/node", RouteInfo::default()).unwrap(); announced.assert_next_wait(); opted.expect_next_active(".stats/node").await; @@ -8502,7 +8694,7 @@ mod tests { #[kio::test] async fn a_replayed_route_retracted_before_delivery_cancels() { let producer = origin(1).produce(); - let alice = producer.announce("alice", Route::default()).unwrap(); + let alice = producer.announce("alice", RouteInfo::default()).unwrap(); let mut announced = producer.consume().announced(); drop(alice); announced.assert_next_wait(); @@ -8517,36 +8709,36 @@ mod tests { let mut peer = consumer.clone().excluding(Hop::UNKNOWN).announced(); // Created but not announced: invisible to local and peer cursors alike. - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.route("room/alice", RouteOptions::hidden()).unwrap(); announced.assert_next_wait(); peer.assert_next_wait(); - broadcast.announce(Route::default().with_cost(3)).unwrap(); + broadcast.announce(RouteInfo::default().with_cost(3)).unwrap(); assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(3)); assert_eq!(peer.expect_next_active("room/alice").await.cost, Cost::new(3)); // Announcing again re-prices in place. - broadcast.announce(Route::default().with_cost(1)).unwrap(); + broadcast.announce(RouteInfo::default().with_cost(1)).unwrap(); assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(1)); assert_eq!(peer.expect_next_active("room/alice").await.cost, Cost::new(1)); // Off the air: the route retracts for everyone and the path is unroutable. - broadcast.unannounce(); + broadcast.withdraw(); announced.expect_next_ended("room/alice").await; peer.expect_next_ended("room/alice").await; - broadcast.unannounce(); + broadcast.withdraw(); announced.assert_next_wait(); 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. - broadcast.announce(Route::default()).unwrap(); + broadcast.announce().unwrap(); announced.expect_next_active("room/alice").await; peer.expect_next_active("room/alice").await; - broadcast.close(); + broadcast.broadcast().close(); announced.expect_next_ended("room/alice").await; peer.expect_next_ended("room/alice").await; - assert!(matches!(broadcast.announce(Route::default()), Err(Error::Closed))); + assert!(matches!(broadcast.announce(), Err(Error::Closed))); announced.assert_next_wait(); } @@ -8556,9 +8748,9 @@ mod tests { let consumer = producer.consume(); let mut announced = consumer.announced(); - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.route("room/alice", RouteOptions::hidden()).unwrap(); let clone = broadcast.clone(); - broadcast.announce(Route::default()).unwrap(); + broadcast.announce().unwrap(); announced.expect_next_active("room/alice").await; // A clone keeps the broadcast, and its advertisement, alive. @@ -8572,23 +8764,23 @@ mod tests { async fn publish_creates_and_announces_together() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let _broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let _broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); announced.expect_next_active("room/alice").await; } #[kio::test] async fn standalone_broadcast_cannot_announce() { let broadcast = broadcast::Info::new().produce(); - assert!(matches!(broadcast.announce(Route::default()), Err(Error::Closed))); + assert!(matches!(broadcast.announce(), Err(Error::Closed))); // Harmless without an advertisement to retract. - broadcast.unannounce(); + broadcast.withdraw(); } #[kio::test] async fn announce_replays_to_late_cursor() { let producer = origin(1).produce(); - let _a = producer.announce("room/alice", Route::default()).unwrap(); - let _b = producer.announce("room/bob", Route::default()).unwrap(); + let _a = producer.announce("room/alice", RouteInfo::default()).unwrap(); + let _b = producer.announce("room/bob", RouteInfo::default()).unwrap(); let mut announced = producer.consume().announced(); // Replay follows the table traversal order. @@ -8603,13 +8795,13 @@ mod tests { let scoped = producer.scope("", &scopes(&["room"])).unwrap(); // Prefix advertisements stay prefixes. The scope filters requests locally. - let _a = scoped.announce("", Route::default()).unwrap(); + let _a = scoped.announce("", RouteInfo::default()).unwrap(); let mut announced = producer.consume().announced(); announced.expect_next_active("").await; // Disjoint prefixes cannot be claimed at all. assert!(matches!( - scoped.announce("other", Route::default()), + scoped.announce("other", RouteInfo::default()), Err(Error::Unauthorized) )); } @@ -8617,7 +8809,7 @@ mod tests { #[kio::test] async fn cursor_keeps_an_overlapping_prefix_above_its_scope() { let producer = origin(1).produce(); - let _a = producer.announce("", Route::default()).unwrap(); + let _a = producer.announce("", RouteInfo::default()).unwrap(); let consumer = producer.consume().scope("", &scopes(&["room"])).unwrap(); let mut announced = consumer.clone().covering().announced(); @@ -8628,7 +8820,7 @@ mod tests { #[kio::test] async fn cursor_root_strips_prefix() { let producer = origin(1).produce(); - let _a = producer.announce("room/alice", Route::default()).unwrap(); + let _a = producer.announce("room/alice", RouteInfo::default()).unwrap(); let consumer = producer .consume() @@ -8644,14 +8836,14 @@ mod tests { let mut announced = producer.consume().announced(); let expensive = producer - .announce("room", Route::default().with_hops(hops(&[10])).with_cost(5)) + .announce("room", RouteInfo::default().with_hops(hops(&[10])).with_cost(5)) .unwrap(); let route = announced.expect_next_active("room").await; assert_eq!(route.cost, Cost::new(5)); // A cheaper route for the same prefix takes over in place. let cheap = producer - .announce("room", Route::default().with_hops(hops(&[20])).with_cost(1)) + .announce("room", RouteInfo::default().with_hops(hops(&[20])).with_cost(1)) .unwrap(); let route = announced.expect_next_active("room").await; assert_eq!(route.cost, Cost::new(1)); @@ -8691,9 +8883,9 @@ mod tests { let _pool: Vec = order .map(|id| { producer - .requests_route( + .forward( "pool", - Route::default() + RouteInfo::default() .with_instance(format!("worker-{id}").parse().unwrap(), 0) .with_hops(hops(&[id])) .with_cost(3), @@ -8744,7 +8936,7 @@ mod tests { for named in [None, Some(instance())] { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let mut route = Route::default().with_hops(hops(&[10])); + let mut route = RouteInfo::default().with_hops(hops(&[10])); route.instance = named.clone(); let old = producer.announce("room", route.clone()).unwrap(); @@ -8769,11 +8961,11 @@ mod tests { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); let route = producer - .requests_route("room", Route::default().with_cost(3), None) + .forward("room", RouteInfo::default().with_cost(3), None) .unwrap(); announced.expect_next_active("room").await; - route.update_route(Route::default().with_cost(5)).unwrap(); + route.update(RouteInfo::default().with_cost(5)).unwrap(); match announced.next().await.expect("no next") { AnnounceEvent::Update(update) => assert_eq!(update.route.cost, Cost::new(5)), other => panic!("should be an update: got {other:?}"), @@ -8791,11 +8983,11 @@ mod tests { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); let route = producer - .requests_route("room", Route::default().with_auth(first.clone()), None) + .forward("room", RouteInfo::default().with_auth(first.clone()), None) .unwrap(); assert_eq!(announced.expect_next_active("room").await.auth, Some(first)); - route.update_route(Route::default().with_auth(second.clone())).unwrap(); + route.update(RouteInfo::default().with_auth(second.clone())).unwrap(); match announced.next().await.expect("no next") { AnnounceEvent::Update(update) => assert_eq!(update.route.auth, Some(second)), other => panic!("should be an update: got {other:?}"), @@ -8820,9 +9012,9 @@ mod tests { let mut announced = consumer.announced(); let peer = producer.clone().with_link(Link::Peer); let old = peer - .requests_route( + .forward( "pool/job-0", - Route::default() + RouteInfo::default() .with_instance("a".parse().unwrap(), 0) .with_hops(hops(&[11])), None, @@ -8831,9 +9023,9 @@ mod tests { announced.expect_next_active("pool/job-0").await; let new = peer - .requests_route( + .forward( "pool/job-0", - Route::default() + RouteInfo::default() .with_instance("b".parse().unwrap(), 0) .with_hops(hops(&[10])), None, @@ -8874,12 +9066,12 @@ mod tests { let consumer = producer.consume(); let mut announced = consumer.announced(); let _old = producer - .requests_route("pool/job-0", Route::default().with_hops(hops(&[old_hop])), None) + .forward("pool/job-0", RouteInfo::default().with_hops(hops(&[old_hop])), None) .unwrap(); announced.expect_next_active("pool/job-0").await; let new = producer - .requests_route("pool/job-0", Route::default().with_hops(hops(&[new_hop])), None) + .forward("pool/job-0", RouteInfo::default().with_hops(hops(&[new_hop])), None) .unwrap(); assert_eq!( announced.expect_next_restarted("pool/job-0").await.hops, @@ -8906,7 +9098,7 @@ mod tests { claims .scope("", &scopes(&[scope])) .unwrap() - .requests_route(prefix, Route::default().with_hops(hops(&[hop])).with_cost(cost), None) + .forward(prefix, RouteInfo::default().with_hops(hops(&[hop])).with_cost(cost), None) .unwrap() }; (producer, claim) @@ -8944,7 +9136,7 @@ mod tests { assert_eq!(announced.expect_next_active("room").await.cost, Cost::new(5)); let _sticky = hold(&consumer, "room/job", &a).await; - b.update_route(Route::default().with_hops(hops(&[11])).with_cost(3)) + b.update(RouteInfo::default().with_hops(hops(&[11])).with_cost(3)) .unwrap(); assert_eq!(announced.expect_next_restarted("room").await.cost, Cost::new(3)); quiet(&mut announced).await; @@ -8954,7 +9146,7 @@ mod tests { async fn exclude_hides_routes_through_the_peer() { let producer = origin(1).produce(); let _a = producer - .announce("room", Route::default().with_hops(hops(&[7]))) + .announce("room", RouteInfo::default().with_hops(hops(&[7]))) .unwrap(); let mut hidden = producer.consume().excluding(origin(7)).announced(); @@ -8969,10 +9161,10 @@ mod tests { let producer = origin(1).produce(); let assigned = origin(777); let _echoed = producer - .announce("echoed", Route::default().with_hops(hops(&[0])).with_via(assigned)) + .announce("echoed", RouteInfo::default().with_hops(hops(&[0])).with_via(assigned)) .unwrap(); let _local = producer - .announce("local", Route::default().with_hops(hops(&[10]))) + .announce("local", RouteInfo::default().with_hops(hops(&[10]))) .unwrap(); let mut hidden = producer.consume().excluding(assigned).announced(); @@ -8986,14 +9178,14 @@ mod tests { let mut announced = producer.consume().announced(); let _anonymous = producer - .announce("room", Route::default().with_hops(hops(&[0])).with_cost(1)) + .announce("room", RouteInfo::default().with_hops(hops(&[0])).with_cost(1)) .unwrap(); let route = announced.expect_next_active("room").await; assert!(route.is_anonymous()); assert_eq!(route.cost, Cost::new(1)); let _identified = producer - .announce("room", Route::default().with_hops(hops(&[10])).with_cost(5)) + .announce("room", RouteInfo::default().with_hops(hops(&[10])).with_cost(5)) .unwrap(); let route = announced.expect_next_active("room").await; assert!(!route.is_anonymous()); @@ -9006,13 +9198,13 @@ mod tests { let mut announced = producer.consume().announced(); let expensive = producer - .announce("room", Route::default().with_hops(hops(&[0])).with_cost(5)) + .announce("room", RouteInfo::default().with_hops(hops(&[0])).with_cost(5)) .unwrap(); let route = announced.expect_next_active("room").await; assert_eq!(route.cost, Cost::new(5)); let _cheap = producer - .announce("room", Route::default().with_hops(hops(&[0, 7])).with_cost(1)) + .announce("room", RouteInfo::default().with_hops(hops(&[0, 7])).with_cost(1)) .unwrap(); let route = announced.expect_next_active("room").await; assert!(route.is_anonymous()); @@ -9030,7 +9222,7 @@ mod tests { let _anonymous = producer .announce( "room", - Route::default() + RouteInfo::default() .with_hops(hops(&[0, 7])) .with_cost(1) .with_via(origin(7)), @@ -9039,7 +9231,7 @@ mod tests { announced.expect_next_active("room").await; let _identified = producer - .announce("room", Route::default().with_hops(hops(&[10, 20])).with_cost(5)) + .announce("room", RouteInfo::default().with_hops(hops(&[10, 20])).with_cost(5)) .unwrap(); let route = announced.expect_next_active("room").await; assert!(!route.is_anonymous()); @@ -9053,10 +9245,10 @@ mod tests { let consumer = producer.consume(); let anonymous = producer - .requests_route("room", Route::default().with_hops(hops(&[0])).with_cost(1), None) + .forward("room", RouteInfo::default().with_hops(hops(&[0])).with_cost(1), None) .unwrap(); let identified = producer - .requests_route("room", Route::default().with_hops(hops(&[10])).with_cost(5), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])).with_cost(5), None) .unwrap(); let _pending = consumer.request("room/alice", None); @@ -9077,10 +9269,10 @@ mod tests { let demoted = producer .clone() .with_preference(Preference::new(-1)) - .requests_route("room", Route::default().with_hops(hops(&[10])).with_cost(1), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])).with_cost(1), None) .unwrap(); let unranked = producer - .requests_route("room", Route::default().with_hops(hops(&[11])).with_cost(5), None) + .forward("room", RouteInfo::default().with_hops(hops(&[11])).with_cost(5), None) .unwrap(); let _pending = consumer.request("room/alice", None); @@ -9097,10 +9289,10 @@ mod tests { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let announcement = producer.announce("room", Route::default()).unwrap(); + let announcement = producer.announce("room", RouteInfo::default()).unwrap(); announced.expect_next_active("room").await; - announcement.update(Route::default().with_cost(9)).unwrap(); + announcement.update(RouteInfo::default().with_cost(9)).unwrap(); let route = announced.expect_next_active("room").await; assert_eq!(route.cost, Cost::new(9)); } @@ -9112,24 +9304,24 @@ mod tests { let mut announced = producer.consume().announced(); let dynamic = producer - .requests_route("room", Route::default().with_instance(instance(), 0).with_cost(5), None) + .forward("room", RouteInfo::default().with_instance(instance(), 0).with_cost(5), None) .unwrap(); announced.expect_next_active("room").await; - dynamic.update_route(dynamic.route().with_cost(1)).unwrap(); + dynamic.update(dynamic.route().with_cost(1)).unwrap(); let route = announced.expect_next_active("room").await; assert_eq!((route.instance, route.cost), (Some(instance()), Cost::new(1))); assert_eq!(dynamic.route().cost, Cost::new(1)); - let broadcast = producer.create_broadcast("lobby").unwrap(); + let broadcast = producer.route("lobby", RouteOptions::hidden()).unwrap(); assert!(broadcast.route().is_none(), "not announced yet"); broadcast - .announce(Route::default().with_instance(instance(), 0).with_cost(5)) + .announce(RouteInfo::default().with_instance(instance(), 0).with_cost(5)) .unwrap(); announced.expect_next_active("lobby").await; broadcast.announce(broadcast.route().unwrap().with_cost(1)).unwrap(); let route = announced.expect_next_active("lobby").await; assert_eq!((route.instance, route.cost), (Some(instance()), Cost::new(1))); - broadcast.unannounce(); + broadcast.withdraw(); assert!(broadcast.route().is_none(), "withdrawn"); } @@ -9138,13 +9330,13 @@ mod tests { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let announcement = producer.announce("room", Route::default()).unwrap(); + let announcement = producer.announce("room", RouteInfo::default()).unwrap(); announced.expect_next_active("room").await; // Reprice, then retract before the consumer observes the reprice: the // pending metadata update must not cancel the retraction the delivered // announce still owes. - announcement.update(Route::default().with_cost(9)).unwrap(); + announcement.update(RouteInfo::default().with_cost(9)).unwrap(); drop(announcement); announced.expect_next_ended("room").await; announced.assert_next_wait(); @@ -9155,8 +9347,8 @@ mod tests { let producer = origin(1).produce(); // Broad and cheap; narrow and expensive. Both present relative to a cursor // rooted below them, and the narrow one is what a request there resolves. - let _broad = producer.announce("room", Route::default().with_cost(1)).unwrap(); - let _narrow = producer.announce("room/alice", Route::default().with_cost(9)).unwrap(); + let _broad = producer.announce("room", RouteInfo::default().with_cost(1)).unwrap(); + let _narrow = producer.announce("room/alice", RouteInfo::default().with_cost(9)).unwrap(); let consumer = producer .consume() @@ -9172,8 +9364,8 @@ mod tests { #[cfg(feature = "async")] async fn capture_change_retracts_before_reannouncing_a_presented_prefix() { let producer = origin(1).produce(); - let _broad = producer.announce("room", Route::default()).unwrap(); - let exact = producer.announce("room/alice", Route::default()).unwrap(); + let _broad = producer.announce("room", RouteInfo::default()).unwrap(); + let exact = producer.announce("room/alice", RouteInfo::default()).unwrap(); let consumer = producer .consume() .scope("", &Patterns::from("room/*".parse::().unwrap())) @@ -9222,13 +9414,13 @@ mod tests { assert!((&mut resolving).now_or_never().is_none()); // Creating is not announcing: still parked. - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.route("room/alice", RouteOptions::hidden()).unwrap(); for _ in 0..20 { kio::clock::sim::yield_now().await; } assert!((&mut resolving).now_or_never().is_none()); - broadcast.announce(Route::default()).unwrap(); + broadcast.announce().unwrap(); let resolved = resolving.await.expect("resolves once announced"); assert_eq!(resolved.info().path.as_str(), "room/alice"); drop(broadcast); @@ -9244,14 +9436,14 @@ mod tests { let mut announced = consumer.announced(); let _local = producer - .publish("room/alice", Route::default().with_instance(instance(), 0).with_cost(5)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0).with_cost(5)) .unwrap(); assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(5)); let server = producer - .requests_route( + .forward( "room/alice", - Route::default() + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(&[10])) .with_cost(1), @@ -9279,9 +9471,9 @@ mod tests { let consumer = producer.consume(); let _stable = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); - let minted = producer.publish("room/bob", Route::default()).unwrap(); + let minted = producer.route("room/bob", RouteOptions::default()).unwrap(); let alice = consumer.request("room/alice", None).await.unwrap(); assert_eq!(alice.info().instance, Some(instance())); @@ -9300,14 +9492,14 @@ mod tests { let consumer = producer.consume(); let _local = producer - .publish("room/alice", Route::default().with_instance(instance(), 0).with_cost(5)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0).with_cost(5)) .unwrap(); let first = consumer.request("room/alice", None).await.expect("resolves locally"); let server = producer - .requests_route( + .forward( "room/alice", - Route::default() + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(&[10])) .with_cost(1), @@ -9340,15 +9532,15 @@ mod tests { async fn a_front_lists_its_source() { let producer = origin(1).produce(); let consumer = producer.consume(); - let source = producer.publish("room/alice", Route::default()).unwrap(); - let video = source.create_track("video", None).unwrap(); + let source = producer.route("room/alice", RouteOptions::default()).unwrap(); + let video = source.broadcast().create_track("video", None).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"); - let _audio = source.create_track("audio", None).unwrap(); + let _audio = source.broadcast().create_track("audio", None).unwrap(); assert_eq!(listed(&mut tracks).await, "+audio"); drop(video); assert_eq!(listed(&mut tracks).await, "-video"); @@ -9364,10 +9556,10 @@ mod tests { async fn a_front_forwards_the_finishes_before_its_source_closed() { let producer = origin(1).produce(); let consumer = producer.consume(); - let source = producer.publish("room/alice", Route::default()).unwrap(); - let dropped = source.create_track("dropped", None).unwrap(); - let held = source.create_track("held", None).unwrap(); - let _live = source.create_track("live", None).unwrap(); + let source = producer.route("room/alice", RouteOptions::default()).unwrap(); + let dropped = source.broadcast().create_track("dropped", None).unwrap(); + let held = source.broadcast().create_track("held", None).unwrap(); + let _live = source.broadcast().create_track("live", None).unwrap(); let front = consumer.request("room/alice", None).await.unwrap(); let mut tracks = front.tracks().unwrap(); @@ -9378,7 +9570,7 @@ mod tests { dropped.finish().unwrap(); drop(dropped); held.finish().unwrap(); - source.close(); + source.broadcast().close(); for event in ["~dropped", "~held", "end"] { assert_eq!(listed(&mut tracks).await, event); } @@ -9391,8 +9583,8 @@ mod tests { async fn a_front_ends_its_listing_with_its_sources() { let producer = origin(1).produce(); let consumer = producer.consume(); - let source = producer.publish("room/alice", Route::default()).unwrap(); - let lister = source.requests().lister().unwrap(); + let source = producer.route("room/alice", RouteOptions::default()).unwrap(); + let lister = source.broadcast().requests().lister().unwrap(); lister.add("video", crate::track::Info::default()).unwrap(); lister.synced(); @@ -9414,10 +9606,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let local = producer - .publish("room/alice", Route::default().with_instance(instance(), 0).with_cost(5)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0).with_cost(5)) .unwrap(); - let _a = local.create_track("a", None).unwrap(); - let _b = local.create_track("b", None).unwrap(); + let _a = local.broadcast().create_track("a", None).unwrap(); + let _b = local.broadcast().create_track("b", None).unwrap(); let front = consumer.request("room/alice", None).await.unwrap(); let mut tracks = front.tracks().unwrap(); @@ -9426,9 +9618,9 @@ mod tests { assert_eq!(listed(&mut tracks).await, "synced"); let server = producer - .requests_route( + .forward( "room/alice", - Route::default() + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(&[10])) .with_cost(1), @@ -9452,7 +9644,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let first = producer - .requests_route("room/alice", Route::default().with_hops(hops(&[10])), None) + .forward("room/alice", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); @@ -9464,7 +9656,7 @@ mod tests { assert_eq!(listed(&mut tracks).await, "synced"); let second = producer - .requests_route("room/alice", Route::default().with_hops(hops(&[10])), Some(&first)) + .forward("room/alice", RouteInfo::default().with_hops(hops(&[10])), Some(&first)) .unwrap(); kio::clock::sim::yield_now().await; drop(first); @@ -9495,7 +9687,7 @@ mod tests { #[cfg(feature = "async")] async fn follows_a_chain_of_takeovers(links: u64, named: bool) { let route = |link: u64| { - let route = Route::default().with_hops(hops(&[10])); + let route = RouteInfo::default().with_hops(hops(&[10])); match named { true => route.with_instance(format!("link-{link}").parse().unwrap(), 0), false => route, @@ -9503,7 +9695,7 @@ mod tests { }; let producer = origin(1).produce(); let consumer = producer.consume(); - let first = producer.requests_route("room/alice", route(0), None).unwrap(); + let first = producer.forward("room/alice", route(0), None).unwrap(); let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let _a = upstream.create_track("a", None).unwrap(); @@ -9516,7 +9708,7 @@ mod tests { // Each link takes over the one before and retires it, with no yield between. let mut last = first; for link in 1..=links { - let next = producer.requests_route("room/alice", route(link), Some(&last)).unwrap(); + let next = producer.forward("room/alice", route(link), Some(&last)).unwrap(); drop(std::mem::replace(&mut last, next)); } @@ -9540,21 +9732,21 @@ mod tests { #[cfg(feature = "async")] async fn a_renewed_successor_continues_nothing() { let route = |link: u64| { - Route::default() + RouteInfo::default() .with_hops(hops(&[10])) .with_instance(format!("link-{link}").parse().unwrap(), 0) }; let producer = origin(1).produce(); let consumer = producer.consume(); - let first = producer.requests_route("room/alice", route(0), None).unwrap(); + let first = producer.forward("room/alice", route(0), None).unwrap(); let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); queued(&first).await.serve(&upstream); let resolved = pending.await.unwrap(); // Taken over, then renewed, with no yield between. - let second = producer.requests_route("room/alice", route(1), Some(&first)).unwrap(); - second.update_route(route(2)).unwrap(); + let second = producer.forward("room/alice", route(1), Some(&first)).unwrap(); + second.update(route(2)).unwrap(); kio::clock::sim::yield_now().await; let pending = consumer.request("room/alice", None); @@ -9578,7 +9770,7 @@ mod tests { async fn a_front_through_a_covering_prefix_lists_nothing() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.requests_route("room", Route::default(), None).unwrap(); + let server = producer.forward("room", RouteInfo::default(), None).unwrap(); let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let _video = upstream.create_track("video", None).unwrap(); @@ -9598,8 +9790,8 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let _local = producer.publish("room/alice", Route::default()).unwrap(); - let server = producer.requests_route("room/alice", Route::default(), None).unwrap(); + let _local = producer.route("room/alice", RouteOptions::default()).unwrap(); + let server = producer.forward("room/alice", RouteInfo::default(), None).unwrap(); // Were the claim to win, the request would park on its handler forever. let resolved = kio::clock::timeout(Duration::from_secs(1), consumer.request("room/alice", None)) @@ -9630,19 +9822,19 @@ mod tests { .unwrap_or_default() }; - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.route("room/alice", RouteOptions::hidden()).unwrap(); assert_eq!(announces(), (0, 0), "a hidden broadcast is not announced"); - broadcast.announce(Route::default()).unwrap(); + broadcast.announce().unwrap(); broadcast - .announce(Route { + .announce(RouteInfo { cost: Cost::new(3), - ..Route::default() + ..RouteInfo::default() }) .unwrap(); assert_eq!(announces(), (1, 0), "a re-price is not another announce"); - broadcast.unannounce(); + broadcast.withdraw(); assert_eq!(announces(), (1, 1)); - broadcast.announce(Route::default()).unwrap(); + broadcast.announce().unwrap(); drop(broadcast); assert_eq!(announces(), (2, 2)); } @@ -9656,9 +9848,9 @@ mod tests { let mut announced = consumer.announced(); let server = producer - .requests_route( + .forward( "room/alice", - Route::default() + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(&[10])) .with_cost(2), @@ -9667,7 +9859,7 @@ mod tests { .unwrap(); announced.expect_next_active("room/alice").await; let _local = producer - .publish("room/alice", Route::default().with_instance(instance(), 0).with_cost(2)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0).with_cost(2)) .unwrap(); assert!(announced.expect_next_active("room/alice").await.hops.is_empty()); @@ -9687,17 +9879,17 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); - broadcast.unannounce(); + broadcast.withdraw(); 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"); + assert!(!broadcast.broadcast().consume().is_closed(), "the broadcast itself lives on"); // Announcing again serves a fresh front. - broadcast.announce(Route::default()).unwrap(); + broadcast.announce().unwrap(); let again = consumer.request("room/alice", None).await.expect("resolves again"); assert!(!again.is_clone(&resolved)); } @@ -9713,12 +9905,9 @@ mod tests { let consumer = producer.consume(); let broadcast = producer - .publish( - "room/alice", - Route::default().with_instance(crate::Instance::random(), 0), - ) + .route("room/alice", RouteOptions::default().with_instance(crate::Instance::random(), 0)) .unwrap(); - let mut dynamic = broadcast.requests(); + let mut dynamic = broadcast.broadcast().requests(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let track = resolved.track("video").unwrap(); let mut subscribing = track.subscribe(crate::track::Subscription::default().with_priority(3)); @@ -9729,9 +9918,9 @@ mod tests { .expect("request"); let _replacement = replacement.then(|| { producer - .requests_route( + .forward( "room/alice", - Route::default() + RouteInfo::default() .with_instance(crate::Instance::random(), 0) .with_hops(hops(&[10])), None, @@ -9740,9 +9929,9 @@ mod tests { }); if close { - broadcast.close(); + broadcast.broadcast().close(); } else { - broadcast.unannounce(); + broadcast.withdraw(); } settle(|| resolved.is_closed()).await; subscribing @@ -9777,7 +9966,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer - .requests_route("room/alice", Route::default().with_hops(hops(&[10])), None) + .forward("room/alice", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); @@ -9858,7 +10047,7 @@ mod tests { let producer = origin(1).produce(); // A prefix route, which resolves any path beneath it optimistically. let server = producer - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); @@ -9910,7 +10099,7 @@ mod tests { async fn a_hop_in_a_chain_gets_its_own_front() { let producer = origin(1).produce(); let _incumbent = producer - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let fronts = || producer.shared.lock().fronts.len(); @@ -9921,7 +10110,7 @@ mod tests { // The same publisher, now also reached through the peer. let _echo = producer - .requests_route("room", Route::default().with_hops(hops(&[10, 7])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10, 7])), None) .unwrap(); let _filtered = peer.request("room/alice", None); assert_eq!(fronts(), 2, "the peer still shares the plain front"); @@ -9937,7 +10126,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); @@ -9972,7 +10161,7 @@ mod tests { async fn a_request_racing_a_front_retiring_never_joins_it_ending() { let producer = origin(1).produce(); let consumer = producer.consume(); - let _broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let _broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); let fronts = || producer.shared.lock().fronts.len(); let first = consumer.request("room/alice", None).await.expect("resolves"); @@ -9998,7 +10187,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", None).unwrap(); @@ -10027,7 +10216,7 @@ mod tests { async fn a_front_whose_broadcast_closes_ends() { let producer = origin(1).produce(); let consumer = producer.consume(); - let _published = producer.publish("room/alice", Route::default()).unwrap(); + let _published = producer.route("room/alice", RouteOptions::default()).unwrap(); let path = consumer.absolute("room/alice").unwrap(); let broadcast = broadcast::Info::new().produce(); // Held, so the front waits on its holder rather than retiring on its own. @@ -10068,11 +10257,11 @@ mod tests { async fn a_peers_filtered_front_ends_once_unread() { let producer = origin(1).produce(); let server = producer - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); // The same publisher, also reached through the peer, at a price the plain front skips. let _echo = producer - .requests_route("room", Route::default().with_hops(hops(&[10, 7])).with_cost(100), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10, 7])).with_cost(100), None) .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); @@ -10108,9 +10297,9 @@ mod tests { let peer = producer.consume().excluding(origin(7)); let mut view = peer.announced(); let incumbent = producer - .requests_route( + .forward( "room", - Route::default().with_instance(instance(), 0).with_hops(hops(&[10])), + RouteInfo::default().with_instance(instance(), 0).with_hops(hops(&[10])), None, ) .unwrap(); @@ -10123,9 +10312,9 @@ mod tests { // The same publisher, now also reached through the peer, outlives the incumbent. let echo = producer - .requests_route( + .forward( "room", - Route::default().with_instance(instance(), 0).with_hops(hops(&[10, 7])), + RouteInfo::default().with_instance(instance(), 0).with_hops(hops(&[10, 7])), None, ) .unwrap(); @@ -10156,9 +10345,9 @@ mod tests { async fn takeover_keeps_the_open_group_head(dies_first: bool) { let producer = origin(1).produce(); let first_server = producer - .requests_route( + .forward( "room/alice", - Route::default() + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(&[10])) .with_cost(5), @@ -10215,9 +10404,9 @@ mod tests { } let cost = if dies_first { 5 } else { 0 }; let replacement_server = producer - .requests_route( + .forward( "room/alice", - Route::default() + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(&[10])) .with_cost(cost), @@ -10329,8 +10518,8 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); - let mut dynamic = broadcast.requests(); + let broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let track = resolved.track("video").unwrap(); let subscribing = kio::clock::sim::spawn(async move { track.subscribe(None).await }); @@ -10360,7 +10549,7 @@ mod tests { .expect("the front asked the source again") .expect("request"); - broadcast.unannounce(); + broadcast.withdraw(); settle(|| resolved.is_closed()).await; // A fresh source copy numbers groups past what the cache already delivered. @@ -10386,11 +10575,11 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broadcast = producer.publish("room/alice", Route::default()).unwrap(); + let broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); - broadcast.unannounce(); - broadcast.announce(Route::default()).unwrap(); + broadcast.withdraw(); + broadcast.announce().unwrap(); for _ in 0..20 { kio::clock::sim::yield_now().await; } @@ -10406,7 +10595,7 @@ mod tests { let consumer = producer.consume(); // Created but not announced: nobody can reach it, locally included. - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.route("room/alice", RouteOptions::hidden()).unwrap(); let err = consumer .request("room/alice", None) .now_or_never() @@ -10415,7 +10604,7 @@ mod tests { .unwrap(); assert!(matches!(err, Error::Unroutable)); - broadcast.announce(Route::default()).unwrap(); + broadcast.announce().unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); assert_eq!(resolved.info().path.as_str(), "room/alice"); drop(broadcast); @@ -10434,10 +10623,10 @@ mod tests { async fn create_broadcast_accepts_a_path_at_the_wire_limits() { let producer = origin(1).produce(); let path = vec!["a"; Path::MAX_PARTS].join("/"); - let _broadcast = producer.create_broadcast(path.as_str()).expect("max depth is allowed"); + let _broadcast = producer.route(path.as_str(), RouteOptions::hidden()).expect("max depth is allowed"); let deeper = vec!["a"; Path::MAX_PARTS + 1].join("/"); assert!(matches!( - producer.create_broadcast(deeper.as_str()), + producer.route(deeper.as_str(), RouteOptions::hidden()), Err(Error::BoundsExceeded(_)) )); @@ -10445,11 +10634,11 @@ mod tests { let rooted = producer.scope("r", &Patterns::from(Pattern::all())).unwrap(); let longest = "b".repeat(Path::MAX_BYTES - 2); let _long = rooted - .create_broadcast(longest.as_str()) + .route(longest.as_str(), RouteOptions::hidden()) .expect("max length is allowed"); let longer = "c".repeat(Path::MAX_BYTES - 1); assert!(matches!( - rooted.create_broadcast(longer.as_str()), + rooted.route(longer.as_str(), RouteOptions::hidden()), Err(Error::BoundsExceeded(_)) )); } @@ -10459,10 +10648,10 @@ mod tests { async fn duplicate_routes_aggregate_until_the_last_leaves() { let producer = origin(1).produce(); let first = producer - .requests_route("live", Route::default().with_cost(3), None) + .forward("live", RouteInfo::default().with_cost(3), None) .unwrap(); let second = producer - .requests_route("live", Route::default().with_cost(1), None) + .forward("live", RouteInfo::default().with_cost(1), None) .unwrap(); let mut announced = producer.consume().announced(); @@ -10487,14 +10676,14 @@ mod tests { let producer = origin(1).produce(); let scoped = producer.scope("", &scopes(&["room"])).unwrap(); let _broad = scoped - .requests_route("", Route::default(), None) + .forward("", RouteInfo::default(), None) .expect("an overlapping prefix is accepted"); let _ok = scoped - .requests_route("room/alice", Route::default(), None) + .forward("room/alice", RouteInfo::default(), None) .expect("a contained prefix is accepted"); assert!(matches!( - scoped.requests_route("other", Route::default(), None), + scoped.forward("other", RouteInfo::default(), None), Err(Error::Unauthorized) )); } @@ -10505,7 +10694,7 @@ mod tests { let producer = origin(1).produce(); let scope = Patterns::from("*/chat".parse::().unwrap()); let scoped = producer.scope("", &scope).unwrap(); - let dynamic = scoped.requests_route("", Route::default(), None).unwrap(); + let dynamic = scoped.forward("", RouteInfo::default(), None).unwrap(); let mut matching = producer .consume() @@ -10528,7 +10717,7 @@ mod tests { .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()); + assert!(dynamic.requested().now_or_never().is_none()); let _pending = producer.consume().request("room/chat", None); let request = queued(&dynamic).await; @@ -10544,10 +10733,10 @@ mod tests { .unwrap() }; let _chat = scoped("*/chat") - .requests_route("", Route::default().with_cost(1), None) + .forward("", RouteInfo::default().with_cost(1), None) .unwrap(); let _video = scoped("*/video") - .requests_route("", Route::default().with_cost(5), None) + .forward("", RouteInfo::default().with_cost(5), None) .unwrap(); let mut video = producer @@ -10580,7 +10769,7 @@ mod tests { let chat = producer .scope("", &scopes(&["room/live/chat"])) .unwrap() - .requests_route("room/live", Route::default().with_hops(hops(&[7])).with_cost(1), None) + .forward("room/live", RouteInfo::default().with_hops(hops(&[7])).with_cost(1), None) .unwrap(); assert_eq!(all.expect_next_active("room/live").await.cost, Cost::new(1)); assert_eq!(rooted.expect_next_active("").await.cost, Cost::new(1)); @@ -10590,14 +10779,14 @@ mod tests { let video_route = producer .scope("", &scopes(&["room/live/video"])) .unwrap() - .requests_route("room/live", Route::default().with_hops(hops(&[8])).with_cost(5), None) + .forward("room/live", RouteInfo::default().with_hops(hops(&[8])).with_cost(5), None) .unwrap(); all.assert_next_wait(); rooted.assert_next_wait(); assert_eq!(excluded.expect_next_active("room/live").await.cost, Cost::new(5)); assert_eq!(video.expect_next_active("room/live").await.cost, Cost::new(5)); - chat.update_route(Route::default().with_hops(hops(&[7])).with_cost(9)) + chat.update(RouteInfo::default().with_hops(hops(&[7])).with_cost(9)) .unwrap(); assert_eq!(all.expect_next_active("room/live").await.cost, Cost::new(5)); assert_eq!(rooted.expect_next_active("").await.cost, Cost::new(5)); @@ -10616,10 +10805,10 @@ mod tests { async fn root_cursor_keeps_the_more_specific_covering_route() { let producer = origin(1).produce(); let broad = producer - .requests_route("room", Route::default().with_cost(1), None) + .forward("room", RouteInfo::default().with_cost(1), None) .unwrap(); let narrow = producer - .requests_route("room/live", Route::default().with_cost(9), None) + .forward("room/live", RouteInfo::default().with_cost(9), None) .unwrap(); let mut announced = producer .consume() @@ -10629,9 +10818,9 @@ mod tests { .announced(); assert_eq!(announced.expect_next_active("").await.cost, Cost::new(9)); - broad.update_route(Route::default().with_cost(0)).unwrap(); + broad.update(RouteInfo::default().with_cost(0)).unwrap(); announced.assert_next_wait(); - narrow.update_route(Route::default().with_cost(8)).unwrap(); + narrow.update(RouteInfo::default().with_cost(8)).unwrap(); assert_eq!(announced.expect_next_active("").await.cost, Cost::new(8)); drop(narrow); assert_eq!(announced.expect_next_active("").await.cost, Cost::new(0)); @@ -10648,7 +10837,7 @@ mod tests { let mut announced = producer.consume().announced(); let dynamic = producer - .requests_route(&path, Route::default(), None) + .forward(&path, RouteInfo::default(), None) .expect("max depth is allowed"); announced.expect_next_active(&path).await; @@ -10661,7 +10850,7 @@ mod tests { async fn dynamic_exclusion_skips_routes_through_the_subscriber() { let producer = origin(1).produce(); let _server = producer - .requests_route("live", Route::default().with_hops(hops(&[7])), None) + .forward("live", RouteInfo::default().with_hops(hops(&[7])), None) .unwrap(); let mut excluded = producer.consume().excluding(origin(7)).announced(); @@ -10677,7 +10866,7 @@ mod tests { async fn announce_consumer_is_a_stream() { use futures::StreamExt; let producer = origin(1).produce(); - let server = producer.requests_route("live", Route::default(), None).unwrap(); + let server = producer.forward("live", RouteInfo::default(), None).unwrap(); let mut announced = producer.consume().announced(); let mut next = || StreamExt::next(&mut announced).now_or_never(); let Some(Some(AnnounceEvent::Start(update))) = next() else { @@ -10692,7 +10881,7 @@ mod tests { #[kio::test] async fn dynamic_retracts() { let producer = origin(1).produce(); - let server = producer.requests_route("live", Route::default(), None).unwrap(); + let server = producer.forward("live", RouteInfo::default(), None).unwrap(); let mut announced = producer.consume().announced(); announced.expect_next_active("live").await; @@ -10705,11 +10894,11 @@ mod tests { let producer = origin(1).produce(); let mut local = producer.consume().announced(); let mut peer = producer.consume().excluding(Hop::UNKNOWN).announced(); - let broadcast = producer.create_broadcast("room/alice").unwrap(); + let broadcast = producer.route("room/alice", RouteOptions::hidden()).unwrap(); local.assert_next_wait(); peer.assert_next_wait(); - broadcast.announce(Route::default()).unwrap(); + broadcast.announce().unwrap(); local.expect_next_active("room/alice").await; peer.expect_next_active("room/alice").await; @@ -10724,7 +10913,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.requests("room").unwrap(); + let server = producer.route_prefix("room", RouteOptions::default()).unwrap(); let pending = consumer.request("room/alice", None); let request = queued(&server).await; @@ -10747,7 +10936,7 @@ mod tests { async fn served_requests_coalesce() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.requests_route("room", Route::default(), None).unwrap(); + let server = producer.forward("room", RouteInfo::default(), None).unwrap(); let first = consumer.request("room/alice", None); let second = consumer.request("room/alice", None); @@ -10769,7 +10958,7 @@ mod tests { async fn retract_rejects_pending_requests() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.requests_route("room", Route::default(), None).unwrap(); + let server = producer.forward("room", RouteInfo::default(), None).unwrap(); let pending = consumer.request("room/alice", None); drop(server); @@ -10795,9 +10984,9 @@ mod tests { // Three identical routes, oldest first: the newest identical route wins // requests, and swapping between them emits no announce update. - let standby_server = producer.requests_route("room", Route::default(), None).unwrap(); - let second_server = producer.requests_route("room", Route::default(), None).unwrap(); - let incumbent_server = producer.requests_route("room", Route::default(), None).unwrap(); + let standby_server = producer.forward("room", RouteInfo::default(), None).unwrap(); + let second_server = producer.forward("room", RouteInfo::default(), None).unwrap(); + let incumbent_server = producer.forward("room", RouteInfo::default(), None).unwrap(); let mut following = consumer.follow("room/alice", None).unwrap(); let mut resolving = Box::pin(following.available()); @@ -10825,7 +11014,7 @@ mod tests { async fn split_horizon_skips_routes_through_the_requester() { let producer = origin(1).produce(); let _server = producer - .requests_route("room", Route::default().with_hops(hops(&[7])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[7])), None) .unwrap(); // The requester's own bytes must not be served back to it. @@ -10851,17 +11040,17 @@ mod tests { let mut announced = producer.consume().announced(); let _ingest = producer - .requests_route( + .forward( "client", - Route::default().with_hops(hops(&[5])).with_via(origin(5)), + RouteInfo::default().with_hops(hops(&[5])).with_via(origin(5)), None, ) .unwrap(); - let _gateway = producer.publish("gateway", Route::default()).unwrap(); + let _gateway = producer.route("gateway", RouteOptions::default()).unwrap(); let _forwarded = peer - .requests_route( + .forward( "forwarded", - Route::default().with_hops(hops(&[5, 7])).with_via(origin(7)), + RouteInfo::default().with_hops(hops(&[5, 7])).with_via(origin(7)), None, ) .unwrap(); @@ -10876,7 +11065,7 @@ mod tests { // The mark survives narrowing the handle. let scoped = peer.scope("room", &Patterns::from(Pattern::all())).unwrap(); let _nested = scoped - .requests_route("x", Route::default().with_via(origin(8)), None) + .forward("x", RouteInfo::default().with_via(origin(8)), None) .unwrap(); assert_eq!( announced.expect_next_active("room/x").await.source(), @@ -10906,15 +11095,15 @@ mod tests { // One instance, so the winner moving between routes is an update, not a restart. let route = |chain: &[u64], via| { - Route::default() + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(chain)) .with_via(origin(via)) }; - let near = peer.requests_route("room", route(&[9, 2], 2), None).unwrap(); + let near = peer.forward("room", route(&[9, 2], 2), None).unwrap(); announced.assert_try_next_active("room"); - let _far = peer.requests_route("room", route(&[9, 3, 4], 4), None).unwrap(); + let _far = peer.forward("room", route(&[9, 3, 4], 4), None).unwrap(); drop(near); assert!(announced.try_next().is_none(), "the update is held"); step(Duration::from_millis(1)).await; @@ -10941,7 +11130,7 @@ mod tests { let peer = producer.clone().with_link(Link::Peer); // One instance, so the winner moving between routes is an update, not a restart. let route = |chain: &[u64], via| { - Route::default() + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(chain)) .with_via(origin(via)) @@ -10950,11 +11139,11 @@ mod tests { let mut far = Vec::new(); for i in 0..k { near.push( - peer.requests_route(format!("room/{i}"), route(&[9, 2], 2), None) + peer.forward(format!("room/{i}"), route(&[9, 2], 2), None) .unwrap(), ); far.push( - peer.requests_route(format!("room/{i}"), route(&[9, 3, 4], 4), None) + peer.forward(format!("room/{i}"), route(&[9, 3, 4], 4), None) .unwrap(), ); } @@ -10996,17 +11185,17 @@ mod tests { // One instance, so the winner moving between routes is an update, not a restart. let route = |chain: &[u64], via| { - Route::default() + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(chain)) .with_via(origin(via)) }; - let near = peer.requests_route("room", route(&[9, 2], 2), None).unwrap(); + let near = peer.forward("room", route(&[9, 2], 2), None).unwrap(); announced.expect_next_active("room").await; // The best route changes twice; the consumer sees only the last, once. - let far = peer.requests_route("room", route(&[9, 3, 4], 4), None).unwrap(); - let farther = peer.requests_route("room", route(&[9, 5, 6, 7], 7), None).unwrap(); + let far = peer.forward("room", route(&[9, 3, 4], 4), None).unwrap(); + let farther = peer.forward("room", route(&[9, 5, 6, 7], 7), None).unwrap(); let start = kio::clock::now(); drop(near); drop(far); @@ -11034,36 +11223,36 @@ mod tests { // Every path is to one publisher, so to one instance. let route = |chain: &[u64], via| { - Route::default() + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(chain)) .with_via(origin(via)) }; - let near = peer.requests_route("named", route(&[9, 2], 2), None).unwrap(); + let near = peer.forward("named", route(&[9, 2], 2), None).unwrap(); announced.expect_next_active("named").await; drop(near); announced.expect_next_ended("named").await; let start = kio::clock::now(); - let _stale = peer.requests_route("named", route(&[9, 3, 4], 4), None).unwrap(); + let _stale = peer.forward("named", route(&[9, 3, 4], 4), None).unwrap(); match announced.next().await.unwrap() { AnnounceEvent::Start(announce) => assert_eq!(announce.route.hops, hops(&[9, 3, 4])), other => panic!("should be a start: got {other:?}"), } assert!(kio::clock::now() - start >= RETRACT_QUARANTINE); - let near = peer.requests_route("anonymous", route(&[0, 2], 2), None).unwrap(); + let near = peer.forward("anonymous", route(&[0, 2], 2), None).unwrap(); announced.expect_next_active("anonymous").await; drop(near); announced.expect_next_ended("anonymous").await; - let _other = peer.requests_route("anonymous", route(&[0, 3, 4], 4), None).unwrap(); + let _other = peer.forward("anonymous", route(&[0, 3, 4], 4), None).unwrap(); announced.expect_next_active("anonymous").await; // Retract and announce cycles at one clock reading queue the prefix once, // whether or not the route names its publisher. let queued = announced.anchoring.len(); for chain in [[9, 2], [0, 2], [9, 2], [0, 2]] { - let churn = peer.requests_route("churn", route(&chain, 2), None).unwrap(); + let churn = peer.forward("churn", route(&chain, 2), None).unwrap(); announced.expect_next_active("churn").await; drop(churn); announced.expect_next_ended("churn").await; @@ -11072,7 +11261,7 @@ mod tests { // A quarantine is forgotten once it ends: the cursor wakes to anchor it, // then again to drop it. - let gone = peer.requests_route("gone", route(&[9, 2], 2), None).unwrap(); + let gone = peer.forward("gone", route(&[9, 2], 2), None).unwrap(); announced.expect_next_active("gone").await; drop(gone); announced.expect_next_ended("gone").await; @@ -11095,12 +11284,12 @@ mod tests { let mut announced = producer.consume().announced(); // Publisher 9 ingests at relay 2; relay 3 relays 2's route. - let direct = || Route::default().with_hops(hops(&[9, 2])).with_via(origin(2)); - let first = peer.requests_route("room", direct(), None).unwrap(); + let direct = || RouteInfo::default().with_hops(hops(&[9, 2])).with_via(origin(2)); + let first = peer.forward("room", direct(), None).unwrap(); let relayed = peer - .requests_route( + .forward( "room", - Route::default().with_hops(hops(&[9, 2, 3])).with_via(origin(3)), + RouteInfo::default().with_hops(hops(&[9, 2, 3])).with_via(origin(3)), None, ) .unwrap(); @@ -11113,7 +11302,7 @@ mod tests { announced.assert_next_wait(); // Relay 2 announces again, and the relayed copy is live with it. - let second = peer.requests_route("room", direct(), None).unwrap(); + let second = peer.forward("room", direct(), None).unwrap(); announced.expect_next_active("room").await; assert!(producer.shared.lock().withdrawn.is_empty()); @@ -11132,9 +11321,9 @@ mod tests { let producer = origin(1).produce(); let peer = producer.clone().with_link(Link::Peer); let mut announced = producer.consume().announced(); - let route = Route::default().with_instance(instance(), 0).with_hops(hops(&[9, 2])); - let first = peer.requests_route("room", route.clone(), None).unwrap(); - let second = peer.requests_route("room", route.clone(), None).unwrap(); + let route = RouteInfo::default().with_instance(instance(), 0).with_hops(hops(&[9, 2])); + let first = peer.forward("room", route.clone(), None).unwrap(); + let second = peer.forward("room", route.clone(), None).unwrap(); announced.expect_next_active("room").await; announced.assert_next_wait(); let remaining = if old_first { @@ -11157,10 +11346,10 @@ mod tests { let producer = origin(1).produce(); let peer = producer.clone().with_link(Link::Peer); let direct = peer - .requests_route("room", Route::default().with_hops(hops(&[9, 2])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[9, 2])), None) .unwrap(); let _relayed = peer - .requests_route("room", Route::default().with_hops(hops(&[9, 2, 3])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[9, 2, 3])), None) .unwrap(); let path = Path::from_static("room/video"); let id = producer @@ -11186,18 +11375,18 @@ mod tests { let peer = producer.clone().with_link(Link::Peer); let mut announced = producer.consume().announced(); - let route = Route::default() + let route = RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(&[7])) .with_via(origin(7)); - let _forwarded = peer.requests_route("room", route.clone(), None).unwrap(); + let _forwarded = peer.forward("room", route.clone(), None).unwrap(); assert_eq!( announced.expect_next_active("room").await.source(), Source::Peer(origin(7)) ); // The newest identical route wins, so the local twin takes over. - let local = producer.requests_route("room", route, None).unwrap(); + let local = producer.forward("room", route, None).unwrap(); match announced.next().await.expect("no next") { AnnounceEvent::Update(announce) => assert_eq!(announce.route.source(), Source::Local), other => panic!("should be an update: got {other:?}"), @@ -11217,9 +11406,9 @@ mod tests { let mut local = producer.consume().local().announced(); let _forwarded = peer - .requests_route( + .forward( "remote", - Route::default().with_hops(hops(&[7])).with_via(origin(7)), + RouteInfo::default().with_hops(hops(&[7])).with_via(origin(7)), None, ) .unwrap(); @@ -11229,12 +11418,12 @@ mod tests { // and retracts from the local view when the local route goes, even though // the peer's still covers it. let _shadow = peer - .requests_route("both", Route::default().with_hops(hops(&[7])).with_via(origin(7)), None) + .forward("both", RouteInfo::default().with_hops(hops(&[7])).with_via(origin(7)), None) .unwrap(); let ingest = producer - .requests_route( + .forward( "both", - Route::default().with_hops(hops(&[5])).with_via(origin(5)).with_cost(9), + RouteInfo::default().with_hops(hops(&[5])).with_via(origin(5)).with_cost(9), None, ) .unwrap(); @@ -11274,7 +11463,7 @@ mod tests { let mut everyone = producer.consume().announced(); let _core = core - .requests_route("core", Route::default().with_hops(hops(&[7])).with_via(origin(7)), None) + .forward("core", RouteInfo::default().with_hops(hops(&[7])).with_via(origin(7)), None) .unwrap(); assert_eq!( everyone.expect_next_active("core").await.source(), @@ -11283,7 +11472,7 @@ mod tests { toward_core.assert_next_wait(); let _mesh = peer - .requests_route("mesh", Route::default().with_hops(hops(&[8])).with_via(origin(8)), None) + .forward("mesh", RouteInfo::default().with_hops(hops(&[8])).with_via(origin(8)), None) .unwrap(); assert_eq!( toward_core.expect_next_active("mesh").await.source(), @@ -11293,12 +11482,12 @@ mod tests { // A path both an upstream and a mesh peer reach: the upstream route is // cheaper, yet the upstream view selects the mesh peer's. let _cheap = core - .requests_route("both", Route::default().with_hops(hops(&[7])).with_via(origin(7)), None) + .forward("both", RouteInfo::default().with_hops(hops(&[7])).with_via(origin(7)), None) .unwrap(); let mesh = peer - .requests_route( + .forward( "both", - Route::default().with_hops(hops(&[8])).with_via(origin(8)).with_cost(9), + RouteInfo::default().with_hops(hops(&[8])).with_via(origin(8)).with_cost(9), None, ) .unwrap(); @@ -11330,7 +11519,7 @@ mod tests { async fn handler_rejection_is_final() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.requests_route("room", Route::default(), None).unwrap(); + let server = producer.forward("room", RouteInfo::default(), None).unwrap(); let pending = consumer.request("room/alice", None); let request = queued(&server).await; @@ -11356,18 +11545,18 @@ mod tests { async fn claim_answer_is_hidden_until_published_with_its_instance() { let producer = origin(1).produce(); let consumer = producer.consume(); - let claim = producer.requests("room").unwrap(); + let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); let mut pending = Box::pin(consumer.request("room/alice", None)); assert!((&mut pending).now_or_never().is_none()); - let prepared = queued(&claim).await.prepare().unwrap(); + let prepared = queued(&claim).await.route(RouteOptions::hidden()).unwrap(); let _track = prepared .broadcast() .create_track("video", crate::track::Info::timed()) .unwrap(); assert!((&mut pending).now_or_never().is_none()); - let published = prepared.publish().unwrap(); + let published = prepared.announce().unwrap(); let resolved = pending.await.unwrap(); assert_eq!(resolved.info().instance, published.route().unwrap().instance); assert_ne!( @@ -11384,18 +11573,18 @@ mod tests { async fn a_prepared_answer_cannot_announce_itself() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let claim = producer.requests("room").unwrap(); + let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); announced.assert_next_active("room"); let pending = producer.consume().request("room/alice", None); - let prepared = queued(&claim).await.prepare().unwrap(); + let prepared = queued(&claim).await.route(RouteOptions::hidden()).unwrap(); let answer = prepared.broadcast().clone(); - let other = Route::default().with_instance(crate::Instance::random(), 0); + let other = RouteInfo::default().with_instance(crate::Instance::random(), 0); assert!(matches!(answer.announce(other), Err(Error::Closed))); assert!(answer.route().is_none()); announced.assert_next_wait(); - let published = prepared.publish().unwrap(); + let published = prepared.announce().unwrap(); let instance = published.route().and_then(|route| route.instance); assert!(instance.is_some()); assert_eq!(pending.await.unwrap().info().instance, instance); @@ -11408,18 +11597,18 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let mut events = consumer.announced(); - let publication = producer.create_broadcast("room/alice").unwrap(); + let publication = producer.route("room/alice", RouteOptions::hidden()).unwrap(); let fill = publication.broadcast().clone(); let control = publication.clone(); publication - .announce(Route::default().with_instance(instance(), 0)) + .announce(RouteInfo::default().with_instance(instance(), 0)) .unwrap(); events.expect_next_active("room/alice").await; - control.unannounce(); + control.withdraw(); events.expect_next_ended("room/alice").await; assert!(publication.route().is_none()); publication - .announce(Route::default().with_instance(instance(), 0)) + .announce(RouteInfo::default().with_instance(instance(), 0)) .unwrap(); events.expect_next_active("room/alice").await; drop(control); @@ -11437,17 +11626,14 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let old = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); let replacement_instance: crate::Instance = "01900000-0000-7000-8000-000000000002".parse().unwrap(); let replacement = producer - .publish( - "room/alice", - Route::default().with_instance(replacement_instance.clone(), 0), - ) + .route("room/alice", RouteOptions::default().with_instance(replacement_instance.clone(), 0)) .unwrap(); - old.unannounce(); - old.close(); + old.withdraw(); + old.broadcast().close(); assert_eq!( replacement.route().unwrap().instance, Some(replacement_instance.clone()) @@ -11464,14 +11650,14 @@ mod tests { #[cfg(feature = "async")] async fn a_refused_prepared_answer_cannot_announce_later() { let producer = origin(1).produce(); - let claim = producer.requests("room").unwrap(); + let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); let _pending = producer.consume().request("room/alice", None); - let prepared = queued(&claim).await.prepare().unwrap(); + let prepared = queued(&claim).await.route(RouteOptions::hidden()).unwrap(); let answer = prepared.broadcast().clone(); drop(claim); - assert!(matches!(prepared.publish(), Err(Error::Unroutable))); - assert!(matches!(answer.announce(Route::default()), Err(Error::Closed))); + assert!(matches!(prepared.announce(), Err(Error::Unroutable))); + assert!(matches!(answer.announce(), Err(Error::Closed))); } #[kio::test] @@ -11479,9 +11665,9 @@ mod tests { async fn dropping_a_prepared_claim_answer_refuses_the_request() { let producer = origin(1).produce(); let consumer = producer.consume(); - let claim = producer.requests("room").unwrap(); + let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); let pending = consumer.request("room/alice", None); - let prepared = queued(&claim).await.prepare().unwrap(); + let prepared = queued(&claim).await.route(RouteOptions::hidden()).unwrap(); drop(prepared); assert!(matches!(pending.await, Err(Error::Unroutable))); } @@ -11492,14 +11678,14 @@ mod tests { async fn a_prepared_answer_for_an_abandoned_claim_is_never_announced() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let claim = producer.requests("room").unwrap(); + let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); announced.assert_next_active("room"); let _pending = producer.consume().request("room/alice", None); - let prepared = queued(&claim).await.prepare().unwrap(); + let prepared = queued(&claim).await.route(RouteOptions::hidden()).unwrap(); drop(claim); announced.assert_next_ended("room"); - assert!(matches!(prepared.publish(), Err(Error::Unroutable))); + assert!(matches!(prepared.announce(), Err(Error::Unroutable))); announced.assert_next_wait(); } @@ -11509,16 +11695,16 @@ mod tests { async fn a_prepared_answer_for_a_released_request_is_never_announced() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); - let claim = producer.requests("room").unwrap(); + let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); announced.assert_next_active("room"); let _pending = producer.consume().request("room/alice", None); - let prepared = queued(&claim).await.prepare().unwrap(); + let prepared = queued(&claim).await.route(RouteOptions::hidden()).unwrap(); claim - .update_route(Route::default().with_instance(crate::Instance::random(), 0)) + .update(RouteInfo::default().with_instance(crate::Instance::random(), 0)) .unwrap(); announced.assert_next_restarted("room"); - assert!(matches!(prepared.publish(), Err(Error::Unroutable))); + assert!(matches!(prepared.announce(), Err(Error::Unroutable))); announced.assert_next_wait(); } @@ -11528,12 +11714,12 @@ mod tests { #[cfg(feature = "async")] async fn a_withdrawn_publication_is_not_a_cached_claim_answer() { let producer = origin(1).produce(); - let claim = producer.requests("room").unwrap(); + let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); let path = Path::from_static("room/alice"); let pending = producer.consume().request(path.clone(), None); - let publication = queued(&claim).await.prepare().unwrap().publish().unwrap(); + let publication = queued(&claim).await.route(RouteOptions::hidden()).unwrap().announce().unwrap(); let held = pending.await.unwrap(); - publication.unannounce(); + publication.withdraw(); assert!( claim.state.lock().served.get(&path).is_none(), "withdrawn job still cached" @@ -11554,12 +11740,12 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let mut announced = consumer.announced(); - let claim = producer.requests("room").unwrap(); + let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); announced.assert_next_active("room"); let answer = async |path: &str| { let pending = consumer.request(path, None); - let published = queued(&claim).await.prepare().unwrap().publish().unwrap(); + let published = queued(&claim).await.route(RouteOptions::hidden()).unwrap().announce().unwrap(); pending.await.unwrap(); published }; @@ -11573,7 +11759,7 @@ mod tests { other => panic!("should be a takeover: got {other:?}"), } - answer("room/bob").await.unannounce(); + answer("room/bob").await.withdraw(); let _carol = answer("room/carol").await; match announced.expect_next().await { AnnounceEvent::Start(announce) => assert_eq!(announce.prefix.as_str(), "room/carol"), @@ -11589,12 +11775,12 @@ mod tests { async fn a_pinned_request_resolves_only_through_the_published_instance() { let producer = origin(1).produce(); let consumer = producer.consume(); - let claim = producer.requests("room").unwrap(); + let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); let unknown = consumer.request("room/alice", crate::Instance::random()); assert!(matches!(unknown.await, Err(Error::Unroutable))); let pending = consumer.request("room/alice", None); - let published = queued(&claim).await.prepare().unwrap().publish().unwrap(); + let published = queued(&claim).await.route(RouteOptions::hidden()).unwrap().announce().unwrap(); let instance = published.route().unwrap().instance.unwrap(); pending.await.expect("resolves"); @@ -11611,10 +11797,10 @@ mod tests { async fn refusal_never_falls_through() { let producer = origin(1).produce(); let consumer = producer.consume(); - let catch_all = producer.requests_route("", Route::default(), None).unwrap(); - let winner = producer.requests_route("room", Route::default(), None).unwrap(); + let catch_all = producer.forward("", RouteInfo::default(), None).unwrap(); + let winner = producer.forward("room", RouteInfo::default(), None).unwrap(); let sibling = producer - .requests_route("room", Route::default().with_cost(2), None) + .forward("room", RouteInfo::default().with_cost(2), None) .unwrap(); let mut pending = Box::pin(consumer.request("room/alice", None)); @@ -11641,15 +11827,15 @@ mod tests { async fn superseded_refusal_does_not_end_the_request() { let producer = origin(1).produce(); let consumer = producer.consume(); - let stale = producer.requests_route("room", Route::default(), None).unwrap(); + let stale = producer.forward("room", RouteInfo::default(), None).unwrap(); let mut pending = Box::pin(consumer.request("room/alice", None)); assert!((&mut pending).now_or_never().is_none()); let request = queued(&stale).await; // The local broadcast wins before the front sees the rejection. - let local = producer.create_broadcast("room/alice").unwrap(); - local.announce(Route::default()).unwrap(); + let local = producer.route("room/alice", RouteOptions::hidden()).unwrap(); + local.announce().unwrap(); request.reject(Error::NotFound); let mut result = None; @@ -11668,13 +11854,13 @@ mod tests { async fn refusal_from_a_beaten_route_asks_the_new_winner() { let producer = origin(1).produce(); let consumer = producer.consume(); - let stale = producer.requests_route("room", Route::default(), None).unwrap(); + let stale = producer.forward("room", RouteInfo::default(), None).unwrap(); let mut pending = Box::pin(consumer.request("room/alice", None)); assert!((&mut pending).now_or_never().is_none()); let request = queued(&stale).await; - let winner = producer.requests_route("room/alice", Route::default(), None).unwrap(); + let winner = producer.forward("room/alice", RouteInfo::default(), None).unwrap(); request.reject(Error::NotFound); let source = broadcast::Info::new().produce(); queued(&winner).await.serve(&source); @@ -11694,7 +11880,7 @@ mod tests { 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(), None).unwrap(); + let _server = producer.forward("room", RouteInfo::default(), None).unwrap(); // Park on the covering route, past the loop's closed check. let mut following = consumer.follow("room/alice", None).unwrap(); @@ -11718,7 +11904,7 @@ mod tests { async fn late_track_on_a_served_front_replays() { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.requests_route("room", Route::default(), None).unwrap(); + let server = producer.forward("room", RouteInfo::default(), None).unwrap(); let source = broadcast::Info::new().produce(); for name in ["a", "b"] { @@ -11759,10 +11945,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let broad_server = producer.requests_route("", Route::default(), None).unwrap(); + let broad_server = producer.forward("", RouteInfo::default(), None).unwrap(); // A narrow advertise-only claim: requests under it must NOT route to the // broad server; they fall through to the (absent) fallback handler. - let _narrow = producer.announce(".dash", Route::default()).unwrap(); + let _narrow = producer.announce(".dash", RouteInfo::default()).unwrap(); let err = consumer .request(".dash/pid", None) @@ -11784,7 +11970,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let mut announced = consumer.announced(); - let dynamic = producer.requests_route("", Route::default(), None).unwrap(); + let dynamic = producer.forward("", RouteInfo::default(), None).unwrap(); // The root claim is advertised like any other prefix. announced.expect_next_active("").await; @@ -11818,7 +12004,7 @@ mod tests { #[cfg(feature = "async")] async fn out_of_scope_request_never_reaches_the_dynamic_handler() { let producer = origin(1).produce(); - let dynamic = producer.requests_route("", Route::default(), None).unwrap(); + let dynamic = producer.forward("", RouteInfo::default(), None).unwrap(); let scoped = producer.consume().scope("", &scopes(&["tenant-a"])).unwrap(); // `tenant-a-other` shares a character prefix but not a segment, so this @@ -11830,7 +12016,7 @@ mod tests { .expect("an out-of-scope request must be refused synchronously, not queued"); assert!(matches!(refused, Err(Error::Unauthorized))); assert!( - dynamic.requested_broadcast().now_or_never().is_none(), + dynamic.requested().now_or_never().is_none(), "the dynamic handler was asked to create a broadcast the requester may not read" ); } @@ -11838,7 +12024,7 @@ mod tests { /// The route a follower's first event starts on. #[cfg(feature = "async")] - fn started(event: Option) -> Route { + fn started(event: Option) -> RouteInfo { match event.expect("routed") { AnnounceEvent::Start(announce) => announce.route, other => panic!("should start: got {other:?}"), @@ -11856,7 +12042,7 @@ mod tests { 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 _a = producer.announce("room", RouteInfo::default().with_cost(3)).unwrap(); let route = started(fut.now_or_never().expect("covered")); assert_eq!(route.cost, Cost::new(3)); @@ -11872,12 +12058,12 @@ mod tests { let consumer = producer.consume(); // A deeper route does not cover the shorter path. - let _deep = producer.announce("room/alice/cam", Route::default()).unwrap(); + let _deep = producer.announce("room/alice/cam", RouteInfo::default()).unwrap(); 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(); + let _exact = producer.announce("room/alice", RouteInfo::default()).unwrap(); started(fut.now_or_never().expect("covered")); } @@ -11899,7 +12085,7 @@ mod tests { 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(); + let _a = producer.announce("", RouteInfo::default()).unwrap(); started(fut.now_or_never().expect("covered")); } @@ -11908,11 +12094,11 @@ mod tests { async fn teardown_ends_everything() { let (producer, driver) = Producer::new(Config::new(origin(1))); let consumer = producer.consume(); - let _announcement = producer.announce("room", Route::default()).unwrap(); + let _announcement = producer.announce("room", RouteInfo::default()).unwrap(); let mut announced = consumer.announced(); announced.expect_next_active("room").await; - let _server = producer.requests_route("served", Route::default(), None).unwrap(); + let _server = producer.forward("served", RouteInfo::default(), None).unwrap(); let pending = consumer.request("served/path", None); drop(driver); @@ -11923,8 +12109,8 @@ mod tests { // Pending requests reject; new work refuses. assert!(matches!(pending.now_or_never().expect("rejected"), Err(Error::Closed))); - assert!(matches!(producer.announce("x", Route::default()), Err(Error::Closed))); - assert!(matches!(producer.create_broadcast("x"), Err(Error::Closed))); + assert!(matches!(producer.announce("x", RouteInfo::default()), Err(Error::Closed))); + assert!(matches!(producer.route("x", RouteOptions::hidden()), Err(Error::Closed))); let err = consumer .request("y", None) .now_or_never() @@ -11945,7 +12131,7 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let snapshot = producer.snapshot("room"); let mut announced = producer.consume().announced(); - let _alice = producer.announce("room/alice", Route::default()).unwrap(); + let _alice = producer.announce("room/alice", RouteInfo::default()).unwrap(); drop(driver); assert!(!announced.is_synced(), "the queue is still owed"); @@ -11957,7 +12143,7 @@ mod tests { #[test] 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(), None).unwrap(); + let server = producer.forward("room", RouteInfo::default(), None).unwrap(); 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 { @@ -11985,7 +12171,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(), None).unwrap(); + let server = producer.forward("room", RouteInfo::default(), None).unwrap(); let _pending = producer.consume().request("room/alice", None); driver.poll(Instant::ZERO, &kio::Waiter::noop()).unwrap(); let channel = server @@ -12040,9 +12226,9 @@ mod tests { let consumer = producer.consume(); let server = producer - .requests_route( + .forward( "room", - Route::default().with_instance(instance(), 0).with_hops(hops(first)), + RouteInfo::default().with_instance(instance(), 0).with_hops(hops(first)), None, ) .unwrap(); @@ -12087,9 +12273,9 @@ mod tests { /// back its handle, ready to answer the front's re-request. fn standby(&self, first: &[u64]) -> Requests { self.producer - .requests_route( + .forward( "room", - Route::default().with_instance(instance(), 0).with_hops(hops(first)), + RouteInfo::default().with_instance(instance(), 0).with_hops(hops(first)), None, ) .unwrap() @@ -12136,9 +12322,9 @@ mod tests { let (mut rig, _incumbent, _source) = ResumeRig::new(&[10]).await; let newer = rig .producer - .requests_route( + .forward( "room", - Route::default() + RouteInfo::default() .with_instance(instance(), 1) .with_hops(hops(&[11])) .with_cost(9), @@ -12163,9 +12349,9 @@ mod tests { let consumer = producer.consume(); let host = |name: &str, hop| { producer - .requests_route( + .forward( "pool", - Route::default() + RouteInfo::default() .with_instance(name.parse().unwrap(), 0) .with_hops(hops(&[hop])), None, @@ -12202,9 +12388,9 @@ mod tests { let consumer = producer.consume(); let host = |name: &str, hop| { producer - .requests_route( + .forward( "pool", - Route::default() + RouteInfo::default() .with_instance(name.parse().unwrap(), 0) .with_hops(hops(&[hop])), None, @@ -12262,7 +12448,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let first = producer - .requests_route("room", Route::default().with_hops(hops(&[10])).with_cost(5), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])).with_cost(5), None) .unwrap(); let pending = consumer.request("room/alice", None); let source = broadcast::Info::new().produce(); @@ -12273,7 +12459,7 @@ mod tests { deliver(&track, &mut subscription, b"first").await; let second = producer - .requests_route("room", Route::default().with_hops(hops(&[11])).with_cost(1), None) + .forward("room", RouteInfo::default().with_hops(hops(&[11])).with_cost(1), None) .unwrap(); deliver(&track, &mut subscription, b"pinned").await; @@ -12299,27 +12485,21 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let old = producer - .publish( - "room/alice", - Route::default() + .route("room/alice", RouteOptions::default() .with_instance(crate::Instance::random(), 0) - .with_cost(9), - ) + .with_cost(9)) .unwrap(); - let old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); + let old_track = old.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); 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; let new = producer - .publish( - "room/alice", - Route::default() + .route("room/alice", RouteOptions::default() .with_instance(crate::Instance::random(), 0) - .with_cost(1), - ) + .with_cost(1)) .unwrap(); - let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); + let new_track = new.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); deliver(&old_track, &mut subscription, b"sticky").await; let replaced = consumer.request("room/alice", None).await.expect("resolves"); @@ -12348,9 +12528,9 @@ mod tests { let consumer = producer.consume(); let first = crate::Instance::random(); let old = producer - .publish("room/alice", Route::default().with_instance(first.clone(), 0)) + .route("room/alice", RouteOptions::default().with_instance(first.clone(), 0)) .unwrap(); - let _old_track = old.create_track("video", crate::track::Info::timed()).unwrap(); + let _old_track = old.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); assert_eq!( resolved.info().instance.as_ref(), @@ -12360,9 +12540,9 @@ mod tests { let instance = crate::Instance::random(); let new = producer - .publish("room/alice", Route::default().with_instance(instance.clone(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance.clone(), 0)) .unwrap(); - let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); + let new_track = new.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let named = consumer.request("room/alice", instance.clone()); let bare = consumer.request("room/alice", None); @@ -12391,9 +12571,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let old = producer - .requests_route( + .forward( "room", - Route::default().with_instance(crate::Instance::random(), 0), + RouteInfo::default().with_instance(crate::Instance::random(), 0), None, ) .unwrap(); @@ -12402,12 +12582,9 @@ mod tests { // The answer and the new instance land in the same tick. let new = producer - .publish( - "room/alice", - Route::default().with_instance(crate::Instance::random(), 0), - ) + .route("room/alice", RouteOptions::default().with_instance(crate::Instance::random(), 0)) .unwrap(); - let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); + let new_track = new.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let stale = broadcast::Info::new().produce(); let _stale_track = stale.create_track("video", crate::track::Info::timed()).unwrap(); request.serve(&stale); @@ -12428,7 +12605,7 @@ mod tests { let consumer = producer.consume(); let old = crate::Instance::random(); let dynamic = producer - .requests_route("room", Route::default().with_instance(old.clone(), 0), None) + .forward("room", RouteInfo::default().with_instance(old.clone(), 0), None) .unwrap(); let pending = consumer.request("room/alice", None); let pinned = consumer.request("room/alice", old); @@ -12440,11 +12617,11 @@ mod tests { if answer_first { request.serve(&stale); dynamic - .update_route(dynamic.route().with_instance(instance.clone(), 0)) + .update(dynamic.route().with_instance(instance.clone(), 0)) .unwrap(); } else { dynamic - .update_route(dynamic.route().with_instance(instance.clone(), 0)) + .update(dynamic.route().with_instance(instance.clone(), 0)) .unwrap(); request.serve(&stale); } @@ -12488,9 +12665,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let dynamic = producer - .requests_route( + .forward( "room", - Route::default().with_instance(crate::Instance::random(), 0), + RouteInfo::default().with_instance(crate::Instance::random(), 0), None, ) .unwrap(); @@ -12498,7 +12675,7 @@ mod tests { queued(&dynamic).await.reject(Error::NotFound); let instance = crate::Instance::random(); dynamic - .update_route(dynamic.route().with_instance(instance.clone(), 0)) + .update(dynamic.route().with_instance(instance.clone(), 0)) .unwrap(); let fresh = broadcast::Info::new().produce(); @@ -12519,16 +12696,16 @@ mod tests { let consumer = producer.consume(); let old = crate::Instance::random(); let dynamic = producer - .requests_route("room", Route::default().with_instance(old.clone(), 0), None) + .forward("room", RouteInfo::default().with_instance(old.clone(), 0), None) .unwrap(); let pending = consumer.request("room/alice", None); let request = queued(&dynamic).await; dynamic - .update_route(dynamic.route().with_instance(crate::Instance::random(), 0)) + .update(dynamic.route().with_instance(crate::Instance::random(), 0)) .unwrap(); dynamic - .update_route(dynamic.route().with_instance(old.clone(), 0)) + .update(dynamic.route().with_instance(old.clone(), 0)) .unwrap(); let stale = broadcast::Info::new().produce(); let _stale_track = stale.create_track("video", crate::track::Info::timed()).unwrap(); @@ -12552,18 +12729,12 @@ mod tests { let mut announced = producer.consume().announced(); let instance = crate::Instance::random(); let _old = producer - .publish( - "room/alice", - Route::default().with_instance(instance.clone(), 1).with_cost(1), - ) + .route("room/alice", RouteOptions::default().with_instance(instance.clone(), 1).with_cost(1)) .unwrap(); assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(1)); let new = producer - .publish( - "room/alice", - Route::default().with_instance(instance.clone(), 2).with_cost(9), - ) + .route("room/alice", RouteOptions::default().with_instance(instance.clone(), 2).with_cost(9)) .unwrap(); let newest = announced.expect_next_active("room/alice").await; assert_eq!( @@ -12584,7 +12755,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let _broadcast = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); let other: crate::Instance = "01900000-0000-7000-8000-000000000002".parse().unwrap(); @@ -12712,7 +12883,7 @@ mod tests { for first in [&[][..], &[0][..], &[10][..]] { let (mut rig, server, _source) = ResumeRig::new(first).await; let standby = rig.standby(&[10, 20]); - server.update_route(Route::default().with_hops(hops(&[11]))).unwrap(); + server.update(RouteInfo::default().with_hops(hops(&[11]))).unwrap(); let mut group = rig.incumbent_track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"after".as_ref()).unwrap(); @@ -12746,17 +12917,17 @@ mod tests { None => producer.consume(), }; let incumbent = producer - .requests_route( + .forward( "room", - Route::default().with_instance(instance(), 0).with_hops(hops(&[10])), + RouteInfo::default().with_instance(instance(), 0).with_hops(hops(&[10])), None, ) .unwrap(); // The same publisher, reached through the requesting peer. let echo = producer - .requests_route( + .forward( "room", - Route::default().with_instance(instance(), 0).with_hops(hops(&[10, 7])), + RouteInfo::default().with_instance(instance(), 0).with_hops(hops(&[10, 7])), None, ) .unwrap(); @@ -12821,7 +12992,7 @@ mod tests { // Session A: an assigned anonymous hop serving the path. let server_a = producer - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); // Session C: a third anonymous session, excluding the hop the server @@ -12877,7 +13048,7 @@ mod tests { // Session B attaches at the same path. Its front is served immediately. let server_b = producer - .requests_route("room", Route::default().with_hops(hops(&[20])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[20])), None) .unwrap(); let pending = consumer.request("room/alice", None); let request = queued(&server_b).await; @@ -12919,7 +13090,7 @@ mod tests { // A metadata-only reprice of the only route: nothing re-requests and the // subscription keeps flowing from the same source. incumbent - .update_route(Route::default().with_hops(hops(&[10])).with_cost(9)) + .update(RouteInfo::default().with_hops(hops(&[10])).with_cost(9)) .unwrap(); let track = source.create_track("audio", crate::track::Info::timed()).unwrap(); @@ -12953,8 +13124,8 @@ mod tests { // keeps serving. The front migrates to the standby without waiting for // the death. incumbent - .update_route( - Route::default() + .update( + RouteInfo::default() .with_instance(instance(), 0) .with_hops(hops(&[10])) .with_cost(Cost::DRAIN), @@ -12976,21 +13147,21 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let first = producer.publish("room/alice", Route::default()).unwrap(); + let first = producer.route("room/alice", RouteOptions::default()).unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); - let second = producer.publish("room/alice", Route::default()).unwrap(); + let second = producer.route("room/alice", RouteOptions::default()).unwrap(); 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. - second.close(); + second.broadcast().close(); settle(|| consumer.get_broadcast("room/alice").is_some()).await; - first.close(); + first.broadcast().close(); settle(|| consumer.get_broadcast("room/alice").is_none()).await; // The path is free again for a fresh broadcast. - let _third = producer.publish("room/alice", Route::default()).unwrap(); + let _third = producer.route("room/alice", RouteOptions::default()).unwrap(); assert!(consumer.get_broadcast("room/alice").is_some()); } @@ -13003,7 +13174,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); // The front selected the covering route and waits on its answer. @@ -13011,7 +13182,7 @@ mod tests { 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 _winner = producer.route("room/alice", RouteOptions::default()).unwrap(); 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"); @@ -13025,14 +13196,14 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let covering = producer - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let pending = consumer.request("room/alice", None); let _beaten = queued(&covering).await; // The exact path wins, and the front asks it in turn. let exact = producer - .requests_route("room/alice", Route::default().with_hops(hops(&[10])), None) + .forward("room/alice", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let request = queued(&exact).await; let again = consumer.request("room/alice", None); @@ -13060,8 +13231,8 @@ mod tests { let producer = origin(1).produce(); 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 broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved @@ -13076,7 +13247,7 @@ mod tests { group.finish().unwrap(); track.finish().unwrap(); drop(track); - broadcast.close(); + broadcast.broadcast().close(); let mut group = next_group(&mut subscription) .await @@ -13103,7 +13274,7 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let pending = consumer.request("room/alice", None); @@ -13151,7 +13322,7 @@ mod tests { async fn a_closed_source_is_not_requested_again_from_its_standing_route() { let producer = origin(1).produce(); let server = producer - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let pending = producer.consume().request("room/alice", None); let source = broadcast::Info::new().produce(); @@ -13176,8 +13347,8 @@ mod tests { let producer = origin(1).produce(); 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 broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"cached".as_ref()).unwrap(); group.finish().unwrap(); @@ -13240,7 +13411,7 @@ mod tests { async fn a_held_group_continues_after_its_track_goes_unread() { let producer = origin(1).produce(); let server = producer - .requests_route("live", Route::default().with_hops(hops(&[10])), None) + .forward("live", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let pending = producer.consume().request("live", None); let source = broadcast::Info::new().produce(); @@ -13280,8 +13451,8 @@ mod tests { #[cfg(feature = "async")] async fn a_group_the_source_aborts_ends_while_the_track_lives() { 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 broadcast = producer.route("live", RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let resolved = producer.consume().request("live", None).await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -13315,8 +13486,8 @@ mod tests { let leaf = origin(1).produce(); let leaf_consumer = leaf.consume(); - let broadcast = leaf.publish("room/alice", Route::default()).unwrap(); - let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); + let broadcast = leaf.route("room/alice", RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"cached".as_ref()).unwrap(); group.finish().unwrap(); @@ -13326,7 +13497,7 @@ mod tests { let mid = origin(2).produce(); let mid_server = mid - .requests_route("room", Route::default().with_hops(hops(&[10])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[10])), None) .unwrap(); let mid_pending = mid.consume().request("room/alice", None); queued(&mid_server).await.serve(&leaf_front); @@ -13334,7 +13505,7 @@ mod tests { let edge = origin(3).produce(); let edge_server = edge - .requests_route("room", Route::default().with_hops(hops(&[20])), None) + .forward("room", RouteInfo::default().with_hops(hops(&[20])), None) .unwrap(); let edge_pending = edge.consume().request("room/alice", None); queued(&edge_server).await.serve(&mid_resolved); @@ -13414,9 +13585,9 @@ mod tests { let consumer = producer.consume(); let first = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); - let track = first.create_track("video", crate::track::Info::timed()).unwrap(); + let track = first.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved .track("video") @@ -13432,10 +13603,10 @@ mod tests { // The newest source is dispatched the track, and refused for its metadata. let second = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); let _incompatible = second - .create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) + .broadcast().create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) .unwrap(); for _ in 0..10 { kio::clock::sim::yield_now().await; @@ -13450,7 +13621,7 @@ mod tests { // The incumbent leaving exhausts the table: the refusal is never retried. drop(track); - first.close(); + first.broadcast().close(); assert!(matches!(subscription.recv_group().await, Err(Error::Unsupported))); } @@ -13466,9 +13637,9 @@ mod tests { ) { let producer = origin(1).produce(); let server = producer - .requests_route( + .forward( "room", - Route::default().with_instance(instance(), 0).with_hops(hops(&[10])), + RouteInfo::default().with_instance(instance(), 0).with_hops(hops(&[10])), None, ) .unwrap(); @@ -13494,10 +13665,10 @@ mod tests { async fn an_unread_draining_track_releases_the_old_source() { let (producer, _server, _upstream, old, subscription) = remote_front().await; - let newcomer = producer.create_broadcast("room/alice").unwrap(); + let newcomer = producer.route("room/alice", RouteOptions::hidden()).unwrap(); let mut handler = newcomer.requests(); newcomer - .announce(Route::default().with_instance(instance(), 0)) + .announce(RouteInfo::default().with_instance(instance(), 0)) .unwrap(); let _unanswered = kio::clock::timeout(Duration::from_secs(1), handler.requested_track()) .await @@ -13523,7 +13694,7 @@ mod tests { // No handler and no track: refuses "video" with NotFound. let _second = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); for _ in 0..10 { kio::clock::sim::yield_now().await; @@ -13542,7 +13713,7 @@ mod tests { .expect("open"); let _third = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); for _ in 0..10 { kio::clock::sim::yield_now().await; @@ -13618,7 +13789,7 @@ mod tests { .expect("open"); let newcomer = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); let _video = newcomer.create_track("video", crate::track::Info::timed()).unwrap(); for _ in 0..10 { @@ -13641,9 +13812,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let first = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); - let track = first.create_track("video", crate::track::Info::timed()).unwrap(); + let track = first.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); 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(); @@ -13653,10 +13824,10 @@ mod tests { assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); let second = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); let incompatible = second - .create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) + .broadcast().create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) .unwrap(); for _ in 0..10 { kio::clock::sim::yield_now().await; @@ -13668,7 +13839,7 @@ mod tests { // The refusal happened: the incumbent leaving surfaces it. drop(track); - first.close(); + first.broadcast().close(); assert!(matches!(subscription.recv_group().await, Err(Error::Unsupported))); } @@ -13681,9 +13852,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let first = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); - let track = first.create_track("video", crate::track::Info::timed()).unwrap(); + let track = first.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); 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(); @@ -13694,17 +13865,17 @@ mod tests { drop(group); let second = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); let incompatible = second - .create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) + .broadcast().create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) .unwrap(); for _ in 0..10 { kio::clock::sim::yield_now().await; } - first.unannounce(); - second.unannounce(); + first.withdraw(); + second.withdraw(); settle(|| resolved.is_closed()).await; let mut group = track.append_group().unwrap(); @@ -13737,9 +13908,9 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let first = producer - .publish("room/alice", Route::default().with_instance(instance(), 0)) + .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); - let track = first.create_track("video", crate::track::Info::timed()).unwrap(); + let track = first.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); 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(); @@ -13749,16 +13920,16 @@ mod tests { assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); drop(group); - let second = producer.create_broadcast("room/alice").unwrap(); - let mut handler = second.requests(); - second.announce(Route::default().with_instance(instance(), 0)).unwrap(); + let second = producer.route("room/alice", RouteOptions::hidden()).unwrap(); + let mut handler = second.broadcast().requests(); + second.announce(RouteInfo::default().with_instance(instance(), 0)).unwrap(); let request = kio::clock::timeout(Duration::from_secs(1), handler.requested_track()) .await .expect("the front asked the newcomer") .expect("request"); - first.unannounce(); - second.unannounce(); + first.withdraw(); + second.withdraw(); settle(|| resolved.is_closed()).await; let mut group = track.append_group().unwrap(); @@ -13776,7 +13947,7 @@ mod tests { #[kio::test] async fn multiple_scopes_present_one_broad_prefix() { let producer = origin(1).produce(); - let _a = producer.announce("", Route::default()).unwrap(); + let _a = producer.announce("", RouteInfo::default()).unwrap(); let consumer = producer .consume() @@ -13835,7 +14006,7 @@ mod tests { .scope("", &scopes(&["room/a", "other/deep/head"])) .unwrap() .announced(); - let route = producer.announce("room/a/b/c", Route::default()).unwrap(); + let route = producer.announce("room/a/b/c", RouteInfo::default()).unwrap(); { let table = producer.shared.lock(); assert!( @@ -13869,7 +14040,7 @@ mod tests { async fn a_published_broadcast_keeps_the_driver_running() { let (producer, mut driver) = Producer::new(Config::new(origin(1))); let waiter = kio::Waiter::noop(); - let broadcast = producer.create_broadcast("room/a").unwrap(); + let broadcast = producer.route("room/a", RouteOptions::hidden()).unwrap(); drop(producer); assert!( driver.poll(Instant::now(), &waiter).is_ok(), @@ -13887,7 +14058,7 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let run = kio::clock::sim::spawn(crate::time::run(driver)); let consumer = producer.consume(); - let server = producer.requests_route("room", Route::default(), None).unwrap(); + let server = producer.forward("room", RouteInfo::default(), None).unwrap(); drop(producer); let pending = consumer.request("room/alice", None); @@ -13914,12 +14085,12 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let run = kio::clock::sim::spawn(crate::time::run(driver)); 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 broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); - broadcast.unannounce(); + broadcast.withdraw(); settle(|| resolved.is_closed()).await; drop(broadcast); drop(producer); @@ -13939,13 +14110,13 @@ mod tests { let (producer, driver) = Producer::new(Config::new(origin(1))); let run = kio::clock::sim::spawn(crate::time::run(driver)); 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 broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); + let mut track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); 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); - broadcast.unannounce(); + broadcast.withdraw(); settle(|| resolved.is_closed()).await; drop(broadcast); drop(producer); @@ -13967,8 +14138,8 @@ mod tests { async fn a_track_unread_as_its_broadcast_ends_releases_its_source() { let producer = origin(1).produce(); 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 broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); kio::clock::timeout(Duration::from_secs(1), track.demand().until(|wanted| wanted.is_some())) @@ -13992,20 +14163,20 @@ mod tests { async fn source_selection_leases_survive_reprices_but_never_revive_pending_work() { let producer = origin(1).produce(); let broad = producer - .requests_route("room", Route::default().with_via(origin(2)), None) + .forward("room", RouteInfo::default().with_via(origin(2)), None) .unwrap(); let selected = broad.request_validity(&Path::from_static("room/a")).unwrap(); let pending = selected.current(); assert!(!pending.is_closed()); - broad.update_route(broad.route().with_cost(Cost::from(7))).unwrap(); + broad.update(broad.route().with_cost(Cost::from(7))).unwrap(); assert!(!pending.is_closed()); // Another peer's winning route cannot change what a request on peer 2 names. let other = producer - .requests_route("room/a", Route::default().with_via(origin(3)), None) + .forward("room/a", RouteInfo::default().with_via(origin(3)), None) .unwrap(); assert!(!pending.is_closed()); let replacement = producer - .requests_route("room/a", Route::default().with_via(origin(2)), None) + .forward("room/a", RouteInfo::default().with_via(origin(2)), None) .unwrap(); assert!(pending.is_closed()); assert!(selected.current().is_closed()); @@ -14027,15 +14198,15 @@ mod tests { let producer = origin(1).produce(); let path = Path::from_static("room/a"); let first = producer - .requests_route("room", Route::default().with_via(origin(2)), None) + .forward("room", RouteInfo::default().with_via(origin(2)), None) .unwrap(); let selected = first.request_validity(&path).unwrap(); let answering = selected.answering(); // A route that loses to the selected one replaces nothing. let worse = producer - .requests_route( + .forward( "room", - Route::default().with_via(origin(2)).with_cost(Cost::from(7)), + RouteInfo::default().with_via(origin(2)).with_cost(Cost::from(7)), None, ) .unwrap(); @@ -14043,7 +14214,7 @@ mod tests { drop(worse); let replacement = producer - .requests_route("room/a", Route::default().with_via(origin(2)), None) + .forward("room/a", RouteInfo::default().with_via(origin(2)), None) .unwrap(); assert!(answering.is_closed()); // Winning again opens a new lease, which a withdrawal leaves open. @@ -14056,7 +14227,7 @@ mod tests { // Announced again, the path has a new instance: a replacement. let _again = producer - .requests_route("room", Route::default().with_via(origin(2)), None) + .forward("room", RouteInfo::default().with_via(origin(2)), None) .unwrap(); assert!(answering.is_closed()); } @@ -14065,7 +14236,7 @@ mod tests { async fn source_selection_unregisters_without_retaining_the_source() { let producer = origin(1).produce(); let route = producer - .requests_route("room", Route::default().with_via(origin(2)), None) + .forward("room", RouteInfo::default().with_via(origin(2)), None) .unwrap(); let path = Path::from_static("room/a"); let selected = route.request_validity(&path).unwrap(); @@ -14087,12 +14258,12 @@ mod tests { let seen = watch.seen(); // A route beside the path or beneath it covers nothing at the path. - let _other = producer.announce("other", Route::default()).unwrap(); - let _below = producer.announce("room/a/b", Route::default()).unwrap(); + let _other = producer.announce("other", RouteInfo::default()).unwrap(); + let _below = producer.announce("room/a/b", RouteInfo::default()).unwrap(); assert!(watch.poll_changed(&waiter, seen).is_pending()); // A route above it does, and so does its retraction. - let above = producer.announce("room", Route::default()).unwrap(); + let above = producer.announce("room", RouteInfo::default()).unwrap(); assert!(watch.poll_changed(&waiter, seen).is_ready()); let seen = watch.seen(); drop(above); @@ -14100,9 +14271,9 @@ mod tests { let seen = watch.seen(); // A local broadcast attaching at the exact path does; one beside it does not. - let _beside = producer.create_broadcast("room/b").unwrap(); + let _beside = producer.route("room/b", RouteOptions::hidden()).unwrap(); assert!(watch.poll_changed(&waiter, seen).is_pending()); - let _here = producer.create_broadcast("room/a").unwrap(); + let _here = producer.route("room/a", RouteOptions::hidden()).unwrap(); assert!(watch.poll_changed(&waiter, seen).is_ready()); // Dropping the watch takes it out of the table. @@ -14124,7 +14295,7 @@ mod tests { ..Default::default() }); let consumer = producer.consume(); - let _served = producer.requests_route("room", Route::default(), None).unwrap(); + let _served = producer.forward("room", RouteInfo::default(), None).unwrap(); // A consumer outlives its producer by design, so the task set can refuse // submissions while the origin is still open. The front's task is then // dropped on the spot, taking its `Watch` with it: the request must not @@ -14137,15 +14308,15 @@ mod tests { async fn published_names_refuse_navigation_segments() { let producer = origin(1).produce(); for path in ["room/./cam", "room/../cam", ".", ".."] { - assert!(producer.create_broadcast(path).is_err(), "created {path}"); - assert!(producer.announce(path, Route::default()).is_err(), "announced {path}"); + assert!(producer.route(path, RouteOptions::hidden()).is_err(), "created {path}"); + assert!(producer.announce(path, RouteInfo::default()).is_err(), "announced {path}"); } let scoped = producer .scope("room/..", &Patterns::from_iter([Pattern::all()])) .unwrap(); - assert!(scoped.create_broadcast("cam").is_err()); + assert!(scoped.route("cam", RouteOptions::hidden()).is_err()); for path in ["room/.pro/cam", "room/a..b", "room/cam"] { - producer.create_broadcast(path).unwrap(); + producer.route(path, RouteOptions::hidden()).unwrap(); } } @@ -14157,11 +14328,11 @@ mod tests { // never be built: refuse the broadcast instead of publishing one that // announces nowhere. assert!(matches!( - producer.create_broadcast("room/*"), + producer.route("room/*", RouteOptions::hidden()), Err(Error::InvalidPath(_)) )); assert!(matches!( - producer.announce("room/**", Route::default()), + producer.announce("room/**", RouteInfo::default()), Err(Error::InvalidPath(_)) )); } @@ -14198,9 +14369,9 @@ mod tests { assert_eq!(rooted.allowed(), scopes(&[""])); // Publishing through the nested view lands where the root says. - let broadcast = nested.create_broadcast("room/chat/live").unwrap(); + let broadcast = nested.route("room/chat/live", RouteOptions::hidden()).unwrap(); assert!(producer.consume().get_broadcast("room/chat/live").is_some()); - broadcast.close(); + broadcast.broadcast().close(); } #[kio::test] @@ -14224,9 +14395,9 @@ mod tests { Err(Error::Unauthorized) )); - let broadcast = exact.create_broadcast("room/alice").unwrap(); + let broadcast = exact.route("room/alice", RouteOptions::hidden()).unwrap(); assert!(matches!( - exact.create_broadcast("room/alice/cam"), + exact.route("room/alice/cam", RouteOptions::hidden()), Err(Error::Unauthorized) )); assert!(producer.consume().get_broadcast("room/alice").is_some()); @@ -14243,8 +14414,8 @@ mod tests { let mut listed = consumer.announced(); let mut announced = consumer.covering().announced(); - let alice = producer.create_broadcast("room/alice/chat").unwrap(); - alice.announce(Route::default()).unwrap(); + let alice = producer.route("room/alice/chat", RouteOptions::hidden()).unwrap(); + alice.announce().unwrap(); let Some(AnnounceEvent::Start(update)) = announced.try_next() else { panic!("expected alice's chat"); }; @@ -14252,11 +14423,11 @@ mod tests { assert_eq!(update.captures, Some(vec!["alice".parse::().unwrap()])); listed.expect_next_active("room/alice/chat").await; - let audio = producer.create_broadcast("room/alice/audio").unwrap(); - audio.announce(Route::default()).unwrap(); + let audio = producer.route("room/alice/audio", RouteOptions::hidden()).unwrap(); + audio.announce().unwrap(); announced.assert_next_wait(); - let broad = producer.announce("room", Route::default()).unwrap(); + let broad = producer.announce("room", RouteInfo::default()).unwrap(); let Some(AnnounceEvent::Start(update)) = announced.try_next() else { panic!("expected the overlapping broad route"); }; @@ -14277,9 +14448,9 @@ mod tests { .map(|p| p.parse::().unwrap()) .collect(); let consumer = producer.consume().scope("project", &patterns).unwrap(); - let cam = producer.announce("project/cam.hang", Route::default()).unwrap(); - let overlap = producer.announce("project/room/mic.hang", Route::default()).unwrap(); - let chat = producer.announce("project/lobby.chat", Route::default()).unwrap(); + let cam = producer.announce("project/cam.hang", RouteInfo::default()).unwrap(); + let overlap = producer.announce("project/room/mic.hang", RouteInfo::default()).unwrap(); + let chat = producer.announce("project/lobby.chat", RouteInfo::default()).unwrap(); let mut routing = consumer.clone().covering().announced(); routing.expect_next_active("cam.hang").await; routing.expect_next_active("lobby.chat").await; @@ -14289,9 +14460,9 @@ mod tests { selected.expect_next_active("lobby.chat").await; selected.assert_next_wait(); - let nested = producer.announce("project/room/lobby.chat", Route::default()).unwrap(); + let nested = producer.announce("project/room/lobby.chat", RouteInfo::default()).unwrap(); selected.expect_next_active("room/lobby.chat").await; - overlap.update(Route::default().with_cost(2)).unwrap(); + overlap.update(RouteInfo::default().with_cost(2)).unwrap(); drop(overlap); selected.assert_next_wait(); drop(nested); @@ -14307,29 +14478,29 @@ mod tests { .consume() .scope("room/alice", &Patterns::from(Pattern::all())) .unwrap(); - let broad = producer.announce("room", Route::default()).unwrap(); + let broad = producer.announce("room", RouteInfo::default()).unwrap(); let mut selected = consumer.announced(); selected.assert_next_wait(); let first_instance = crate::Instance::random(); let exact = producer - .announce("room/alice", Route::default().with_instance(first_instance.clone(), 0)) + .announce("room/alice", RouteInfo::default().with_instance(first_instance.clone(), 0)) .unwrap(); assert!( matches!(selected.expect_next().await, AnnounceEvent::Start(a) if a.prefix.is_empty() && a.captures.is_some()) ); exact - .update(Route::default().with_instance(first_instance, 0).with_cost(2)) + .update(RouteInfo::default().with_instance(first_instance, 0).with_cost(2)) .unwrap(); assert!(matches!(selected.expect_next().await, AnnounceEvent::Update(a) if a.route.cost == Cost::new(2))); exact - .update(Route::default().with_instance(crate::Instance::random(), 0)) + .update(RouteInfo::default().with_instance(crate::Instance::random(), 0)) .unwrap(); assert!(matches!(selected.expect_next().await, AnnounceEvent::Restart(_))); drop(exact); selected.expect_next_ended("").await; selected.assert_next_wait(); - let _again = producer.announce("room/alice", Route::default()).unwrap(); + let _again = producer.announce("room/alice", RouteInfo::default()).unwrap(); assert!(matches!(selected.expect_next().await, AnnounceEvent::Start(_))); drop(broad); selected.assert_next_wait(); @@ -14342,13 +14513,13 @@ mod tests { #[kio::test] async fn announced_matches_mounted_names_and_keeps_exclusions() { let producer = origin(1).produce(); - let _broad = producer.announce(".svc", Route::default()).unwrap(); - let _overlap = producer.announce(".svc/p1/mic.hang", Route::default()).unwrap(); + let _broad = producer.announce(".svc", RouteInfo::default()).unwrap(); + let _overlap = producer.announce(".svc/p1/mic.hang", RouteInfo::default()).unwrap(); let _hidden = producer - .announce(".svc/p1/.private/lobby.chat", Route::default()) + .announce(".svc/p1/.private/lobby.chat", RouteInfo::default()) .unwrap(); let _excluded = producer - .announce(".svc/p1/private/lobby.chat", Route::default()) + .announce(".svc/p1/private/lobby.chat", RouteInfo::default()) .unwrap(); let project = mounted(&producer, "p1", &["**/*.chat"]) .with_hidden(true) @@ -14363,7 +14534,7 @@ mod tests { .announced(); inside.expect_next_active(".private/lobby.chat").await; inside.assert_next_wait(); - let live = producer.announce(".svc/p1/lobby.chat", Route::default()).unwrap(); + let live = producer.announce(".svc/p1/lobby.chat", RouteInfo::default()).unwrap(); selected.expect_next_active(".svc/lobby.chat").await; inside.expect_next_active("lobby.chat").await; drop(live); @@ -14376,8 +14547,8 @@ mod tests { async fn announced_requests_covering_routes_and_preserves_shared_fronts_and_stats() { let registry = stats::Registry::new(stats::Config::new()); let producer = origin(1).produce(); - let local = producer.publish("project/cam.chat", Route::default()).unwrap(); - let overlap = producer.announce("project/room", Route::default()).unwrap(); + let local = producer.route("project/cam.chat", RouteOptions::default()).unwrap(); + let overlap = producer.announce("project/room", RouteInfo::default()).unwrap(); let consumer = producer .consume() .scope("project", &Patterns::from("**/*.chat".parse::().unwrap())) @@ -14402,7 +14573,7 @@ mod tests { resolved.is_clone(&original), "the view shares the origin's existing front" ); - let track = local.create_track("video", crate::track::Info::timed()).unwrap(); + let track = local.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let mut written = track.append_group().unwrap(); written.write_frame(crate::Timestamp::ZERO, b"frame".as_ref()).unwrap(); written.finish().unwrap(); @@ -14425,19 +14596,19 @@ mod tests { assert!(routes.next().await.is_some()); drop(routes); drop(overlap); - let source = producer.requests("project/room").unwrap(); + let source = producer.route_prefix("project/room", RouteOptions::default()).unwrap(); let pending = consumer.request("room/lobby.chat", None); - let request = source.requested_broadcast().await.unwrap(); - request.serve(local.consume()); + let request = source.requested().await.unwrap(); + request.serve(local.broadcast().consume()); pending.await.unwrap(); } #[kio::test] async fn local_broadcast_wins_announcement_ties() { let producer = origin(1).produce(); - let remote = producer.announce("room/alice", Route::default().with_cost(9)).unwrap(); - let local = producer.create_broadcast("room/alice").unwrap(); - local.announce(Route::default()).unwrap(); + let remote = producer.announce("room/alice", RouteInfo::default().with_cost(9)).unwrap(); + let local = producer.route("room/alice", RouteOptions::hidden()).unwrap(); + local.announce().unwrap(); let mut announced = producer.consume().announced(); let Some(AnnounceEvent::Start(update)) = announced.try_next() else { @@ -14482,8 +14653,8 @@ mod tests { async fn stalled_publisher_open_group_is_reclaimed() { let expiry = Duration::from_secs(1); let origin = expiring_origin(expiry); - let broadcast = origin.create_broadcast("test").unwrap(); - let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); + let broadcast = origin.route("test", RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let mut stalled = track.append_group().unwrap(); stalled.write_frame(crate::Timestamp::ZERO, b"x".as_slice()).unwrap(); @@ -14515,8 +14686,8 @@ mod tests { ..Config::default() } .produce(); - let broadcast = origin.create_broadcast("test").unwrap(); - let track = broadcast.create_track("video", crate::track::Info::timed()).unwrap(); + let broadcast = origin.route("test", RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let mut stalled = track.append_group().unwrap(); stalled.write_frame(crate::Timestamp::ZERO, b"x".as_slice()).unwrap(); diff --git a/rs/moq-net/src/model/resume_model.rs b/rs/moq-net/src/model/resume_model.rs index ae543920738..bdab5e3e56d 100644 --- a/rs/moq-net/src/model/resume_model.rs +++ b/rs/moq-net/src/model/resume_model.rs @@ -19,7 +19,7 @@ use std::time::Duration; use proptest::prelude::*; use proptest::test_runner::{Config, RngSeed, TestCaseError, TestRunner}; -use super::origin::{Producer, Route}; +use super::origin::{Producer, RouteInfo}; use crate::{Error, Hop, Hops, Instance, SessionError, StreamError, Timestamp, broadcast, group, origin, track}; /// Groups in the logical track; group `g` has `1 + g % 3` frames. @@ -448,12 +448,12 @@ impl Model { let mut hops = Hops::new(); hops.push(Hop::new(10 * (instance as u64 + 1) + slot as u64).unwrap()) .unwrap(); - let route = Route::default() + let route = RouteInfo::default() .with_instance(self::instance(instance), 0) .with_hops(hops) // The second instance's routes all undercut the first's. .with_cost(((INSTANCES - instance) * SLOTS - slot) as u64); - let requests = self.origin.requests_route(PATH, route, None).unwrap(); + let requests = self.origin.forward(PATH, route, None).unwrap(); let broadcast = broadcast::Info::new().produce(); let track = broadcast.create_track("video", track::Info::timed()).unwrap(); let upstream = broadcast.consume(); diff --git a/rs/moq-net/src/server.rs b/rs/moq-net/src/server.rs index 9c7dfe52320..4d5cd8e2631 100644 --- a/rs/moq-net/src/server.rs +++ b/rs/moq-net/src/server.rs @@ -1541,7 +1541,7 @@ mod tests { let _echoed = origin .announce( "echoed-route", - crate::origin::Route::default() + crate::origin::RouteInfo::default() .with_hops(echoed_hops) .with_via(assigned), ) @@ -1550,7 +1550,7 @@ mod tests { let mut local_hops = crate::Hops::new(); local_hops.push(other).unwrap(); let _local = origin - .announce("local-route", crate::origin::Route::default().with_hops(local_hops)) + .announce("local-route", crate::origin::RouteInfo::default().with_hops(local_hops)) .unwrap(); let (session, driver) = request.ok().await.unwrap(); diff --git a/rs/moq-net/src/util.rs b/rs/moq-net/src/util.rs index 438ce870ef5..7488e390927 100644 --- a/rs/moq-net/src/util.rs +++ b/rs/moq-net/src/util.rs @@ -54,7 +54,7 @@ pub(crate) struct Tasks { } /// A claim on a [`TaskSet`]'s lifetime with no submission queue: what a -/// broadcast published on an origin and an `origin::Requests` hold, so the +/// broadcast published on an origin and an `origin::Route` hold, so the /// driver outlives the producer handles a session was given and dropped. pub(crate) struct Keepalive { _alive: kio::Producer<()>, diff --git a/rs/moq-net/tests/integration/announce_covering_route.rs b/rs/moq-net/tests/integration/announce_covering_route.rs index 9b1db074a8b..8f7480fcf00 100644 --- a/rs/moq-net/tests/integration/announce_covering_route.rs +++ b/rs/moq-net/tests/integration/announce_covering_route.rs @@ -65,13 +65,13 @@ async fn covering(version: Option<&str>) -> Vec { let mut announced = observer.scope(REQUESTED, &everything).unwrap().covering().announced(); let mut log = Vec::new(); - let served = publisher.create_broadcast(SERVED).unwrap(); - served.announce(Default::default()).unwrap(); + let served = publisher.route(SERVED, moq_net::origin::RouteOptions::hidden()).unwrap(); + served.announce().unwrap(); kio::clock::sleep(SETTLE).await; log.push(format!("served: {:?}", drain(&mut announced))); - let below = publisher.create_broadcast(format!("{REQUESTED}/cam")).unwrap(); - below.announce(Default::default()).unwrap(); + let below = publisher.route(format!("{REQUESTED}/cam"), moq_net::origin::RouteOptions::hidden()).unwrap(); + below.announce().unwrap(); kio::clock::sleep(SETTLE).await; log.push(format!("below: {:?}", drain(&mut announced))); @@ -129,9 +129,9 @@ async fn relays_route_a_covering_claim_that_listings_omit() { ] { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let claim = publisher.requests("room").unwrap(); - let listed = publisher.create_broadcast("lobby.chat").unwrap(); - listed.announce(Default::default()).unwrap(); + let claim = publisher.route_prefix("room", moq_net::origin::RouteOptions::default()).unwrap(); + let listed = publisher.route("lobby.chat", moq_net::origin::RouteOptions::hidden()).unwrap(); + listed.announce().unwrap(); let relay = produce_origin(2); let mut options = MockConnectOptions::new(version); @@ -161,7 +161,7 @@ async fn relays_route_a_covering_claim_that_listings_omit() { .unwrap(); let track = broadcast.track("video").unwrap(); let _subscribing = kio::clock::sim::spawn(async move { track.subscribe(None).await.map(drop) }); - let request = kio::clock::timeout(SETTLE, claim.requested_broadcast()) + let request = kio::clock::timeout(SETTLE, claim.requested()) .await .expect("the request crossed both hops") .unwrap(); diff --git a/rs/moq-net/tests/integration/announce_takeover.rs b/rs/moq-net/tests/integration/announce_takeover.rs index bf28bbf2ae3..5a31d4b97a6 100644 --- a/rs/moq-net/tests/integration/announce_takeover.rs +++ b/rs/moq-net/tests/integration/announce_takeover.rs @@ -37,20 +37,20 @@ async fn settle() { /// A worker claiming `claim`, answering each request with an output whose `video` track /// carries the worker's name. struct Worker { - _claim: Rc, - outputs: Rc>>, + _claim: Rc, + outputs: Rc>>, origin: origin::Producer, } impl Worker { fn new(hop: u64, claim: &str, name: &'static str) -> Self { let origin = produce_origin(hop); - let claim = Rc::new(origin.requests(claim).unwrap()); + let claim = Rc::new(origin.route_prefix(claim, moq_net::origin::RouteOptions::default()).unwrap()); let outputs = Rc::new(RefCell::new(Vec::new())); let (handler, served) = (claim.clone(), outputs.clone()); drop(kio::clock::sim::spawn(async move { - while let Ok(request) = handler.requested_broadcast().await { - let prepared = request.prepare().unwrap(); + while let Ok(request) = handler.requested().await { + let prepared = request.route(moq_net::origin::RouteOptions::hidden()).unwrap(); let track = prepared .broadcast() .create_track( @@ -61,7 +61,7 @@ impl Worker { let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, name.as_bytes().to_vec()).unwrap(); group.finish().unwrap(); - served.borrow_mut().push((prepared.publish().unwrap(), track)); + served.borrow_mut().push((prepared.announce().unwrap(), track)); } })); Self { @@ -220,7 +220,7 @@ async fn an_unrequested_publish_is_a_start() { let mut announced = relay.consume().announced(); assert_eq!(drain(&mut announced).await, [("start", "pool".to_string(), None)]); - let _direct = worker.origin.publish("pool/q", origin::Route::default()).unwrap(); + let _direct = worker.origin.route("pool/q", moq_net::origin::RouteOptions::default()).unwrap(); settle().await; assert_eq!(drain(&mut announced).await, [("start", "pool/q".to_string(), None)]); }) diff --git a/rs/moq-net/tests/integration/announce_to_serve.rs b/rs/moq-net/tests/integration/announce_to_serve.rs index 35895427298..d4c1dd8c6ff 100644 --- a/rs/moq-net/tests/integration/announce_to_serve.rs +++ b/rs/moq-net/tests/integration/announce_to_serve.rs @@ -145,8 +145,8 @@ async fn lifecycle(observer: Observer) -> Vec { let mut log = Vec::new(); // Created, not yet announced: nobody can see or reach it. - let broadcast = publisher.create_broadcast(PATH).unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); + let broadcast = publisher.route(PATH, moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); kio::clock::sleep(SETTLE).await; log.push(format!( "created: {:?} {}", @@ -155,7 +155,7 @@ async fn lifecycle(observer: Observer) -> Vec { )); // Announced: listed, and a request resolves. - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); kio::clock::sleep(SETTLE).await; let first = request(&consumer).await; log.push(format!("announced: {:?} {}", drain(&mut announced), outcome(&first))); @@ -173,7 +173,7 @@ async fn lifecycle(observer: Observer) -> Vec { // Unannounced: retracted for everyone. A fresh request is refused rather // than joining the broadcast still draining, which ends, while the track // already in flight carries on to its own end. - broadcast.unannounce(); + broadcast.withdraw(); kio::clock::sleep(SETTLE).await; log.push(format!( "unannounced: {:?} {} closed={}", @@ -190,7 +190,7 @@ async fn lifecycle(observer: Observer) -> Vec { )); // Announced again: listed and servable, through a fresh broadcast. - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); kio::clock::sleep(SETTLE).await; let again = request(&consumer).await; log.push(format!( @@ -201,7 +201,7 @@ async fn lifecycle(observer: Observer) -> Vec { )); let again = again.expect("a reannounced broadcast resolves"); - let audio = broadcast.create_track("audio", timed()).unwrap(); + let audio = broadcast.broadcast().create_track("audio", timed()).unwrap(); let mut reader = read(&again, "audio").await; kio::clock::timeout(SETTLE, crate::support::wanted(audio.demand())) .await diff --git a/rs/moq-net/tests/integration/auth.rs b/rs/moq-net/tests/integration/auth.rs index a5d6b2bb392..0f45eb5269c 100644 --- a/rs/moq-net/tests/integration/auth.rs +++ b/rs/moq-net/tests/integration/auth.rs @@ -143,8 +143,8 @@ async fn moqt_22_renewing_a_cancelled_announce_keeps_the_session() { let mut tokens = serve(pair.requests.take().unwrap(), |_| Some(Grant::all())); let (first, answer) = pair.client.auth().add("first").await.expect("kept for requests"); assert_eq!(answer, auth::Answer::Requests); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); - broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); + let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_auth(first)).unwrap(); let (_, first) = tokens.next().await.expect("the announce's token"); // Ending the grant cancels the announcement. The idle request reads that and the @@ -155,7 +155,7 @@ async fn moqt_22_renewing_a_cancelled_announce_keeps_the_session() { assert_eq!(token, b"first"); kio::clock::sleep(Duration::from_secs(1)).await; let (second, _) = pair.client.auth().add("second").await.expect("kept for requests"); - broadcast.announce(origin::Route::default().with_auth(second)).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_auth(second)).unwrap(); let (token, _second) = tokens.next().await.expect("announced again"); assert_eq!(token, b"second"); assert_eq!(pair.client_transport.close_reason(), None); @@ -174,12 +174,12 @@ async fn moqt_22_a_cancelled_renewal_keeps_the_session() { (token == b"first").then(Grant::all) }); let (first, _) = pair.client.auth().add("first").await.expect("kept for requests"); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); - broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); + let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_auth(first)).unwrap(); let (_, first) = tokens.next().await.expect("the announce's token"); let (second, _) = pair.client.auth().add("second").await.expect("kept for requests"); - broadcast.announce(origin::Route::default().with_auth(second)).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_auth(second)).unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; drop(first); kio::clock::sleep(Duration::from_secs(1)).await; @@ -198,8 +198,8 @@ async fn moqt_22_dropping_the_old_grant_with_its_renewal_keeps_the_announce() { let (mut pair, client_origin, server_origin) = connect_route_auth(MOQT_22).await; let mut requests = pair.requests.take().unwrap(); let (first, _) = pair.client.auth().add("first").await.expect("kept for requests"); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); - broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); + let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_auth(first)).unwrap(); let first = requests .next() .await @@ -208,7 +208,7 @@ async fn moqt_22_dropping_the_old_grant_with_its_renewal_keeps_the_announce() { wait_announced(&server_origin.consume(), "room/x", true).await; let (second, _) = pair.client.auth().add("second").await.expect("kept for requests"); - broadcast.announce(origin::Route::default().with_auth(second)).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_auth(second)).unwrap(); let renewal = requests.next().await.expect("the renewal's token"); assert_eq!(renewal.token().as_ref(), b"second"); let second = renewal.accept(Grant::all()); @@ -253,8 +253,8 @@ async fn moqt_22_a_revoked_route_auth_remakes_its_announce() { let (first, _) = pair.client.auth().add("first").await.expect("granted"); let (token, presented) = tokens.next().await.expect("the AUTH stream's token"); assert_eq!(token, b"first"); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); - broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); + let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_auth(first)).unwrap(); let (token, carried) = tokens.next().await.expect("the announce's token"); assert_eq!(token, b"first"); wait_announced(&server_origin.consume(), "room/x", true).await; @@ -313,8 +313,8 @@ async fn a_route_auth_survives_a_reconnect(version: &'static str) { let mut first = connect_route_auth_on(version, &client_origin, &server_origin, Some(handle.clone())).await; let mut tokens = serve(first.requests.take().unwrap(), |_| Some(Grant::all())); let (token, _) = handle.add("first").await.expect("kept for requests"); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); - broadcast.announce(origin::Route::default().with_auth(token)).unwrap(); + let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_auth(token)).unwrap(); let (token, _first) = tokens.next().await.expect("the announce's token"); assert_eq!(token, b"first"); @@ -339,14 +339,14 @@ async fn a_route_auth_renews_its_announce(version: &'static str) { let mut tokens = serve(pair.requests.take().unwrap(), |_| Some(Grant::all())); let (first, _) = pair.client.auth().add("first").await.expect("kept for requests"); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); - broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); + let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_auth(first)).unwrap(); let (token, _first) = tokens.next().await.expect("the announce's token"); assert_eq!(token, b"first"); wait_announced(&server_origin.consume(), "room/x", true).await; let (second, _) = pair.client.auth().add("second").await.expect("kept for requests"); - broadcast.announce(origin::Route::default().with_auth(second)).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_auth(second)).unwrap(); let (token, _second) = tokens.next().await.expect("the renewal's token"); assert_eq!(token, b"second"); wait_announced(&server_origin.consume(), "room/x", true).await; @@ -608,13 +608,13 @@ async fn an_out_of_scope_announce_aborts_with_the_path(version: &'static str) { .await; // In scope: served, and nothing aborts. - let ok = publisher.create_broadcast("baz/ok").unwrap(); - ok.announce(Default::default()).unwrap(); + let ok = publisher.route("baz/ok", moq_net::origin::RouteOptions::hidden()).unwrap(); + ok.announce().unwrap(); wait_announced(&relay.consume(), "baz/ok", true).await; assert_eq!(pair.client_transport.close_reason(), None); - let bad = publisher.create_broadcast("foo/bar").unwrap(); - bad.announce(Default::default()).unwrap(); + let bad = publisher.route("foo/bar", moq_net::origin::RouteOptions::hidden()).unwrap(); + bad.announce().unwrap(); let err = pair.server.closed().await; assert!( matches!(err, Error::Session(SessionError::Unauthorized)), @@ -632,8 +632,8 @@ async fn an_out_of_scope_announce_aborts_with_the_path(version: &'static str) { async fn a_broadcast_published_before_the_grant_is_checked(version: &'static str) { within(async { let publisher = produce_origin(2); - let early = publisher.create_broadcast("foo/bar").unwrap(); - early.announce(Default::default()).unwrap(); + let early = publisher.route("foo/bar", moq_net::origin::RouteOptions::hidden()).unwrap(); + early.announce().unwrap(); let pair = connect(Options { version: Some(version), @@ -674,8 +674,8 @@ async fn an_unanswered_token_holds_the_check(version: &'static str) { let auth = pair.client.auth(); let pending = kio::clock::sim::spawn(async move { auth.add("new").await }); let unanswered = requests.next().await.unwrap(); - let broadcast = publisher.create_broadcast("foo/bar").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("foo/bar", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; use futures::FutureExt; assert!( @@ -685,8 +685,8 @@ async fn an_unanswered_token_holds_the_check(version: &'static str) { let _issued = unanswered.accept(grant(&["foo"], &[])); let _token = pending.await.unwrap().unwrap(); assert_eq!(granted(&pair.client).await, grant(&["baz", "foo"], &[])); - let bad = publisher.create_broadcast("still-bad").unwrap(); - bad.announce(Default::default()).unwrap(); + let bad = publisher.route("still-bad", moq_net::origin::RouteOptions::hidden()).unwrap(); + bad.announce().unwrap(); assert!(matches!( pair.server.closed().await, Error::Session(SessionError::Unauthorized) @@ -716,17 +716,17 @@ async fn a_broadcast_withdrawn_while_its_token_waits_is_not_refused(version: &'s let auth = pair.client.auth(); let pending = kio::clock::sim::spawn(async move { auth.add("new").await }); let unanswered = requests.next().await.unwrap(); - let withdrawn = publisher.create_broadcast("foo/bar").unwrap(); - withdrawn.announce(Default::default()).unwrap(); + let withdrawn = publisher.route("foo/bar", moq_net::origin::RouteOptions::hidden()).unwrap(); + withdrawn.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; - withdrawn.unannounce(); + withdrawn.withdraw(); kio::clock::sleep(Duration::from_secs(1)).await; let _issued = unanswered.accept(grant(&["other"], &[])); let _token = pending.await.unwrap().unwrap(); assert_eq!(granted(&pair.client).await, grant(&["baz", "other"], &[])); // Still enforcing: the next uncovered broadcast is the one named. - let bad = publisher.create_broadcast("still-bad").unwrap(); - bad.announce(Default::default()).unwrap(); + let bad = publisher.route("still-bad", moq_net::origin::RouteOptions::hidden()).unwrap(); + bad.announce().unwrap(); assert!(matches!( pair.server.closed().await, Error::Session(SessionError::Unauthorized) @@ -764,10 +764,10 @@ async fn tokens_union_and_withdrawing_one_shrinks_it(version: &'static str) { assert_eq!(t1.grant().peek(), Some(grant(&["b"], &[]))); assert_eq!(granted(&pair.client).await, grant(&["a", "b"], &[])); - let a = publisher.create_broadcast("a/x").unwrap(); - a.announce(Default::default()).unwrap(); - let b = publisher.create_broadcast("b/y").unwrap(); - b.announce(Default::default()).unwrap(); + let a = publisher.route("a/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + a.announce().unwrap(); + let b = publisher.route("b/y", moq_net::origin::RouteOptions::hidden()).unwrap(); + b.announce().unwrap(); let served = relay.consume(); wait_announced(&served, "a/x", true).await; wait_announced(&served, "b/y", true).await; @@ -832,8 +832,8 @@ async fn a_revoked_grant_withdraws_and_can_be_restored(version: &'static str) { }); let (_, setup) = issued.next().await.unwrap(); - let a = publisher.create_broadcast("a/x").unwrap(); - a.announce(Default::default()).unwrap(); + let a = publisher.route("a/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + a.announce().unwrap(); let served = relay.consume(); wait_announced(&served, "a/x", true).await; @@ -1080,9 +1080,9 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { for scope in ["ch1", "ch1/**"] { within(async { let relay = produce_origin(1); - let broadcast = relay.create_broadcast("ch1").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = relay.route("ch1", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let received = produce_origin(2); let scope = pattern_set(&[scope]); @@ -1121,10 +1121,10 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { /// Connect on `version` and wait for a client announcement to reach the server. Each /// driver presents its setup token before it handles any other stream, so by then a /// version with AUTH has opened its Auth Stream on both sides. -async fn connect_announced(version: &'static str) -> (Pair, moq_net::origin::Publication) { +async fn connect_announced(version: &'static str) -> (Pair, moq_net::origin::Route) { let client_origin = produce_origin(2); - let broadcast = client_origin.create_broadcast("room/x").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let server_origin = produce_origin(1); let pair = connect(Options { version: Some(version), @@ -1140,9 +1140,9 @@ async fn connect_announced(version: &'static str) -> (Pair, moq_net::origin::Pub async fn a_live_subscription_survives_union_renewal(version: &'static str) { within(async { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("room/x").unwrap(); - let published = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + let published = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let received = produce_origin(2); let mut pair = connect(Options { version: Some(version), @@ -1210,14 +1210,14 @@ async fn a_revoked_grant_cancels_its_subscriptions(version: &'static str) { // The server publishes room/x to the client; the client publishes up/y to the server. let server_origin = produce_origin(1); - let down = server_origin.create_broadcast("room/x").unwrap(); - let down_track = down.create_track("video", timed()).unwrap(); - down.announce(Default::default()).unwrap(); + let down = server_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + let down_track = down.broadcast().create_track("video", timed()).unwrap(); + down.announce().unwrap(); let client_origin = produce_origin(2); - let up = client_origin.create_broadcast("up/y").unwrap(); - let up_track = up.create_track("video", timed()).unwrap(); - up.announce(Default::default()).unwrap(); + let up = client_origin.route("up/y", moq_net::origin::RouteOptions::hidden()).unwrap(); + let up_track = up.broadcast().create_track("video", timed()).unwrap(); + up.announce().unwrap(); let received = produce_origin(3); let mut pair = connect(Options { @@ -1438,15 +1438,15 @@ async fn a_wildcard_grant_is_enforced(version: &'static str) { let mut held = Vec::new(); for path in ["room/alice/cam", "b.hang", "deep/x/b.hang"] { - let broadcast = publisher.create_broadcast(path).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route(path, moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); wait_announced(&relay.consume(), path, true).await; held.push(broadcast); } assert_eq!(pair.client_transport.close_reason(), None); - let bad = publisher.create_broadcast("room/alice/mic").unwrap(); - bad.announce(Default::default()).unwrap(); + let bad = publisher.route("room/alice/mic", moq_net::origin::RouteOptions::hidden()).unwrap(); + bad.announce().unwrap(); assert!(matches!( pair.server.closed().await, Error::Session(SessionError::Unauthorized) @@ -1466,8 +1466,8 @@ async fn a_wildcard_grant_is_enforced(version: &'static str) { async fn nothing_outside_the_grant_reaches_the_peer(version: &'static str) { within(async { let publisher = produce_origin(2); - let early = publisher.create_broadcast("foo/bar").unwrap(); - early.announce(Default::default()).unwrap(); + let early = publisher.route("foo/bar", moq_net::origin::RouteOptions::hidden()).unwrap(); + early.announce().unwrap(); // The relay accepts anything; only the grant it tells the client is narrow. let relay = produce_origin(1); @@ -1506,8 +1506,8 @@ async fn a_broadcast_received_from_the_peer_is_not_ours_to_check(version: &'stat within(async { let local = produce_origin(2); let relay = produce_origin(1); - let remote = relay.create_broadcast("remote/x").unwrap(); - remote.announce(Default::default()).unwrap(); + let remote = relay.route("remote/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + remote.announce().unwrap(); let pair = connect(Options { version: Some(version), @@ -1523,8 +1523,8 @@ async fn a_broadcast_received_from_the_peer_is_not_ours_to_check(version: &'stat wait_announced(&local.consume(), "remote/x", true).await; // The first broadcast refused is the one we published, not the one we received. - let bad = local.create_broadcast("bad/x").unwrap(); - bad.announce(Default::default()).unwrap(); + let bad = local.route("bad/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + bad.announce().unwrap(); assert!(matches!( pair.server.closed().await, Error::Session(SessionError::Unauthorized) @@ -1611,12 +1611,12 @@ async fn a_narrowing_deafens_one_path(version: &'static str) { }; let relay = produce_origin(1); - let audio = relay.create_broadcast("room/alice/audio").unwrap(); - let audio_track = audio.create_track("opus", timed()).unwrap(); - audio.announce(Default::default()).unwrap(); - let video = relay.create_broadcast("room/alice/video").unwrap(); - let video_track = video.create_track("h264", timed()).unwrap(); - video.announce(Default::default()).unwrap(); + let audio = relay.route("room/alice/audio", moq_net::origin::RouteOptions::hidden()).unwrap(); + let audio_track = audio.broadcast().create_track("opus", timed()).unwrap(); + audio.announce().unwrap(); + let video = relay.route("room/alice/video", moq_net::origin::RouteOptions::hidden()).unwrap(); + let video_track = video.broadcast().create_track("h264", timed()).unwrap(); + video.announce().unwrap(); let received = produce_origin(3); let pair = connect(Options { @@ -1699,12 +1699,12 @@ async fn a_narrowing_aborts_what_the_peer_published(version: &'static str) { }; let client_origin = produce_origin(2); - let mic = client_origin.create_broadcast("room/bob/mic").unwrap(); - let mic_track = mic.create_track("opus", timed()).unwrap(); - mic.announce(Default::default()).unwrap(); - let cam = client_origin.create_broadcast("room/bob/cam").unwrap(); - let cam_track = cam.create_track("h264", timed()).unwrap(); - cam.announce(Default::default()).unwrap(); + let mic = client_origin.route("room/bob/mic", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mic_track = mic.broadcast().create_track("opus", timed()).unwrap(); + mic.announce().unwrap(); + let cam = client_origin.route("room/bob/cam", moq_net::origin::RouteOptions::hidden()).unwrap(); + let cam_track = cam.broadcast().create_track("h264", timed()).unwrap(); + cam.announce().unwrap(); let relay = produce_origin(1); let pair = connect(Options { @@ -1764,9 +1764,9 @@ async fn a_narrowing_resets_a_fetch_in_flight(version: &'static str) { let ts = |ms| moq_net::Timestamp::from_millis(ms).unwrap(); let relay = produce_origin(1); - let broadcast = relay.create_broadcast("room/x").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = relay.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); // The group stays open, so the fetch is still in flight when the grant narrows. let mut group = track.append_group().unwrap(); group.write_frame(ts(0), b"first".as_ref()).unwrap(); @@ -1836,9 +1836,9 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { }; let relay = produce_origin(1); - let audio = relay.create_broadcast("room/alice/audio").unwrap(); - let audio_track = audio.create_track("opus", timed()).unwrap(); - audio.announce(Default::default()).unwrap(); + let audio = relay.route("room/alice/audio", moq_net::origin::RouteOptions::hidden()).unwrap(); + let audio_track = audio.broadcast().create_track("opus", timed()).unwrap(); + audio.announce().unwrap(); let received = produce_origin(3); let pair = connect(Options { @@ -1908,9 +1908,9 @@ async fn a_widening_brings_back_what_the_peer_published(version: &'static str) { }; let client_origin = produce_origin(2); - let mic = client_origin.create_broadcast("room/bob/mic").unwrap(); - let mic_track = mic.create_track("opus", timed()).unwrap(); - mic.announce(Default::default()).unwrap(); + let mic = client_origin.route("room/bob/mic", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mic_track = mic.broadcast().create_track("opus", timed()).unwrap(); + mic.announce().unwrap(); let relay = produce_origin(1); let pair = connect(Options { diff --git a/rs/moq-net/tests/integration/broadcast_close.rs b/rs/moq-net/tests/integration/broadcast_close.rs index cd65a8ca432..adb82f6fa7e 100644 --- a/rs/moq-net/tests/integration/broadcast_close.rs +++ b/rs/moq-net/tests/integration/broadcast_close.rs @@ -22,9 +22,9 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { /// Close a published broadcast and check what `reader`'s origin answers afterwards. async fn close_then_lookup(publisher: moq_net::origin::Producer, reader: moq_net::origin::Producer) { - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let _track = broadcast.create_track("video", None).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let _track = broadcast.broadcast().create_track("video", None).unwrap(); + broadcast.announce().unwrap(); let consumer = reader.consume(); let handle = kio::clock::timeout(TIMEOUT, consumer.follow("bcast", None).unwrap().available()) @@ -33,7 +33,7 @@ async fn close_then_lookup(publisher: moq_net::origin::Producer, reader: moq_net .expect("broadcast resolves"); handle.track("video").expect("a live broadcast serves its track"); - broadcast.close(); + broadcast.broadcast().close(); kio::clock::timeout(TIMEOUT, handle.closed()) .await @@ -41,7 +41,7 @@ async fn close_then_lookup(publisher: moq_net::origin::Producer, reader: moq_net assert!(matches!(handle.track("video"), Err(Error::Unroutable))); assert!(matches!(handle.track("audio"), Err(Error::Unroutable))); assert!(matches!(consumer.request("bcast", None).await, Err(Error::Unroutable))); - assert!(matches!(broadcast.announce(Default::default()), Err(Error::Closed))); + assert!(matches!(broadcast.announce(), Err(Error::Closed))); } #[kio::test] diff --git a/rs/moq-net/tests/integration/catalog_acquisition.rs b/rs/moq-net/tests/integration/catalog_acquisition.rs index 2f694bb89ed..04451455707 100644 --- a/rs/moq-net/tests/integration/catalog_acquisition.rs +++ b/rs/moq-net/tests/integration/catalog_acquisition.rs @@ -26,10 +26,10 @@ async fn acquisition(version: &str, carries_instance: bool) { let version: Version = version.parse().unwrap(); let publisher = origin(1); let subscriber = origin(2); - let broadcast = publisher.create_broadcast("live").unwrap(); - let mut dynamic = broadcast.requests(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); broadcast - .announce(origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let _old = link(version, &publisher, &subscriber, 100).await; let remote = subscriber diff --git a/rs/moq-net/tests/integration/catalog_churn.rs b/rs/moq-net/tests/integration/catalog_churn.rs index 6523b31c160..1df092388e9 100644 --- a/rs/moq-net/tests/integration/catalog_churn.rs +++ b/rs/moq-net/tests/integration/catalog_churn.rs @@ -279,11 +279,11 @@ async fn execute(version: Version, ops: &[Op]) -> Result<(), Failure> { let relay_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); - let track = broadcast.create_track("catalog.json", info).unwrap(); + let track = broadcast.broadcast().create_track("catalog.json", info).unwrap(); broadcast - .announce(origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let upstream = vec![ diff --git a/rs/moq-net/tests/integration/catalog_handover.rs b/rs/moq-net/tests/integration/catalog_handover.rs index 25dbf4c2ba3..80b6f979c7c 100644 --- a/rs/moq-net/tests/integration/catalog_handover.rs +++ b/rs/moq-net/tests/integration/catalog_handover.rs @@ -91,7 +91,7 @@ struct Topology { p_to_a: Option, a_to_r: Option, links: Vec, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, _track: track::Producer, /// Every payload written to the open group so far. written: Vec, @@ -104,10 +104,10 @@ impl Topology { let relay_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.create_broadcast("live").unwrap(); - let track = broadcast.create_track("catalog.json", timed()).unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("catalog.json", timed()).unwrap(); broadcast - .announce(origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let group = track.append_group().unwrap(); diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index b1e33fc8a80..fccb5cd9537 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -43,7 +43,7 @@ fn payload(frame: u64) -> Vec { struct Fixture { track: moq_net::track::Producer, subscriber: moq_net::track::Subscriber, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, _hops: Vec, _origins: Vec, } @@ -51,16 +51,16 @@ struct Fixture { /// A track announced by the original publisher, before any relay carries it. struct Published { publisher: moq_net::origin::Producer, - broadcast: moq_net::origin::Publication, + broadcast: moq_net::origin::Route, track: moq_net::track::Producer, } /// Announce one track described by `info`. fn publish(info: moq_net::track::Info) -> Published { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("data", info).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("data", info).unwrap(); + broadcast.announce().unwrap(); Published { publisher, broadcast, @@ -266,9 +266,9 @@ async fn datagrams_meter_the_bytes_on_the_wire() { for &version in &["moq-lite-07-wip", "moq-lite-06"] { kio::clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let mut track = broadcast.create_track("data", compressed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut track = broadcast.broadcast().create_track("data", compressed()).unwrap(); + broadcast.announce().unwrap(); // The relay accepts both hops, so its sessions are the ones metered. let relay = produce_origin(2); @@ -374,8 +374,8 @@ async fn ietf_fetch_keeps_the_stored_form() { for version in ["moq-transport-18", "moq-transport-22"] { kio::clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("data", compressed()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("data", compressed()).unwrap(); let mut group = track.append_group().unwrap(); for index in 0..3 { group @@ -384,7 +384,7 @@ async fn ietf_fetch_keeps_the_stored_form() { } group.finish().unwrap(); track.finish().unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let origin = produce_origin(2); let mut options = MockConnectOptions::new(version.parse().unwrap()); options.server_publish = Some(publisher.consume()); diff --git a/rs/moq-net/tests/integration/control_stats.rs b/rs/moq-net/tests/integration/control_stats.rs index 4ad814fdbd9..90b21310b7a 100644 --- a/rs/moq-net/tests/integration/control_stats.rs +++ b/rs/moq-net/tests/integration/control_stats.rs @@ -29,14 +29,14 @@ async fn control_classes_cross_lite_and_ietf_sessions_without_counting_payload() options.client_publish = Some(publisher.consume()); options.server_subscribe = Some(subscriber.clone()); let _pair = connect_mock(options).await; - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "video", moq_net::track::Info::default().with_timescale(Timescale::MILLI), ) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let remote = subscriber .consume() .follow("room", None) diff --git a/rs/moq-net/tests/integration/datagram.rs b/rs/moq-net/tests/integration/datagram.rs index 0e8087bd623..6e075a8371f 100644 --- a/rs/moq-net/tests/integration/datagram.rs +++ b/rs/moq-net/tests/integration/datagram.rs @@ -34,7 +34,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { struct Fixture { producer: moq_net::track::Producer, subscriber: moq_net::track::Subscriber, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, _pair: MockPair, } @@ -44,9 +44,9 @@ async fn connect_datagram_track() -> Fixture { let publisher = produce_origin(1); let consumer_origin = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let producer = broadcast.create_track("datagrams", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let producer = broadcast.broadcast().create_track("datagrams", timed()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new("moq-lite-07-wip".parse::().unwrap()); options.server_publish = Some(publisher.consume()); @@ -133,9 +133,9 @@ async fn ietf_delivers_datagrams_on(version: &str) { let publisher = produce_origin(1); let consumer_origin = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let mut producer = broadcast.create_track("datagrams", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut producer = broadcast.broadcast().create_track("datagrams", timed()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.server_publish = Some(publisher.consume()); @@ -240,9 +240,9 @@ async fn a_fetched_datagram_is_refused_per_version() { _pairs.push(peer(version.parse().unwrap(), &pair[0], &pair[1]).await); } - let broadcast = nodes[0].create_broadcast("room").unwrap(); - let mut producer = broadcast.create_track("datagrams", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut producer = broadcast.broadcast().create_track("datagrams", timed()).unwrap(); + broadcast.announce().unwrap(); let sequence = producer.append_datagram(Timestamp::ZERO, &b"x"[..]).unwrap(); let consumer = nodes.last().unwrap().consume(); diff --git a/rs/moq-net/tests/integration/dial_split_horizon.rs b/rs/moq-net/tests/integration/dial_split_horizon.rs index d017fcbe397..a15e2fe5c4a 100644 --- a/rs/moq-net/tests/integration/dial_split_horizon.rs +++ b/rs/moq-net/tests/integration/dial_split_horizon.rs @@ -147,9 +147,9 @@ async fn split_horizon(version: &str, [publisher_hop, subscriber_hop]: [Hop; 2]) let to_publisher = dial(version, &dialer, &publisher).await; let to_subscriber = dial(version, &dialer, &subscriber).await; - let broadcast = publisher.create_broadcast("room").unwrap(); - let track = broadcast.create_track("video", None).unwrap(); - broadcast.announce(origin::Route::default()).unwrap(); + let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", None).unwrap(); + broadcast.announce().unwrap(); let publisher_hop = learned_hop(&dialer, "room").await; assert_ne!( diff --git a/rs/moq-net/tests/integration/drained_claim.rs b/rs/moq-net/tests/integration/drained_claim.rs index a3c83e8eef2..720b12dfc3d 100644 --- a/rs/moq-net/tests/integration/drained_claim.rs +++ b/rs/moq-net/tests/integration/drained_claim.rs @@ -46,26 +46,26 @@ async fn settle() { /// A worker claiming `pool`, answering each request with an output whose `video` /// track carries the worker's name. struct Worker { - _claim: Rc, + _claim: Rc, /// Each output with its track, which would end once its publication drops. - outputs: Rc>>, + outputs: Rc>>, origin: origin::Producer, } impl Worker { fn new(hop: u64, name: &'static str) -> Self { let origin = produce_origin(hop); - let claim = Rc::new(origin.requests("pool").unwrap()); + let claim = Rc::new(origin.route_prefix("pool", moq_net::origin::RouteOptions::default()).unwrap()); let outputs = Rc::new(RefCell::new(Vec::new())); let (handler, served) = (claim.clone(), outputs.clone()); drop(kio::clock::sim::spawn(async move { - while let Ok(request) = handler.requested_broadcast().await { - let prepared = request.prepare().unwrap(); + while let Ok(request) = handler.requested().await { + let prepared = request.route(moq_net::origin::RouteOptions::hidden()).unwrap(); let track = prepared.broadcast().create_track("video", timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, name.as_bytes().to_vec()).unwrap(); group.finish().unwrap(); - served.borrow_mut().push((prepared.publish().unwrap(), track)); + served.borrow_mut().push((prepared.announce().unwrap(), track)); } })); Self { @@ -110,7 +110,7 @@ async fn drained_claim(version: &str) { assert_eq!(watch(version, &relay).await, "a", "{version}"); // A closes its output and drains its session, so B wins the path from here on. - a.outputs.borrow().iter().for_each(|(output, _)| output.close()); + a.outputs.borrow().iter().for_each(|(output, _)| output.broadcast().close()); a_link.server.drain().send(Goaway::new()).unwrap(); // Past the linger, which is as long as the cache window, nothing reads the relay's // front for the path. diff --git a/rs/moq-net/tests/integration/empty_group.rs b/rs/moq-net/tests/integration/empty_group.rs index 4fd5e61799f..f85224c173c 100644 --- a/rs/moq-net/tests/integration/empty_group.rs +++ b/rs/moq-net/tests/integration/empty_group.rs @@ -31,9 +31,9 @@ async fn an_empty_group_arrives_empty() { let subscriber = produce_origin(2); let _pair = peer(version.parse::().unwrap(), &publisher, &subscriber).await; - let broadcast = publisher.create_broadcast("room").unwrap(); - let track = broadcast.create_track("data", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("data", timed()).unwrap(); + broadcast.announce().unwrap(); let consumer = subscriber.consume(); let remote = kio::clock::timeout(TIMEOUT, consumer.follow("room", None).unwrap().available()) diff --git a/rs/moq-net/tests/integration/errored_end.rs b/rs/moq-net/tests/integration/errored_end.rs index 1f80e822cc3..13b04e96804 100644 --- a/rs/moq-net/tests/integration/errored_end.rs +++ b/rs/moq-net/tests/integration/errored_end.rs @@ -78,10 +78,10 @@ async fn an_errored_end_keeps_its_history_across_a_hop() { let label = format!("{name} subscribe_first={subscribe_first}"); let version: Version = name.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); - let mut track = broadcast.create_track("video", info).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let mut track = broadcast.broadcast().create_track("video", info).unwrap(); + broadcast.announce().unwrap(); for _ in 0..GROUPS { let mut group = track.append_group().unwrap(); for frame in FRAMES { diff --git a/rs/moq-net/tests/integration/extensions.rs b/rs/moq-net/tests/integration/extensions.rs index a477925cf59..573b61d0bed 100644 --- a/rs/moq-net/tests/integration/extensions.rs +++ b/rs/moq-net/tests/integration/extensions.rs @@ -86,8 +86,8 @@ async fn a_side_that_declines_solicit_takes_unsolicited_announces() { } let pair = connect_mock(options).await; - let broadcast = publisher.create_broadcast("room/cam").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("room/cam", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); kio::clock::sleep(SETTLE).await; assert!(announced(&subscriber, "room/cam"), "{context}: never announced"); diff --git a/rs/moq-net/tests/integration/fastest_reader.rs b/rs/moq-net/tests/integration/fastest_reader.rs index df0dce3b030..ff8948d54fc 100644 --- a/rs/moq-net/tests/integration/fastest_reader.rs +++ b/rs/moq-net/tests/integration/fastest_reader.rs @@ -27,7 +27,7 @@ fn origin(hop: u64) -> origin::Producer { struct Relay { track: track::Producer, subscriber: track::Subscriber, - _broadcast: origin::Publication, + _broadcast: origin::Route, pair: MockPair, _origins: [origin::Producer; 2], } @@ -37,11 +37,11 @@ async fn relay(version: &str) -> Relay { let relay = origin(2); let pair = peer(version.parse::().unwrap(), &publisher, &relay).await; - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track("data", track::Info::default().with_timescale(moq_net::Timescale::MILLI)) + .broadcast().create_track("data", track::Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let remote = kio::clock::timeout(TIMEOUT, relay.consume().follow("live", None).unwrap().available()) .await diff --git a/rs/moq-net/tests/integration/fetch_cancel.rs b/rs/moq-net/tests/integration/fetch_cancel.rs index 24e3d2cfb9b..d8ca375265c 100644 --- a/rs/moq-net/tests/integration/fetch_cancel.rs +++ b/rs/moq-net/tests/integration/fetch_cancel.rs @@ -47,9 +47,9 @@ async fn abandoned_fetch_reaches_the_publisher(version: &str, relays: u64, stage _pairs.push(peer(version, &pair[0], &pair[1]).await); } - let broadcast = nodes[0].create_broadcast("room").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; let consumer = nodes[relays as usize].consume().request("room", None).await.unwrap(); @@ -172,9 +172,9 @@ async fn a_refetch_within_the_linger_stays_on_the_relay(version: &str) { let relay = produce_origin(2); let _pair = peer(version, &publisher, &relay).await; - let broadcast = publisher.create_broadcast("room").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; let consumer = relay.consume().request("room", None).await.unwrap(); diff --git a/rs/moq-net/tests/integration/fetch_from_feed.rs b/rs/moq-net/tests/integration/fetch_from_feed.rs index abfc3f3ab52..3f371ac5335 100644 --- a/rs/moq-net/tests/integration/fetch_from_feed.rs +++ b/rs/moq-net/tests/integration/fetch_from_feed.rs @@ -24,7 +24,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { struct Relay { track: moq_net::track::Producer, remote: moq_net::broadcast::Consumer, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, _pair: support::harness::MockPair, _origins: (moq_net::origin::Producer, moq_net::origin::Producer), } @@ -32,11 +32,11 @@ struct Relay { /// A publisher on `version` with group 0 of an untimed track written, and the relay's view of it. async fn relay(version: &str) -> Relay { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let mut track = broadcast - .create_track("video", moq_net::track::Info::default().with_timescale(None)) + .broadcast().create_track("video", moq_net::track::Info::default().with_timescale(None)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); track.write_frame(None, &b"0"[..]).unwrap(); let client = produce_origin(2); diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index 59399a0d070..7d13130e7d8 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -37,10 +37,10 @@ async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Cons } /// Publish a finished track of three groups, and flag any subscription it ever gets. -fn publish_finished(origin: &moq_net::origin::Producer) -> (moq_net::origin::Publication, Arc) { - let broadcast = origin.create_broadcast("bcast").unwrap(); - let mut track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); +fn publish_finished(origin: &moq_net::origin::Producer) -> (moq_net::origin::Route, Arc) { + let broadcast = origin.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); for sequence in 0..3u64 { let mut group = track.append_group().unwrap(); for frame in 0..2 { @@ -156,9 +156,9 @@ async fn a_subscribe_after_track_status_keeps_timestamps() { for version in ["moq-transport-18", "moq-transport-22"] { kio::clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let client = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); @@ -333,10 +333,10 @@ fn write_group(track: &moq_net::track::Producer, sequence: u64) { fn publish_live( origin: &moq_net::origin::Producer, groups: u64, -) -> (moq_net::origin::Publication, moq_net::track::Producer) { - let broadcast = origin.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); +) -> (moq_net::origin::Route, moq_net::track::Producer) { + let broadcast = origin.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); for sequence in 0..groups { write_group(&track, sequence); } diff --git a/rs/moq-net/tests/integration/fetch_pipeline.rs b/rs/moq-net/tests/integration/fetch_pipeline.rs index 5cb165927ab..14e836ed644 100644 --- a/rs/moq-net/tests/integration/fetch_pipeline.rs +++ b/rs/moq-net/tests/integration/fetch_pipeline.rs @@ -36,7 +36,7 @@ async fn link(version: Version, from: &moq_net::origin::Producer, to: &moq_net:: /// What keeps the publisher and the hops to the reader up. struct Held { _publisher: moq_net::origin::Producer, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, _links: Vec, } @@ -54,9 +54,9 @@ async fn fetch_ahead( ) { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let mut links = Vec::new(); let mut upstream = publisher.clone(); @@ -135,9 +135,9 @@ async fn a_refused_info_fails_the_fetch_sent_with_it() { async fn first_fetch(version: &str, relays: u64, rtt: Duration) -> Duration { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"frame".as_ref()).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-net/tests/integration/finished_broadcast_mock.rs b/rs/moq-net/tests/integration/finished_broadcast_mock.rs index 2c80d58a072..61003b83cd4 100644 --- a/rs/moq-net/tests/integration/finished_broadcast_mock.rs +++ b/rs/moq-net/tests/integration/finished_broadcast_mock.rs @@ -39,9 +39,9 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { /// the subscriber read: the frame payloads and the error it ended with, if any. async fn round(finish_broadcast: bool) -> (Vec>, Option) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new("moq-lite-05".parse::().unwrap()); @@ -92,7 +92,7 @@ async fn round(finish_broadcast: bool) -> (Vec>, Option) track.finish().unwrap(); drop(track); if finish_broadcast { - broadcast.close(); + broadcast.broadcast().close(); } // The session and both origins stay up until the reader is done. diff --git a/rs/moq-net/tests/integration/finite_relay.rs b/rs/moq-net/tests/integration/finite_relay.rs index 2a0cb226c33..2a6129bf4f8 100644 --- a/rs/moq-net/tests/integration/finite_relay.rs +++ b/rs/moq-net/tests/integration/finite_relay.rs @@ -60,9 +60,9 @@ enum Arrival { async fn round(name: &str, arrival: Arrival) -> (Vec, Result<(), moq_net::Error>) { let version: Version = name.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let mut track = broadcast.create_track("tail", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut track = broadcast.broadcast().create_track("tail", timed()).unwrap(); + broadcast.announce().unwrap(); let relay = produce_origin(2); let mut options = MockConnectOptions::new(version); diff --git a/rs/moq-net/tests/integration/goaway.rs b/rs/moq-net/tests/integration/goaway.rs index 4be7c5e2239..b5990b804bd 100644 --- a/rs/moq-net/tests/integration/goaway.rs +++ b/rs/moq-net/tests/integration/goaway.rs @@ -369,11 +369,11 @@ async fn goaway_keeps_new_subscribes(version: Version) { kio::clock::timeout(TEST_TIMEOUT, async { // Server publishes a broadcast with one live track. let pub_origin = produce_origin(Hop::random()); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); - broadcast.announce(moq_net::origin::Route::default()).expect("announce"); - let track = broadcast.create_track("video", timed()).expect("create track"); + let broadcast = pub_origin.route("test", moq_net::origin::RouteOptions::hidden()).expect("create broadcast"); + broadcast.announce().expect("announce"); + let track = broadcast.broadcast().create_track("video", timed()).expect("create track"); // A second track with content ready for the subscribe opened after the GOAWAY. - let audio = broadcast.create_track("audio", timed()).expect("create track"); + let audio = broadcast.broadcast().create_track("audio", timed()).expect("create track"); let mut audio_group = audio.append_group().expect("append group"); audio_group .write_frame(moq_net::Timestamp::ZERO, b"audio".as_ref()) @@ -483,8 +483,8 @@ async fn goaway_keeps_new_subscribes_moq_transport_22() { async fn goaway_drains_routes(version: Version) { kio::clock::timeout(TEST_TIMEOUT, async { let pub_origin = produce_origin(Hop::random()); - let broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); - broadcast.announce(moq_net::origin::Route::default()).expect("announce"); + let broadcast = pub_origin.route("test", moq_net::origin::RouteOptions::hidden()).expect("create broadcast"); + broadcast.announce().expect("announce"); let sub_origin = produce_origin(Hop::random()); diff --git a/rs/moq-net/tests/integration/group_order.rs b/rs/moq-net/tests/integration/group_order.rs index 44ab3e2aa5d..80385ca8b54 100644 --- a/rs/moq-net/tests/integration/group_order.rs +++ b/rs/moq-net/tests/integration/group_order.rs @@ -113,14 +113,14 @@ fn carries_order(version: &str) -> bool { async fn round(version: &str, relay: bool, order: Order) -> Vec { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "ordered", Info::default().with_timescale(Timescale::MILLI).with_max_age(FOREVER), ) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let upstream = match relay { true => Some(connect(version, publisher.consume(), 2).await), @@ -187,14 +187,14 @@ async fn merged_subscribers_keep_their_own_order() { for version in ["moq-lite-07-wip", "moq-transport-18"] { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "ordered", Info::default().with_timescale(Timescale::MILLI).with_max_age(FOREVER), ) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let (upstream, relay) = connect(version, publisher.consume(), 2).await; let (descending_pair, descending_origin) = connect(version, relay.consume(), 3).await; diff --git a/rs/moq-net/tests/integration/history_groups.rs b/rs/moq-net/tests/integration/history_groups.rs index 78c7ac48ab6..0039ea57f6e 100644 --- a/rs/moq-net/tests/integration/history_groups.rs +++ b/rs/moq-net/tests/integration/history_groups.rs @@ -42,14 +42,14 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { async fn round(version: &str, relay: bool, newest_first: bool) -> Vec<(u64, usize)> { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "history", Info::default().with_timescale(Timescale::MILLI).with_max_age(FOREVER), ) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let relay_origin = produce_origin(2); let upstream = match relay { @@ -200,14 +200,14 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { // Older drafts canonicalize group 0 to the live edge instead of replay. let version: Version = "moq-lite-07-wip".parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "history", Info::default().with_timescale(Timescale::MILLI).with_max_age(FOREVER), ) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let relay = produce_origin(2); let mut options = MockConnectOptions::new(version); options.server_publish = Some(publisher.consume()); diff --git a/rs/moq-net/tests/integration/idle_cancel_refetch.rs b/rs/moq-net/tests/integration/idle_cancel_refetch.rs index 7ca37c81c5a..73c3273a670 100644 --- a/rs/moq-net/tests/integration/idle_cancel_refetch.rs +++ b/rs/moq-net/tests/integration/idle_cancel_refetch.rs @@ -21,11 +21,11 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { #[kio::test] async fn a_group_cut_by_an_idle_cancel_is_refetched_whole() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track("audio", moq_net::track::Info::default().with_timescale(None)) + .broadcast().create_track("audio", moq_net::track::Info::default().with_timescale(None)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut g0 = track.create_group(moq_net::group::Info { sequence: 0 }).unwrap(); g0.write_frame(None, &b"0a"[..]).unwrap(); diff --git a/rs/moq-net/tests/integration/idle_session.rs b/rs/moq-net/tests/integration/idle_session.rs index 8f1cf854992..4f1547f7c7a 100644 --- a/rs/moq-net/tests/integration/idle_session.rs +++ b/rs/moq-net/tests/integration/idle_session.rs @@ -95,8 +95,8 @@ async fn busy_viewer_sees_the_estimate_move() { ..STATS }); // Server work for this session: announcing a broadcast to the viewer. - let broadcast = origin.create_broadcast("live").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let moved = kio::clock::timeout(Duration::from_millis(1), probe.changed()).await; assert_eq!( diff --git a/rs/moq-net/tests/integration/instance.rs b/rs/moq-net/tests/integration/instance.rs index d1b3bb6ff7d..212db8a70f8 100644 --- a/rs/moq-net/tests/integration/instance.rs +++ b/rs/moq-net/tests/integration/instance.rs @@ -56,15 +56,15 @@ async fn job_reannounced(version: &str) { let relay = produce_origin(2); let instance: Instance = "job".parse().unwrap(); let job = publisher - .publish("job", origin::Route::default().with_instance(instance.clone(), 0)) + .route("job", moq_net::origin::RouteOptions::default().with_instance(instance.clone(), 0)) .unwrap(); let _session = link(version, &publisher, &relay).await; let mut announced = relay.consume().announced(); let first = started(&mut announced).await; - job.unannounce(); + job.withdraw(); ended(&mut announced).await; - job.announce(origin::Route::default()).unwrap(); + job.announce().unwrap(); let second = started(&mut announced).await; match version.to_string().as_str() { diff --git a/rs/moq-net/tests/integration/late_lower_group.rs b/rs/moq-net/tests/integration/late_lower_group.rs index 34fb1058b88..3e1c8273236 100644 --- a/rs/moq-net/tests/integration/late_lower_group.rs +++ b/rs/moq-net/tests/integration/late_lower_group.rs @@ -83,16 +83,16 @@ async fn read_all(sub: &mut moq_net::track::Subscriber) -> Vec<(u64, usize)> { async fn session(version: &str, relay: bool, start: Option) -> Vec<(u64, usize)> { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "late", Info::default() .with_timescale(moq_net::Timescale::MILLI) .with_max_age(FOREVER), ) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let relay_origin = produce_origin(2); let upstream = match relay { @@ -155,9 +155,9 @@ async fn session(version: &str, relay: bool, start: Option) -> Vec<(u64, us async fn in_process(start: Option) -> Vec<(u64, usize)> { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "late", Info::default() .with_timescale(moq_net::Timescale::MILLI) @@ -208,16 +208,16 @@ async fn an_explicit_floor_receives_a_group_created_below_the_first_served_group async fn merged(version: &str) -> (Vec<(u64, usize)>, Vec<(u64, usize)>) { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "late", Info::default() .with_timescale(moq_net::Timescale::MILLI) .with_max_age(FOREVER), ) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let relay_origin = produce_origin(2); let mut options = MockConnectOptions::new(version); diff --git a/rs/moq-net/tests/integration/lazy_discovery.rs b/rs/moq-net/tests/integration/lazy_discovery.rs index 811f89b2f31..c9680c2c607 100644 --- a/rs/moq-net/tests/integration/lazy_discovery.rs +++ b/rs/moq-net/tests/integration/lazy_discovery.rs @@ -34,7 +34,7 @@ fn produce_origin(hop: u64) -> origin::Producer { struct Lazy { subscriber: origin::Producer, pair: MockPair, - _broadcasts: Vec, + _broadcasts: Vec, } impl Lazy { @@ -47,8 +47,8 @@ impl Lazy { let broadcasts = ["a/x", "b/y"] .into_iter() .map(|path| { - let broadcast = publisher.create_broadcast(path).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route(path, moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); broadcast }) .collect(); @@ -319,8 +319,8 @@ async fn a_relay_link_asks_for_everything() { async fn a_server_asks_for_everything() { for version in VERSIONS { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("a/x").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("a/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let relay = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.client_publish = Some(publisher.consume()); @@ -338,8 +338,8 @@ async fn serving_the_peer_asks_nothing() { for version in VERSIONS { let local = produce_origin(2); let remote = produce_origin(1); - let broadcast = remote.create_broadcast("a/x").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = remote.route("a/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.client_publish = Some(local.consume()); diff --git a/rs/moq-net/tests/integration/mesh_withdraw.rs b/rs/moq-net/tests/integration/mesh_withdraw.rs index 8fdb0c95dae..c80a328cd9d 100644 --- a/rs/moq-net/tests/integration/mesh_withdraw.rs +++ b/rs/moq-net/tests/integration/mesh_withdraw.rs @@ -99,14 +99,14 @@ impl Mesh { /// Publish `count` broadcasts spread over every relay but the watcher, starting /// at relay `offset`, and require the watcher to see each announced. - async fn publish(&mut self, count: usize, offset: usize) -> Vec { + async fn publish(&mut self, count: usize, offset: usize) -> Vec { let relays = self.nodes.len() - 1; let broadcasts = (0..count) .map(|i| { let broadcast = self.nodes[(i + offset) % relays] - .create_broadcast(format!("room/{i}")) + .route(format!("room/{i}"), moq_net::origin::RouteOptions::hidden()) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); broadcast }) .collect(); @@ -226,8 +226,8 @@ async fn partial_mesh_withdraw_retracts_once() { let mut watched: Vec<_> = nodes.iter().map(|node| watch(node.consume().announced())).collect(); for publisher in [5, 13, 22, 26, 32] { - let broadcast = nodes[publisher].create_broadcast(format!("room/{publisher}")).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = nodes[publisher].route(format!("room/{publisher}"), moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); kio::clock::sim::idle().await; for (relay, watched) in watched.iter_mut().enumerate() { let updates = drain(watched); @@ -280,8 +280,8 @@ async fn retracted_relay_ignores_a_stale_path() { } let mut watched: Vec<_> = nodes.iter().map(|node| watch(node.consume().announced())).collect(); - let broadcast = nodes[7].create_broadcast("room/7").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = nodes[7].route("room/7", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); kio::clock::sim::idle().await; for watched in watched.iter_mut() { drain(watched); @@ -362,9 +362,9 @@ impl Cluster { /// Publish `path` from the client and require everyone to see it. Returns /// what the watching client saw. - async fn publish(&mut self, path: &str) -> (moq_net::origin::Publication, Vec) { - let broadcast = self.publisher.create_broadcast(path).unwrap(); - broadcast.announce(Default::default()).unwrap(); + async fn publish(&mut self, path: &str) -> (moq_net::origin::Route, Vec) { + let broadcast = self.publisher.route(path, moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); kio::clock::sim::idle().await; let client = drain(&mut self.client).remove(path).unwrap(); assert_ne!(client.last(), Some(&Kind::End), "client: {client:?}"); @@ -376,7 +376,7 @@ impl Cluster { } /// Close `broadcast` cleanly: what the watching client, then each relay, saw. - async fn close(&mut self, path: &str, broadcast: moq_net::origin::Publication) -> (Vec, Vec>) { + async fn close(&mut self, path: &str, broadcast: moq_net::origin::Route) -> (Vec, Vec>) { drop(broadcast); kio::clock::sim::idle().await; let client = drain(&mut self.client).remove(path).unwrap(); @@ -474,8 +474,8 @@ async fn late_better_path(mesh: &str, client: &str) -> (Vec, Vec) { kio::clock::sim::idle().await; assert!(drain(&mut watcher).is_empty()); - let broadcast = publishing.create_broadcast("room/a").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publishing.route("room/a", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); kio::clock::sim::idle().await; let published = drain(&mut watcher).remove("room/a").unwrap(); drop(broadcast); @@ -713,7 +713,7 @@ async fn hop_limit_bounds_receive_and_send() { let mut sent = watch(sink.consume().announced()); kio::clock::sim::idle().await; let route = |count: u64| { - origin::Route::default().with_hops( + origin::RouteInfo::default().with_hops( moq_net::Hops::try_from((100..100 + count).map(|id| Hop::new(id).unwrap()).collect::>()) .unwrap(), ) @@ -778,7 +778,7 @@ async fn hop_limit_falls_back_to_a_forwardable_route() { kio::clock::sim::idle().await; let route = |first: u64, count: u64, cost: u64| { - origin::Route::default() + origin::RouteInfo::default() .with_hops( moq_net::Hops::try_from( (first..first + count) diff --git a/rs/moq-net/tests/integration/model.rs b/rs/moq-net/tests/integration/model.rs index c4b1050a23e..41e2af15e47 100644 --- a/rs/moq-net/tests/integration/model.rs +++ b/rs/moq-net/tests/integration/model.rs @@ -16,9 +16,9 @@ fn origin_front_serves_media_with_only_explicit_polls() { let waiter = kio::Waiter::noop(); let (origin, mut driver) = origin::Producer::new(origin::Config::new(Hop::new(1).unwrap())); driver.poll(now, &waiter).unwrap(); - let broadcast = origin.create_broadcast("room/live").unwrap(); + let broadcast = origin.route("room/live", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "video", track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) @@ -26,7 +26,7 @@ fn origin_front_serves_media_with_only_explicit_polls() { let mut group = track.create_group(group::Info { sequence: 7 }).unwrap(); group.write_frame(Timestamp::ZERO, b"media").unwrap(); group.finish().unwrap(); - broadcast.announce(origin::Route::default()).unwrap(); + broadcast.announce().unwrap(); // Resolving and subscribing pass through the origin's core front tasks. let mut requesting = origin.consume().request("room/live", None); @@ -44,7 +44,7 @@ fn origin_front_serves_media_with_only_explicit_polls() { // Driver teardown also works without any executor-owned tasks. drop(driver); - assert!(matches!(origin.create_broadcast("after-close"), Err(Error::Closed))); + assert!(matches!(origin.route("after-close", moq_net::origin::RouteOptions::hidden()), Err(Error::Closed))); } #[test] @@ -57,11 +57,11 @@ fn follow_resolves_with_only_explicit_polls() { // 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(); + let broadcast = origin.route("room/live", moq_net::origin::RouteOptions::hidden()).unwrap(); assert!(following.poll_available(&waiter).is_pending()); // Announcing starts the path, so the next poll asks and the driver serves it. - broadcast.announce(origin::Route::default()).unwrap(); + broadcast.announce().unwrap(); assert!(following.poll_available(&waiter).is_pending()); driver.poll(now, &waiter).unwrap(); let resolved = ready(following.poll_available(&waiter)).unwrap(); diff --git a/rs/moq-net/tests/integration/multi_cdn.rs b/rs/moq-net/tests/integration/multi_cdn.rs index f2fa393dd3a..4282557e405 100644 --- a/rs/moq-net/tests/integration/multi_cdn.rs +++ b/rs/moq-net/tests/integration/multi_cdn.rs @@ -144,7 +144,7 @@ struct Topology { cdn_b: origin::Producer, subscriber: origin::Producer, track: track::Producer, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, _pushes: Vec, s_to_a: Option, s_to_b: MockPair, @@ -161,10 +161,10 @@ impl Topology { let cdn_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.create_broadcast("live").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast - .announce(origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let pushes = vec![ diff --git a/rs/moq-net/tests/integration/partial_group.rs b/rs/moq-net/tests/integration/partial_group.rs index db8c6266368..a09264eba82 100644 --- a/rs/moq-net/tests/integration/partial_group.rs +++ b/rs/moq-net/tests/integration/partial_group.rs @@ -34,11 +34,11 @@ async fn round(version: &str) -> Option, moq_net::Error>> { let downstream = produce_origin(2); let _pair = peer(version.parse::().unwrap(), &publisher, &downstream).await; - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track("data", Info::default().with_timescale(Timescale::MILLI)) + .broadcast().create_track("data", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let consumer = downstream.consume(); let remote = kio::clock::timeout(TIMEOUT, consumer.follow("room", None).unwrap().available()) diff --git a/rs/moq-net/tests/integration/quiet_catalog.rs b/rs/moq-net/tests/integration/quiet_catalog.rs index 9855715de07..558d2ef6131 100644 --- a/rs/moq-net/tests/integration/quiet_catalog.rs +++ b/rs/moq-net/tests/integration/quiet_catalog.rs @@ -47,10 +47,10 @@ async fn settle() { } /// Announce `live/catalog.json` holding one finished snapshot group. -fn publish(origin: &origin::Producer) -> (moq_net::origin::Publication, track::Producer) { - let broadcast = origin.create_broadcast("live").unwrap(); - let track = broadcast.create_track("catalog.json", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); +fn publish(origin: &origin::Producer) -> (moq_net::origin::Route, track::Producer) { + let broadcast = origin.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("catalog.json", timed()).unwrap(); + broadcast.announce().unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"snapshot").unwrap(); group.finish().unwrap(); diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index 8f3ead08c41..bd801a51b4f 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -45,14 +45,14 @@ fn millis(ms: u64) -> Timestamp { /// over one session on it. async fn read(version: Option<&str>, range: Range) -> Result, Error> { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "data", Info::default().with_timescale(Timescale::MILLI).with_max_age(FOREVER), ) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); for sequence in 0..5 { let mut group = track.create_group(moq_net::group::Info { sequence }).unwrap(); group.write_frame(millis(sequence * 1000), &b"x"[..]).unwrap(); diff --git a/rs/moq-net/tests/integration/range_read.rs b/rs/moq-net/tests/integration/range_read.rs index b2c8682be50..5d6ba7bd57f 100644 --- a/rs/moq-net/tests/integration/range_read.rs +++ b/rs/moq-net/tests/integration/range_read.rs @@ -63,14 +63,14 @@ async fn fixture( relay: bool, ) -> (moq_net::broadcast::Consumer, moq_net::track::Producer, impl Sized) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let mut track = broadcast - .create_track( + .broadcast().create_track( "video", moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); for sequence in 0..3 { write_group(&mut track, sequence); } diff --git a/rs/moq-net/tests/integration/received_rewind.rs b/rs/moq-net/tests/integration/received_rewind.rs index 4a8002c79b5..1b05ca174bc 100644 --- a/rs/moq-net/tests/integration/received_rewind.rs +++ b/rs/moq-net/tests/integration/received_rewind.rs @@ -53,11 +53,11 @@ async fn relay( timescale: Option, ) -> (Option, Vec) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track("data", Info::default().with_timescale(timescale)) + .broadcast().create_track("data", Info::default().with_timescale(timescale)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let relay_origin = produce_origin(2); let mut options = MockConnectOptions::new(upstream.parse::().unwrap()); @@ -176,9 +176,9 @@ async fn a_timed_track_keeps_its_timestamps_through_a_relay() { /// timestamp. async fn fetch_only(version: &str) -> Vec, moq_net::Error>> { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("data", Info::default()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("data", Info::default()).unwrap(); + broadcast.announce().unwrap(); write_group(&track, 0); write_group(&track, 1); track.finish().unwrap(); diff --git a/rs/moq-net/tests/integration/rejoin.rs b/rs/moq-net/tests/integration/rejoin.rs index 3489d8d98aa..73fcf1f0638 100644 --- a/rs/moq-net/tests/integration/rejoin.rs +++ b/rs/moq-net/tests/integration/rejoin.rs @@ -45,9 +45,9 @@ async fn rejoin_recovers_the_group_reset_on_leave() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.server_publish = Some(publisher.consume()); @@ -139,9 +139,9 @@ async fn rejoin_skips_a_cache_kept_by_another_handle() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.server_publish = Some(publisher.consume()); @@ -197,9 +197,9 @@ async fn rejoin_keeps_the_cache_when_the_backlog_lands_newest_first() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.server_publish = Some(publisher.consume()); @@ -271,9 +271,9 @@ async fn rejoin_mid_group_keeps_the_head_for_later_readers() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); // Left open, as a JSON snapshot group stays open for its deltas. let mut open = track.append_group().unwrap(); open.write_frame(Timestamp::ZERO, b"a0".as_ref()).unwrap(); @@ -343,9 +343,9 @@ async fn rejoin_goes_live_without_the_join_head() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let mut open = track.append_group().unwrap(); open.write_frame(Timestamp::ZERO, b"a0".as_ref()).unwrap(); @@ -412,9 +412,9 @@ async fn rejoin_during_the_cancel_skips_the_cache() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(publisher.consume()); @@ -475,9 +475,9 @@ async fn rejoin_waits_for_the_answers_first_frame() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(publisher.consume()); @@ -547,9 +547,9 @@ async fn leaving_after_the_cache_window_keeps_the_latest_group() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("catalog", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("catalog", timed()).unwrap(); + broadcast.announce().unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"c0".as_ref()).unwrap(); group.finish().unwrap(); @@ -621,9 +621,9 @@ async fn rejoin_keeps_source_timestamps() { let publisher = produce_origin(1); let client = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.server_publish = Some(publisher.consume()); @@ -705,10 +705,10 @@ async fn quiet_catalog_survives_cache_expiry(version: Version, takeover: bool) { kio::clock::timeout(TEST_TIMEOUT + moq_net::cache::DEFAULT_EXPIRY * 5, async { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("catalog", timed()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("catalog", timed()).unwrap(); broadcast - .announce(moq_net::origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(moq_net::origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"catalog".as_ref()).unwrap(); diff --git a/rs/moq-net/tests/integration/relay_upstream_close.rs b/rs/moq-net/tests/integration/relay_upstream_close.rs index 2a31afcf065..55443ce4a48 100644 --- a/rs/moq-net/tests/integration/relay_upstream_close.rs +++ b/rs/moq-net/tests/integration/relay_upstream_close.rs @@ -90,15 +90,15 @@ async fn read(mut sub: moq_net::track::Subscriber) -> Outcome { async fn round(name: &str, end: End) -> Vec { let version: Version = name.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let tracks: Vec<_> = (0..TRACKS) .map(|index| { broadcast - .create_track(format!("track{index}").as_str(), timed()) + .broadcast().create_track(format!("track{index}").as_str(), timed()) .unwrap() }) .collect(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let relay = produce_origin(2); let mut options = MockConnectOptions::new(version); diff --git a/rs/moq-net/tests/integration/replacement.rs b/rs/moq-net/tests/integration/replacement.rs index 601628ee9b7..eaf29e31857 100644 --- a/rs/moq-net/tests/integration/replacement.rs +++ b/rs/moq-net/tests/integration/replacement.rs @@ -82,7 +82,7 @@ async fn replace(version: &str, instance: Option) { let publisher = produce_origin(1); let viewer = produce_origin(3); - let mut route = origin::Route::default(); + let mut route = origin::RouteInfo::default(); route.instance = instance.clone(); let cam = publisher.publish("cam", route).unwrap(); let video = cam.create_track("video", timed()).unwrap(); @@ -190,8 +190,8 @@ async fn route_death(version: &str, relayed: bool, wait: Duration) { let relay = produce_origin(2); let viewer = produce_origin(3); - let cam = publisher.publish("cam", origin::Route::default()).unwrap(); - let video = cam.create_track("video", timed()).unwrap(); + let cam = publisher.route("cam", moq_net::origin::RouteOptions::default()).unwrap(); + let video = cam.broadcast().create_track("video", timed()).unwrap(); let upstream = if relayed { &relay } else { &viewer }; let old_session = link(version, &publisher, upstream).await; @@ -273,8 +273,8 @@ async fn restart_while_the_old_session_lingers(version: &str, old_hop: u64, new_ let viewer = produce_origin(3); let old = produce_origin(old_hop); - let old_cam = old.publish("cam", origin::Route::default()).unwrap(); - let _old_video = old_cam.create_track("video", timed()).unwrap(); + let old_cam = old.route("cam", moq_net::origin::RouteOptions::default()).unwrap(); + let _old_video = old_cam.broadcast().create_track("video", timed()).unwrap(); let old_session = link(version, &old, &viewer).await; let mut announced = viewer.consume().announced(); next_event(&mut announced).await; @@ -284,8 +284,8 @@ async fn restart_while_the_old_session_lingers(version: &str, old_hop: u64, new_ old_session.server_transport.set_latency(Duration::from_secs(3600)); let new = produce_origin(new_hop); - let new_cam = new.publish("cam", origin::Route::default()).unwrap(); - let new_video = new_cam.create_track("video", timed()).unwrap(); + let new_cam = new.route("cam", moq_net::origin::RouteOptions::default()).unwrap(); + let new_video = new_cam.broadcast().create_track("video", timed()).unwrap(); let _new_session = link(version, &new, &viewer).await; kio::clock::sleep(PAST_HOLD).await; diff --git a/rs/moq-net/tests/integration/request_caps.rs b/rs/moq-net/tests/integration/request_caps.rs index 165552593fa..b79026d4e97 100644 --- a/rs/moq-net/tests/integration/request_caps.rs +++ b/rs/moq-net/tests/integration/request_caps.rs @@ -27,7 +27,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { struct Setup { client: moq_net::origin::Producer, _server: moq_net::origin::Producer, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, tracks: Vec, _pair: MockPair, } @@ -37,11 +37,11 @@ async fn setup(version: &str, limits: Limits, tracks: usize) -> Setup { let server = produce_origin(1); let client = produce_origin(2); - let broadcast = server.create_broadcast("bcast").unwrap(); + let broadcast = server.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let tracks = (0..tracks) - .map(|i| broadcast.create_track(format!("t{i}"), None).unwrap()) + .map(|i| broadcast.broadcast().create_track(format!("t{i}"), None).unwrap()) .collect(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(server.consume()); @@ -112,11 +112,11 @@ async fn flow_control_bounds_the_subscriptions_a_peer_holds() { let version: Version = version.parse().unwrap(); let server = produce_origin(1); let client = produce_origin(2); - let broadcast = server.create_broadcast("bcast").unwrap(); + let broadcast = server.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let tracks: Vec<_> = (0..TRACKS) - .map(|i| broadcast.create_track(format!("t{i}"), None).unwrap()) + .map(|i| broadcast.broadcast().create_track(format!("t{i}"), None).unwrap()) .collect(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.transport.max_concurrent_bi_streams = Some(BOUND); @@ -162,10 +162,10 @@ async fn an_announce_past_the_cap_closes_the_session() { let version: Version = version.parse().unwrap(); let client = produce_origin(1); let server = produce_origin(2); - let a = client.create_broadcast("a").unwrap(); - let b = client.create_broadcast("b").unwrap(); - a.announce(Default::default()).unwrap(); - b.announce(Default::default()).unwrap(); + let a = client.route("a", moq_net::origin::RouteOptions::hidden()).unwrap(); + let b = client.route("b", moq_net::origin::RouteOptions::hidden()).unwrap(); + a.announce().unwrap(); + b.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.client_publish = Some(client.consume()); diff --git a/rs/moq-net/tests/integration/route_change.rs b/rs/moq-net/tests/integration/route_change.rs index 62814153772..dc88167c129 100644 --- a/rs/moq-net/tests/integration/route_change.rs +++ b/rs/moq-net/tests/integration/route_change.rs @@ -101,7 +101,7 @@ struct Topology { publisher: origin::Producer, relay_b: origin::Producer, subscriber: origin::Producer, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, track: track::Producer, p_to_a: Option, a_to_r: Option, @@ -118,10 +118,10 @@ impl Topology { let relay_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.create_broadcast("live").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast - .announce(origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let p_to_a = link(version, &publisher, &relay_a).await; @@ -387,10 +387,10 @@ async fn route_dies_across_instances(version: &str, trigger: Trigger) { let relay_b = produce_origin(4); let relay = produce_origin(5); let downstream = produce_origin(6); - let broadcast_a = publisher_a.publish("live", origin::Route::default()).unwrap(); - let broadcast_b = publisher_b.publish("live", origin::Route::default()).unwrap(); - let track_a = broadcast_a.create_track("video", timed()).unwrap(); - let track_b = broadcast_b.create_track("video", timed()).unwrap(); + let broadcast_a = publisher_a.route("live", moq_net::origin::RouteOptions::default()).unwrap(); + let broadcast_b = publisher_b.route("live", moq_net::origin::RouteOptions::default()).unwrap(); + let track_a = broadcast_a.broadcast().create_track("video", timed()).unwrap(); + let track_b = broadcast_b.broadcast().create_track("video", timed()).unwrap(); assert_ne!( broadcast_a.route().unwrap().instance, broadcast_b.route().unwrap().instance @@ -676,10 +676,10 @@ async fn lagging_route_dies(version: Version) { produce_origin(4), produce_origin(5), ); - let broadcast = p.create_broadcast("live").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); + let broadcast = p.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast - .announce(origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let p_a = lagged(version, &p, &a, Duration::from_millis(300)).await; let p_b = lagged(version, &p, &b, Duration::ZERO).await; @@ -765,10 +765,10 @@ async fn undetected_outage(budget: Duration) -> BTreeMap> { produce_origin(4), produce_origin(5), ); - let broadcast = p.create_broadcast("live").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); + let broadcast = p.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast - .announce(origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let p_o = link(version, &p, &o).await; let o_m1 = link(version, &o, &m1).await; @@ -886,7 +886,7 @@ struct Replica { /// Tags its payloads, so the reader shows which replica served each frame. name: &'static str, origin: origin::Producer, - broadcast: moq_net::origin::Publication, + broadcast: moq_net::origin::Route, track: track::Producer, group: Option, link: Option, @@ -902,9 +902,9 @@ async fn redundant_pair_follows_the_next_instance(version: &str, loss: Loss) { let mut replicas = Vec::new(); for (name, hop, cost) in [("P1", 1, 1), ("P2", 2, 5)] { let publisher = produce_origin(hop); - let broadcast = publisher.create_broadcast("live").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(origin::Route::default().with_cost(cost)).unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce(origin::RouteInfo::default().with_cost(cost)).unwrap(); let link = link(version, &publisher, &subscriber).await; replicas.push(Replica { name, @@ -1015,9 +1015,9 @@ async fn replaced_behind_a_relay(version: &str) { let mut replicas = Vec::new(); for (name, hop, cost) in [("P1", 1, None), ("P2", 2, Some(1_000))] { let publisher = produce_origin(hop); - let broadcast = publisher.create_broadcast("live").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(origin::Route::default()).unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let link = priced_link(version, &publisher, &relay, cost).await; replicas.push(Replica { name, @@ -1108,12 +1108,12 @@ async fn compression_changes_behind_a_relay(compress: bool) { let mut replicas = Vec::new(); for (name, hop, cost, compress) in [("P1", 1, None, true), ("P2", 2, Some(1_000), compress)] { let publisher = produce_origin(hop); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track("video", timed().with_compress(compress)) + .broadcast().create_track("video", timed().with_compress(compress)) .unwrap(); broadcast - .announce(origin::Route::default().with_instance(instance.clone(), 0)) + .announce(origin::RouteInfo::default().with_instance(instance.clone(), 0)) .unwrap(); let link = priced_link(version, &publisher, &relay, cost).await; replicas.push(Replica { @@ -1204,10 +1204,10 @@ async fn producer_replaced(version: &str) { let relay = produce_origin(2); let subscriber = produce_origin(3); - let broadcast = publisher.create_broadcast("live").unwrap(); - let mut dynamic = broadcast.requests(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); broadcast - .announce(origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let (tx, mut producers) = mpsc::unbounded(); kio::clock::sim::spawn(async move { diff --git a/rs/moq-net/tests/integration/route_health.rs b/rs/moq-net/tests/integration/route_health.rs index 38c0cb976f7..0cd8f8e365a 100644 --- a/rs/moq-net/tests/integration/route_health.rs +++ b/rs/moq-net/tests/integration/route_health.rs @@ -54,10 +54,10 @@ async fn silent_kill(budget: Duration, detect: Duration) -> Vec { produce_origin(4), produce_origin(5), ); - let broadcast = p.create_broadcast("live").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); + let broadcast = p.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast - .announce(origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let p_o = link(version, &p, &o).await; let o_m1 = link(version, &o, &m1).await; @@ -191,10 +191,10 @@ async fn payload_stall(stall: Stall, span: Duration) -> (Observed, Observed) { produce_origin(5), produce_origin(6), ); - let broadcast = p.create_broadcast("live").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); + let broadcast = p.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast - .announce(origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); let p_o = link(version, &p, &o).await; let o_m1 = link(version, &o, &m1).await; diff --git a/rs/moq-net/tests/integration/segmented_frame.rs b/rs/moq-net/tests/integration/segmented_frame.rs index c87d4c7db06..a0f15880d18 100644 --- a/rs/moq-net/tests/integration/segmented_frame.rs +++ b/rs/moq-net/tests/integration/segmented_frame.rs @@ -30,10 +30,10 @@ async fn a_segmented_frame_crosses_whole() { let version: Version = version.parse().unwrap(); let publisher = origin(1); let viewer = origin(2); - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); - let track = broadcast.create_track("file", info).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let track = broadcast.broadcast().create_track("file", info).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(publisher.consume()); diff --git a/rs/moq-net/tests/integration/session_close.rs b/rs/moq-net/tests/integration/session_close.rs index 21d677f6ef7..ba759b6fb09 100644 --- a/rs/moq-net/tests/integration/session_close.rs +++ b/rs/moq-net/tests/integration/session_close.rs @@ -33,7 +33,7 @@ struct Setup { pair: MockPair, track: moq_net::track::Producer, reader: kio::clock::sim::JoinHandle, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, } async fn setup(version: &str) -> Setup { @@ -42,9 +42,9 @@ async fn setup(version: &str) -> Setup { async fn setup_with_gate(version: &str, gate: Option>) -> Setup { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); @@ -104,9 +104,9 @@ async fn setup_with_gate(version: &str, gate: Option>) -> Se async fn track_info_interest_precedes_a_subscription() { for version in ["moq-lite-05", "moq-lite-06", "moq-lite-07-wip"] { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse().unwrap()); options.server_publish = Some(publisher.consume()); @@ -226,8 +226,8 @@ async fn abort_cuts_a_drain_short_for(version: &str) { async fn close_withdraws_announcements_before_closing_the_transport() { for version in ["moq-lite-01", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse().unwrap()); options.client_publish = Some(publisher.consume()); @@ -247,8 +247,8 @@ async fn close_withdraws_announcements_before_closing_the_transport() { async fn close_times_out_waiting_for_announcement_acknowledgements() { for version in ["moq-lite-01", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse().unwrap()); options.client_publish = Some(publisher.consume()); diff --git a/rs/moq-net/tests/integration/session_idle.rs b/rs/moq-net/tests/integration/session_idle.rs index 542d7bde485..99768f0e44a 100644 --- a/rs/moq-net/tests/integration/session_idle.rs +++ b/rs/moq-net/tests/integration/session_idle.rs @@ -34,14 +34,14 @@ struct Setup { pair: MockPair, track: moq_net::track::Producer, remote: moq_net::broadcast::Consumer, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, } async fn setup(version: &str) -> Setup { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); diff --git a/rs/moq-net/tests/integration/session_panic.rs b/rs/moq-net/tests/integration/session_panic.rs index 9f0f34dbec5..cc12ac8e01b 100644 --- a/rs/moq-net/tests/integration/session_panic.rs +++ b/rs/moq-net/tests/integration/session_panic.rs @@ -34,13 +34,13 @@ struct Publisher { server_driver: kio::clock::sim::JoinHandle, /// The client's origin, which it publishes from. origin: origin::Producer, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, } async fn publish(version: Version, relay: &origin::Producer, hop: u64, name: &str) -> Publisher { let origin = produce_origin(hop); - let broadcast = origin.create_broadcast(name).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = origin.route(name, moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let mut mock = moq_net::transport::memory::Config::default(); mock.protocol = Some(version.alpn().to_string()); @@ -125,8 +125,8 @@ async fn a_panicking_session_leaves_the_others_serving() { .unwrap_or_else(|_| panic!("{version}: the panicked session never closed")); // The other session still serves: a fresh announcement reaches the relay. - let later = healthy.origin.create_broadcast("later").unwrap(); - later.announce(Default::default()).unwrap(); + let later = healthy.origin.route("later", moq_net::origin::RouteOptions::hidden()).unwrap(); + later.announce().unwrap(); until(&mut announced, "later", true).await; crate::support::announced(&relay.consume(), "healthy").await; drop((healthy, broken.client, later)); diff --git a/rs/moq-net/tests/integration/settled_end_survives_abort.rs b/rs/moq-net/tests/integration/settled_end_survives_abort.rs index 8319b7f96c3..9a7e78dff13 100644 --- a/rs/moq-net/tests/integration/settled_end_survives_abort.rs +++ b/rs/moq-net/tests/integration/settled_end_survives_abort.rs @@ -27,8 +27,8 @@ const GROUPS: u64 = 2; /// or in sequence order, and how the read ended. async fn round(abort: bool, ordered: bool) -> (Vec, Option) { let origin = produce_origin(1); - let broadcast = origin.create_broadcast("bcast").unwrap(); - let mut track = broadcast.create_track("video", timed()).unwrap(); + let broadcast = origin.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut track = broadcast.broadcast().create_track("video", timed()).unwrap(); // From the first group with a replay window: a late reader is owed the whole track, // not the live edge. let subscription = moq_net::track::Subscription::default() diff --git a/rs/moq-net/tests/integration/setup_negotiation.rs b/rs/moq-net/tests/integration/setup_negotiation.rs index 48c7fffa682..79b5df79a09 100644 --- a/rs/moq-net/tests/integration/setup_negotiation.rs +++ b/rs/moq-net/tests/integration/setup_negotiation.rs @@ -57,8 +57,8 @@ async fn every_lite_version_negotiates_in_setup() { let version: Version = name.parse().unwrap(); let versions: Versions = vec![version, "moq-lite-02".parse().unwrap()].into(); let (upstream, downstream) = (origin(), origin()); - let broadcast = upstream.create_broadcast("room").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = upstream.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let (client, server) = dial(versions.clone(), versions, &upstream, &downstream).await; let sessions = [client.unwrap(), server.unwrap()]; diff --git a/rs/moq-net/tests/integration/slow_joiner.rs b/rs/moq-net/tests/integration/slow_joiner.rs index f3260ef0b3a..97788bb01d2 100644 --- a/rs/moq-net/tests/integration/slow_joiner.rs +++ b/rs/moq-net/tests/integration/slow_joiner.rs @@ -30,11 +30,11 @@ async fn stalled_read(version: Version, budget: Duration) -> BTreeSet { let publisher = origin(1); let relay = origin(2); let viewer = origin(3); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let source = broadcast - .create_track("audio", track::Info::default().with_timescale(Timescale::MILLI)) + .broadcast().create_track("audio", track::Info::default().with_timescale(Timescale::MILLI)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut upstream = MockConnectOptions::new(version); upstream.client_publish = Some(publisher.consume()); diff --git a/rs/moq-net/tests/integration/source_errors.rs b/rs/moq-net/tests/integration/source_errors.rs index 5aecf07e94d..2a754a54fde 100644 --- a/rs/moq-net/tests/integration/source_errors.rs +++ b/rs/moq-net/tests/integration/source_errors.rs @@ -31,7 +31,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { /// to the relay, with `bcast` resolved at the relay and the far end. struct Relayed { _publisher: moq_net::origin::Producer, - broadcast: moq_net::origin::Publication, + broadcast: moq_net::origin::Route, upstream: MockPair, _downstream: MockPair, relayed: moq_net::broadcast::Consumer, @@ -51,8 +51,8 @@ async fn relayed(version: &str) -> Relayed { let publisher = produce_origin(1); let relay = produce_origin(2); let far = produce_origin(3); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(publisher.consume()); @@ -105,7 +105,7 @@ fn assert_ended(result: Result<(), Error>, expected: StreamError, version: &str) async fn request_in_flight_to_a_dead_upstream_is_unroutable() { for version in VERSIONS { let setup = relayed(version).await; - let _track = setup.broadcast.create_track("catalog", timed()).unwrap(); + let _track = setup.broadcast.broadcast().create_track("catalog", timed()).unwrap(); // The relay's requests never reach the publisher. setup.upstream.client_transport.hold_bidis(); let relayed = kio::clock::sim::spawn(read_to_end(setup.relayed.clone(), "catalog")); @@ -129,7 +129,7 @@ async fn request_in_flight_to_a_dead_upstream_is_unroutable() { async fn track_in_flight_through_a_dead_upstream_is_unroutable() { for version in VERSIONS { let setup = relayed(version).await; - let track = setup.broadcast.create_track("video", timed()).unwrap(); + let track = setup.broadcast.broadcast().create_track("video", timed()).unwrap(); let mut sub = setup.remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"head".as_ref()).unwrap(); @@ -157,7 +157,7 @@ async fn track_in_flight_through_a_dead_upstream_is_unroutable() { async fn withdrawn_broadcast_keeps_the_source_error() { for version in VERSIONS { let setup = relayed(version).await; - let track = setup.broadcast.create_track("video", timed()).unwrap(); + let track = setup.broadcast.broadcast().create_track("video", timed()).unwrap(); let mut sub = setup.remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"head".as_ref()).unwrap(); @@ -167,7 +167,7 @@ async fn withdrawn_broadcast_keeps_the_source_error() { .expect("group timeout") .unwrap() .unwrap(); - setup.broadcast.unannounce(); + setup.broadcast.withdraw(); kio::clock::sleep(Duration::from_secs(1)).await; track.abort(Error::App(7)).unwrap(); let result = kio::clock::timeout(TIMEOUT, async { @@ -185,8 +185,8 @@ async fn withdrawn_broadcast_keeps_the_source_error() { async fn subscribe_after_withdrawal_is_unroutable() { for version in VERSIONS { let setup = relayed(version).await; - let _track = setup.broadcast.create_track("video", timed()).unwrap(); - setup.broadcast.unannounce(); + let _track = setup.broadcast.broadcast().create_track("video", timed()).unwrap(); + setup.broadcast.withdraw(); kio::clock::sleep(Duration::from_secs(1)).await; for broadcast in [setup.relayed.clone(), setup.remote.clone()] { let result = kio::clock::timeout(TIMEOUT, read_to_end(broadcast, "video")) diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index 4e6443fad9f..f997031c2c7 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -20,12 +20,12 @@ async fn one_stream_credit_serves_every_backlogged_group() { let version: Version = version.parse().unwrap(); let publisher = origin(1); let viewer = origin(2); - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); let tracks: Vec<_> = (0..2) - .map(|i| broadcast.create_track(format!("{i}"), info.clone()).unwrap()) + .map(|i| broadcast.broadcast().create_track(format!("{i}"), info.clone()).unwrap()) .collect(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); // Draft 22 keeps its SETUP stream open, so it needs one more for groups. diff --git a/rs/moq-net/tests/integration/subscribe_priority.rs b/rs/moq-net/tests/integration/subscribe_priority.rs index e71b5e77ade..9d0a14c7978 100644 --- a/rs/moq-net/tests/integration/subscribe_priority.rs +++ b/rs/moq-net/tests/integration/subscribe_priority.rs @@ -48,11 +48,11 @@ async fn priority(track: &moq_net::track::Producer, want: i8) -> Result<(), Stri /// publisher sees the priority rise and fall back. async fn follows(version: Version, relay: bool) -> Result<(), String> { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track("video", Info::default().with_timescale(Timescale::MILLI)) + .broadcast().create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let relay_origin = produce_origin(2); let subscriber = produce_origin(3); diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index 119e94be3f2..08636013b44 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -61,11 +61,11 @@ async fn subscribe(remote: &moq_net::broadcast::Consumer, subscription: Subscrip /// one joins. async fn ahead_then_live(version: Option<&str>, relay: bool) -> (Vec, Vec) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) + .broadcast().create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); for sequence in 0..=3 { write_group(&track, sequence); } @@ -74,7 +74,7 @@ async fn ahead_then_live(version: Option<&str>, relay: bool) -> (Vec, Vec broadcast.consume(), + None => broadcast.broadcast().consume(), Some(version) => { let version: Version = version.parse().unwrap(); if relay { @@ -126,11 +126,11 @@ async fn sparse_ranges_reach_the_publisher_on_lite07() { let sparse = [Range::groups(0..1), Range::groups(3..4)]; for version in LITE { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) + .broadcast().create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); @@ -197,7 +197,7 @@ struct RangeFixture { remote: moq_net::broadcast::Consumer, _sessions: Vec, _origins: [moq_net::origin::Producer; 3], - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, } async fn range_fixture(relay: bool) -> RangeFixture { @@ -210,11 +210,11 @@ async fn range_fixture_version(version: &str, relay: bool) -> RangeFixture { async fn range_fixture_history(version: &str, relay: bool, history: u64) -> RangeFixture { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("ranges").unwrap(); + let broadcast = publisher.route("ranges", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) + .broadcast().create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); for sequence in 0..history { let mut group = track.create_group(moq_net::group::Info { sequence }).unwrap(); group @@ -745,11 +745,11 @@ async fn unresolved_time_reader_never_changes_sibling_demand() { async fn a_covered_bounded_subscription_stays_open() { for version in LITE { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) + .broadcast().create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); for sequence in [0, 1, 2, 4, 5] { write_group(&track, sequence); } diff --git a/rs/moq-net/tests/integration/subscribe_tracks.rs b/rs/moq-net/tests/integration/subscribe_tracks.rs index 821c21b6f10..d9745dcc83c 100644 --- a/rs/moq-net/tests/integration/subscribe_tracks.rs +++ b/rs/moq-net/tests/integration/subscribe_tracks.rs @@ -44,14 +44,14 @@ struct Setup { pair: MockPair, track: moq_net::track::Producer, frames: futures::channel::mpsc::UnboundedReceiver>, - _broadcast: moq_net::origin::Publication, + _broadcast: moq_net::origin::Route, } async fn setup(version: Version) -> Setup { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("room").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version); diff --git a/rs/moq-net/tests/integration/subscribe_with_track.rs b/rs/moq-net/tests/integration/subscribe_with_track.rs index 8e1eeea42c5..b323c7e48a6 100644 --- a/rs/moq-net/tests/integration/subscribe_with_track.rs +++ b/rs/moq-net/tests/integration/subscribe_with_track.rs @@ -66,9 +66,9 @@ async fn first_frame(version: &str, relays: usize, arrival: Arrival) -> Duration } let reader = &links.last().unwrap().client_transport; - let broadcast = nodes[0].create_broadcast("room").unwrap(); + let broadcast = nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .create_track( + .broadcast().create_track( "video", moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) @@ -76,7 +76,7 @@ async fn first_frame(version: &str, relays: usize, arrival: Arrival) -> Duration let mut cached = track.append_group().unwrap(); cached.write_frame(Timestamp::ZERO, b"cached".as_ref()).unwrap(); cached.finish().unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let consumer = nodes.last().unwrap().consume(); let remote = consumer.follow("room", None).unwrap().available().await.unwrap(); diff --git a/rs/moq-net/tests/integration/subscriber_max_age.rs b/rs/moq-net/tests/integration/subscriber_max_age.rs index 35b83a339f0..22595847dc8 100644 --- a/rs/moq-net/tests/integration/subscriber_max_age.rs +++ b/rs/moq-net/tests/integration/subscriber_max_age.rs @@ -39,9 +39,9 @@ async fn relay_forwards_the_most_tolerant_subscriber_max_age() { let viewer = origin(3); let _upstream = peer(version, &publisher, &relay).await; let _downstream = peer(version, &relay, &viewer).await; - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let mut source = broadcast - .create_track( + .broadcast().create_track( "catalog", track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) @@ -49,7 +49,7 @@ async fn relay_forwards_the_most_tolerant_subscriber_max_age() { let mut group = source.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"catalog").unwrap(); group.finish().unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let consumer = viewer.consume(); let remote = consumer.follow("live", None).unwrap().available().await.unwrap(); let cache = remote.track("catalog").unwrap(); @@ -105,9 +105,9 @@ async fn relay_forwards_the_smallest_stated_min_delay() { let _upstream = peer(lite07, &publisher, &relay).await; let _modern = peer(lite07, &relay, &modern).await; let _legacy = peer(lite06, &relay, &legacy).await; - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let mut source = broadcast - .create_track( + .broadcast().create_track( "catalog", track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) @@ -115,7 +115,7 @@ async fn relay_forwards_the_smallest_stated_min_delay() { let mut group = source.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"catalog").unwrap(); group.finish().unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let cache = |origin: &origin::Producer| { let origin = origin.clone(); diff --git a/rs/moq-net/tests/integration/subscription_end_integrity.rs b/rs/moq-net/tests/integration/subscription_end_integrity.rs index efc605ff202..64d7f41f124 100644 --- a/rs/moq-net/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-net/tests/integration/subscription_end_integrity.rs @@ -56,9 +56,9 @@ fn expected() -> Vec> { /// payloads and the error it ended with, if any. async fn round(drop_session: bool) -> (Vec>, Option) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new("moq-lite-05".parse::().unwrap()); @@ -213,9 +213,9 @@ enum Kill { /// `recv_group` and that group end with once it drains what arrived. async fn killed(version: &str, kill: Kill) -> (Option, Option) { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); @@ -318,9 +318,9 @@ async fn a_session_close_cancels_the_track_from_either_side() { /// the error the fetch ends with. async fn fetch_killed(version: &str, kill: Kill) -> moq_net::Error { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); diff --git a/rs/moq-net/tests/integration/support/mod.rs b/rs/moq-net/tests/integration/support/mod.rs index 0bd52c80366..2848df14f87 100644 --- a/rs/moq-net/tests/integration/support/mod.rs +++ b/rs/moq-net/tests/integration/support/mod.rs @@ -24,7 +24,7 @@ pub async fn unwanted(mut demand: track::Demand) -> moq_net::Result<()> { /// 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 { +pub async fn announced(consumer: &origin::Consumer, path: &str) -> origin::RouteInfo { let mut announced = consumer.announced(); loop { match announced.next().await.expect("the origin closed") { diff --git a/rs/moq-net/tests/integration/synced.rs b/rs/moq-net/tests/integration/synced.rs index e623627de9c..c2c30b12e2a 100644 --- a/rs/moq-net/tests/integration/synced.rs +++ b/rs/moq-net/tests/integration/synced.rs @@ -48,10 +48,10 @@ async fn read_until_synced(announced: &mut announce::Consumer) -> BTreeSet BTreeSet { let publisher = produce_origin(1); - let a = publisher.create_broadcast("a").unwrap(); - a.announce(Default::default()).unwrap(); - let b = publisher.create_broadcast("b").unwrap(); - b.announce(Default::default()).unwrap(); + let a = publisher.route("a", moq_net::origin::RouteOptions::hidden()).unwrap(); + a.announce().unwrap(); + let b = publisher.route("b", moq_net::origin::RouteOptions::hidden()).unwrap(); + b.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); @@ -94,8 +94,8 @@ async fn a_best_effort_boundary_still_catches_up() { #[kio::test] async fn a_second_session_catches_up() { let publisher = produce_origin(1); - let a = publisher.create_broadcast("a").unwrap(); - a.announce(Default::default()).unwrap(); + let a = publisher.route("a", moq_net::origin::RouteOptions::hidden()).unwrap(); + a.announce().unwrap(); let subscriber = produce_origin(2); let connect = || { @@ -133,8 +133,8 @@ async fn a_cold_relay_syncs_then_forwards_upstream_routes_as_live() { assert!(announced.try_next().is_none()); let upstream = produce_origin(1); - let broadcast = upstream.create_broadcast("room/cam").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = upstream.route("room/cam", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(upstream.consume()); options.client_subscribe = Some(relay.clone()); 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 538a9afa8fc..3cc41ef6ab1 100644 --- a/rs/moq-net/tests/integration/track_abort_over_session.rs +++ b/rs/moq-net/tests/integration/track_abort_over_session.rs @@ -26,9 +26,9 @@ async fn after_abort(version: &str, hops: u32) { let publisher = produce_origin(1); let relay = produce_origin(2); let far = produce_origin(3); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.server_publish = Some(publisher.consume()); options.client_subscribe = Some(relay.clone()); @@ -76,11 +76,11 @@ abort_test!(abort_06_two, "moq-lite-06", 2); /// group. async fn recreate(finish: bool) { let origin = produce_origin(1); - let broadcast = origin.create_broadcast("bench").unwrap(); + let broadcast = origin.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); broadcast - .announce(moq_net::origin::Route::default().with_instance(moq_net::Instance::random(), 0)) + .announce(moq_net::origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) .unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).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(); @@ -89,7 +89,7 @@ async fn recreate(finish: bool) { assert_eq!(group.sequence, 2); group.read_frame().await.unwrap().unwrap(); track.abort(moq_net::Error::Cancel).unwrap(); - let fresh = broadcast.create_track("video", timed()).unwrap(); + let fresh = broadcast.broadcast().create_track("video", timed()).unwrap(); let mut next = fresh.create_group(moq_net::group::Info { sequence: 3 }).unwrap(); next.write_frame(Timestamp::from_millis(1).unwrap(), b"next".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 250c8fa4cf9..b804e944df9 100644 --- a/rs/moq-net/tests/integration/track_info_cancel.rs +++ b/rs/moq-net/tests/integration/track_info_cancel.rs @@ -30,9 +30,9 @@ async fn abandoned_request_reaches_the_publisher(version: &str, relays: u64) { _pairs.push(peer(version, &pair[0], &pair[1]).await); } - let broadcast = nodes[0].create_broadcast("room").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; let consumer = nodes[relays as usize].consume().request("room", None).await.unwrap(); @@ -70,9 +70,9 @@ async fn withdrawn_broadcast_releases_track_info(version: &str, answered: bool, let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); let reader = produce_origin(2); - let broadcast = publisher.create_broadcast("room").unwrap(); - let mut dynamic = broadcast.requests(); - let mut route = origin::Route::default(); + let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + let mut route = origin::RouteInfo::default(); if explicit { route.instance = Some("019a1234-5678-7000-8000-000000000001".parse().unwrap()); } @@ -104,7 +104,7 @@ async fn withdrawn_broadcast_releases_track_info(version: &str, answered: bool, None }; let finished = pair.client_transport.finished_streams(); - broadcast.close(); + broadcast.broadcast().close(); kio::clock::timeout(Duration::from_secs(5), crate::support::unwanted(demand)) .await .unwrap_or_else(|_| panic!("{version}, answered={answered}, explicit={explicit}: TRACK outlived its broadcast")) diff --git a/rs/moq-net/tests/integration/track_stream_demand.rs b/rs/moq-net/tests/integration/track_stream_demand.rs index 4af2c4c0143..045d1aa43d6 100644 --- a/rs/moq-net/tests/integration/track_stream_demand.rs +++ b/rs/moq-net/tests/integration/track_stream_demand.rs @@ -81,9 +81,9 @@ async fn one_used_edge(version: &str, relays: usize, reorder: bool) { } let reader: &MockSession = &links.last().unwrap().client_transport; - let broadcast = nodes[0].create_broadcast("room").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); // Serve every request for the track, keeping what it started. let requests = Rc::new(RefCell::new(Vec::new())); let track_edges = Rc::new(RefCell::new(None)); @@ -175,9 +175,9 @@ async fn bare_handle_is_lazy(version: &str, relays: usize) { links.push(link(version, &pair[0], &pair[1]).await); } - let broadcast = nodes[0].create_broadcast("room").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let requests = Rc::new(RefCell::new(Vec::new())); let served = requests.clone(); let publisher = kio::clock::sim::spawn(async move { diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index d1bb4b2b7d9..23ebc717d78 100644 --- a/rs/moq-net/tests/integration/track_tail.rs +++ b/rs/moq-net/tests/integration/track_tail.rs @@ -72,7 +72,7 @@ struct Pair { track: moq_net::track::Producer, remote: moq_net::broadcast::Consumer, _keep: ( - moq_net::origin::Publication, + moq_net::origin::Route, moq_net::origin::Producer, moq_net::origin::Producer, ), @@ -80,9 +80,9 @@ struct Pair { async fn connect(version: &str) -> Pair { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); diff --git a/rs/moq-net/tests/integration/tracks.rs b/rs/moq-net/tests/integration/tracks.rs index 1f1b34fa060..7b3df076c80 100644 --- a/rs/moq-net/tests/integration/tracks.rs +++ b/rs/moq-net/tests/integration/tracks.rs @@ -64,9 +64,9 @@ async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Cons #[kio::test] async fn a_session_lists_its_peers_tracks() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let a = broadcast.create_track("a", None).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let a = broadcast.broadcast().create_track("a", None).unwrap(); + broadcast.announce().unwrap(); let (subscriber, _pair) = connect(&publisher, 2, lite07()).await; let remote = resolve(&subscriber).await; @@ -78,7 +78,7 @@ async fn a_session_lists_its_peers_tracks() { ); assert_eq!(next(&mut tracks).await, "+a"); - let b = broadcast.create_track("b", None).unwrap(); + let b = broadcast.broadcast().create_track("b", None).unwrap(); assert_eq!(next(&mut tracks).await, "+b"); drop(a); assert_eq!(next(&mut tracks).await, "-a"); @@ -86,7 +86,7 @@ async fn a_session_lists_its_peers_tracks() { drop(b); assert_eq!(next(&mut tracks).await, "~b", "TRACKS_FINISH, not TRACKS_REMOVE"); - broadcast.close(); + broadcast.broadcast().close(); assert_eq!(next(&mut tracks).await, "end"); } @@ -94,15 +94,15 @@ async fn a_session_lists_its_peers_tracks() { #[kio::test] async fn a_listing_carries_track_info() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let info = moq_net::track::Info::default() .with_timescale(moq_net::Timescale::MILLI) .with_max_age(Duration::from_secs(3)) .with_priority(9) .with_refresh(4) .with_compress(true); - let _a = broadcast.create_track("a", info).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let _a = broadcast.broadcast().create_track("a", info).unwrap(); + broadcast.announce().unwrap(); let (subscriber, _pair) = connect(&publisher, 2, lite07()).await; let mut tracks = resolve(&subscriber).await.tracks().unwrap(); @@ -127,15 +127,15 @@ async fn a_listing_carries_track_info() { #[kio::test] async fn a_listed_track_serves_its_cached_group() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + broadcast.announce().unwrap(); let (subscriber, _pair) = connect(&publisher, 2, lite07()).await; let remote = resolve(&subscriber).await; let mut tracks = remote.tracks().unwrap(); assert_eq!(next(&mut tracks).await, "synced"); - let late = broadcast.create_track("late", None).unwrap(); + let late = broadcast.broadcast().create_track("late", None).unwrap(); let mut group = late.append_group().unwrap(); group.write_frame(None, &b"first"[..]).unwrap(); group.finish().unwrap(); @@ -160,9 +160,9 @@ async fn a_listed_track_serves_its_cached_group() { #[kio::test] async fn a_relay_shares_its_upstream_listing() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let a = broadcast.create_track("a", None).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let a = broadcast.broadcast().create_track("a", None).unwrap(); + broadcast.announce().unwrap(); let (relay, _upstream) = connect(&publisher, 2, lite07()).await; let (first, _first) = connect(&relay, 3, lite07()).await; @@ -177,7 +177,7 @@ async fn a_relay_shares_its_upstream_listing() { assert_eq!(next(&mut two).await, "synced"); assert_eq!(next(&mut two).await, "+a"); - let b = broadcast.create_track("b", None).unwrap(); + let b = broadcast.broadcast().create_track("b", None).unwrap(); assert_eq!(next(&mut one).await, "+b"); assert_eq!(next(&mut two).await, "+b"); @@ -194,9 +194,9 @@ async fn a_relay_shares_its_upstream_listing() { #[kio::test] async fn lite06_cannot_list() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let _a = broadcast.create_track("a", None).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let _a = broadcast.broadcast().create_track("a", None).unwrap(); + broadcast.announce().unwrap(); let (subscriber, _pair) = connect(&publisher, 2, "moq-lite-06".parse().unwrap()).await; let mut tracks = resolve(&subscriber).await.tracks().unwrap(); @@ -211,12 +211,12 @@ async fn lite06_cannot_list() { #[kio::test] async fn a_listing_past_the_announces_cap_is_reset() { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); const CAP: usize = 10; let _tracks: Vec<_> = (0..CAP) - .map(|i| broadcast.create_track(format!("t{i}"), None).unwrap()) + .map(|i| broadcast.broadcast().create_track(format!("t{i}"), None).unwrap()) .collect(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut limits = Limits::default(); limits.announces = CAP; diff --git a/rs/moq-net/tests/integration/tracks_ietf.rs b/rs/moq-net/tests/integration/tracks_ietf.rs index 6d437b3f8e8..078a7986bc3 100644 --- a/rs/moq-net/tests/integration/tracks_ietf.rs +++ b/rs/moq-net/tests/integration/tracks_ietf.rs @@ -98,9 +98,9 @@ async fn read(sub: &mut moq_net::track::Subscriber) -> Option<(u64, Vec)> { async fn a_listing_of_our_own_peer_fails_alone() { for version in DRAFTS { let publisher = produce_origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); - let video = broadcast.create_track("video", None).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let video = broadcast.broadcast().create_track("video", None).unwrap(); + broadcast.announce().unwrap(); let (subscriber, pair) = connect(&publisher, version).await; let remote = resolve(&subscriber, "bcast").await; diff --git a/rs/moq-net/tests/integration/unannounce_release.rs b/rs/moq-net/tests/integration/unannounce_release.rs index bd660de8e49..f6298b83cd8 100644 --- a/rs/moq-net/tests/integration/unannounce_release.rs +++ b/rs/moq-net/tests/integration/unannounce_release.rs @@ -24,8 +24,8 @@ async fn release(version: Version) { options.client_subscribe = Some(relay.clone()); let _pair = connect_mock(options).await; - let broadcast = publisher.publish("a/b", moq_net::origin::Route::default()).unwrap(); - let track = broadcast.create_track("t", None).unwrap(); + let broadcast = publisher.route("a/b", moq_net::origin::RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("t", None).unwrap(); let consumer = relay.consume(); let remote = consumer @@ -37,7 +37,7 @@ async fn release(version: Version) { let sub = remote.track("t").unwrap().subscribe(None).await.expect("subscribes"); crate::support::wanted(track.demand()).await.unwrap(); - broadcast.unannounce(); + broadcast.withdraw(); kio::clock::sleep(Duration::from_secs(1)).await; drop(sub); diff --git a/rs/moq-net/tests/integration/untimed.rs b/rs/moq-net/tests/integration/untimed.rs index 4c5e68c8a02..52f39301824 100644 --- a/rs/moq-net/tests/integration/untimed.rs +++ b/rs/moq-net/tests/integration/untimed.rs @@ -110,9 +110,9 @@ async fn next_frame(subscriber: &mut track::Subscriber) -> Option { async fn frame_through(hops: &[&str], info: track::Info) -> (Option, track::Info) { let timestamp = info.timescale.map(|_| millis(7)); let chain = Chain::new(hops).await; - let broadcast = chain.nodes[0].create_broadcast("room").unwrap(); - let mut producer = broadcast.create_track("data", info).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = chain.nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut producer = broadcast.broadcast().create_track("data", info).unwrap(); + broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; let mut subscriber = chain.subscribe("data").await; @@ -176,9 +176,9 @@ async fn a_relay_forwards_an_untimed_track_untimed() { async fn an_explicit_start_holds_on_an_untimed_track() { for version in ["moq-lite-03", "moq-lite-06", "moq-lite-07-wip", "moq-transport-22"] { let chain = Chain::new(&[version]).await; - let broadcast = chain.nodes[0].create_broadcast("room").unwrap(); - let mut producer = broadcast.create_track("data", untimed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = chain.nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut producer = broadcast.broadcast().create_track("data", untimed()).unwrap(); + broadcast.announce().unwrap(); for _ in 0..5 { producer.write_frame(None, &b"untimed"[..]).unwrap(); } @@ -211,9 +211,9 @@ async fn an_explicit_start_holds_on_an_untimed_track() { async fn datagrams_arrive_as_published() { for version in ["moq-lite-05", "moq-lite-07-wip", "moq-transport-22"] { let chain = Chain::new(&[version]).await; - let broadcast = chain.nodes[0].create_broadcast("room").unwrap(); - let mut producer = broadcast.create_track("data", untimed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = chain.nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut producer = broadcast.broadcast().create_track("data", untimed()).unwrap(); + broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; let mut subscriber = chain.subscribe("data").await; @@ -238,9 +238,9 @@ async fn datagrams_arrive_as_published() { async fn a_fetched_untimed_frame_arrives_untimed() { for version in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-18"] { let chain = Chain::new(&[version]).await; - let broadcast = chain.nodes[0].create_broadcast("room").unwrap(); - let mut dynamic = broadcast.requests(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = chain.nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; let consumer = chain.nodes[1].consume().request("room", None).await.unwrap(); diff --git a/rs/moq-net/tests/integration/warm_backfill.rs b/rs/moq-net/tests/integration/warm_backfill.rs index 2c5f2c7251e..b98b107373d 100644 --- a/rs/moq-net/tests/integration/warm_backfill.rs +++ b/rs/moq-net/tests/integration/warm_backfill.rs @@ -65,9 +65,9 @@ async fn a_newcomer_on_a_warm_relay_gets_the_backfill() { let publisher = origin(1); let relay = origin(2); let _link = peer(version.parse::().unwrap(), &publisher, &relay).await; - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let source = broadcast - .create_track("video", Info::default().with_timescale(Timescale::MILLI)) + .broadcast().create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); for sequence in 0..GROUPS { let mut group = source.create_group(moq_net::group::Info { sequence }).unwrap(); @@ -76,7 +76,7 @@ async fn a_newcomer_on_a_warm_relay_gets_the_backfill() { .unwrap(); group.finish().unwrap(); } - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut first = kio::clock::timeout(TIMEOUT, subscribe(&relay)).await.unwrap(); let cold = kio::clock::timeout(TIMEOUT, received(&mut first)).await.unwrap(); @@ -96,9 +96,9 @@ async fn a_refused_transport_backfill_keeps_delivering_live() { let publisher = origin(1); let relay = origin(2); let _link = peer(version.parse::().unwrap(), &publisher, &relay).await; - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let source = broadcast - .create_track("video", Info::default().with_timescale(Timescale::MILLI)) + .broadcast().create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); for sequence in 0..GROUPS { let mut group = source.create_group(sequence.into()).unwrap(); @@ -107,7 +107,7 @@ async fn a_refused_transport_backfill_keeps_delivering_live() { .unwrap(); group.finish().unwrap(); } - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut subscriber = kio::clock::timeout(TIMEOUT, subscribe(&relay)).await.unwrap(); let got = kio::clock::timeout(TIMEOUT, received(&mut subscriber)).await.unwrap(); assert_eq!(got, BTreeSet::from([GROUPS - 1]), "{version}: only the live edge"); diff --git a/rs/moq-net/tests/integration/wide_hop.rs b/rs/moq-net/tests/integration/wide_hop.rs index ed449b3eb19..d4d832f1389 100644 --- a/rs/moq-net/tests/integration/wide_hop.rs +++ b/rs/moq-net/tests/integration/wide_hop.rs @@ -28,10 +28,10 @@ async fn widest_hop_crosses_each_varint_form() { let upstream: Version = "moq-transport-18".parse().unwrap(); let _upstream = peer(upstream, &source, &relay).await; let _downstream = peer(downstream.parse().unwrap(), &relay, &sink).await; - let _route = source.requests("room").unwrap(); + let _route = source.route_prefix("room", moq_net::origin::RouteOptions::default()).unwrap(); kio::clock::sim::idle().await; - let ids = |route: origin::Route| route.hops.iter().map(|hop| hop.id()).collect::>(); + let ids = |route: origin::RouteInfo| route.hops.iter().map(|hop| hop.id()).collect::>(); let at_relay = crate::support::announced(&relay.consume(), "room").await; assert_eq!(ids(at_relay), [u64::MAX], "{downstream}"); let at_sink = crate::support::announced(&sink.consume(), "room").await; diff --git a/rs/moq-net/tests/integration/wide_sequence.rs b/rs/moq-net/tests/integration/wide_sequence.rs index 3dfb14cd918..d752411303b 100644 --- a/rs/moq-net/tests/integration/wide_sequence.rs +++ b/rs/moq-net/tests/integration/wide_sequence.rs @@ -19,10 +19,10 @@ async fn largest_quic_sequence_reaches_the_subscriber() { let publisher = produce_origin(1); let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.create_broadcast("ladder").unwrap(); + let broadcast = publisher.route("ladder", moq_net::origin::RouteOptions::hidden()).unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MICRO); - let track = broadcast.create_track("data", info).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let track = broadcast.broadcast().create_track("data", info).unwrap(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(publisher.consume()); options.client_subscribe = Some(if relayed { relay.clone() } else { client.clone() }); @@ -86,10 +86,10 @@ async fn wide_sequence_fails_only_its_subscription() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let wide = broadcast.create_track("wide", timed()).unwrap(); - let narrow = broadcast.create_track("narrow", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let wide = broadcast.broadcast().create_track("wide", timed()).unwrap(); + let narrow = broadcast.broadcast().create_track("narrow", timed()).unwrap(); + broadcast.announce().unwrap(); let mut group = wide.create_group(moq_net::group::Info { sequence: WIDE }).unwrap(); group.write_frame(Timestamp::ZERO, b"wide".as_ref()).unwrap(); let mut group = narrow.append_group().unwrap(); @@ -146,10 +146,10 @@ async fn a_later_wide_group_fails_only_that_subscription() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.create_broadcast("bench").unwrap(); - let wide = broadcast.create_track("wide", timed()).unwrap(); - let narrow = broadcast.create_track("narrow", timed()).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let wide = broadcast.broadcast().create_track("wide", timed()).unwrap(); + let narrow = broadcast.broadcast().create_track("narrow", timed()).unwrap(); + broadcast.announce().unwrap(); let mut group = wide.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"first".as_ref()).unwrap(); let mut group = narrow.append_group().unwrap(); diff --git a/rs/moq-net/tests/integration/widened_max_age.rs b/rs/moq-net/tests/integration/widened_max_age.rs index 243ac580130..13205aa071d 100644 --- a/rs/moq-net/tests/integration/widened_max_age.rs +++ b/rs/moq-net/tests/integration/widened_max_age.rs @@ -73,11 +73,11 @@ impl Chain { if let Some(relay) = &relay { links.push(peer(version, relay, &viewer).await); } - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let source = broadcast - .create_track("video", Info::default().with_timescale(Timescale::MILLI)) + .broadcast().create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); Self { source, viewer, @@ -299,9 +299,9 @@ async fn wider_newcomers_after_the_first_pull_nothing_upstream() { .tier(moq_net::stats::Tier::new(moq_net::Path::from_static("upstream"))) .session(moq_net::Path::from_static("")); let _upstream = connect_mock(options).await; - let broadcast = publisher.create_broadcast("live").unwrap(); + let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let source = broadcast - .create_track("video", Info::default().with_timescale(Timescale::MILLI)) + .broadcast().create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); for sequence in 0..GROUPS { let mut group = source.create_group(moq_net::group::Info { sequence }).unwrap(); @@ -310,7 +310,7 @@ async fn wider_newcomers_after_the_first_pull_nothing_upstream() { .unwrap(); group.finish().unwrap(); } - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut links = Vec::new(); let mut readers = Vec::new(); diff --git a/rs/moq-net/tests/integration/zero_copy.rs b/rs/moq-net/tests/integration/zero_copy.rs index b8888660444..d3a287b07f5 100644 --- a/rs/moq-net/tests/integration/zero_copy.rs +++ b/rs/moq-net/tests/integration/zero_copy.rs @@ -54,10 +54,10 @@ async fn frames_cross_without_a_copy() { } ); - let broadcast = publisher.create_broadcast("room").unwrap(); + let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); - let track = broadcast.create_track("video", info).unwrap(); - broadcast.announce(Default::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", info).unwrap(); + broadcast.announce().unwrap(); let consumer = subscriber.consume(); let remote = kio::clock::timeout(TIMEOUT, consumer.follow("room", None).unwrap().available()) From b0c6c02e7b4be0fa76235f6d75bd3042a3dbc175 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 20:44:16 -0800 Subject: [PATCH 03/19] wip: migrate moq-net tests and JS to the Route handle --- bench/browser/page/stats.ts | 6 +- bench/browser/page/transport.ts | 2 +- demo/carla/web/src/truck.ts | 12 +- doc/lib/js/net.md | 16 +- js/crypto/README.md | 23 +- js/crypto/src/e2ee/index.ts | 13 +- js/crypto/src/e2ee/transport.test.ts | 12 +- js/crypto/src/sign/broadcast.ts | 21 +- js/crypto/src/sign/index.ts | 6 +- js/crypto/src/sign/sign.test.ts | 7 +- js/hang/src/catalog/consumer.test.ts | 6 +- js/moq-boy/src/game.test.ts | 3 +- js/moq-boy/src/game.ts | 9 +- js/net/MIGRATE.md | 42 + js/net/api/index.api.md | 59 +- js/net/bench/broadcasts.ts | 45 +- js/net/bench/fills.ts | 3 +- js/net/bench/forward.ts | 4 +- js/net/bench/refresh.ts | 5 +- js/net/bench/requests.ts | 29 +- js/net/bench/resume-history.ts | 3 +- js/net/bench/serve-browser-entry.ts | 5 +- js/net/bench/subscribe-drop.ts | 5 +- js/net/examples/publish.ts | 7 +- js/net/src/announced.test-util.ts | 4 +- js/net/src/announced.test.ts | 17 +- js/net/src/announced.ts | 4 +- js/net/src/auth.test.ts | 62 +- js/net/src/broadcast.ts | 22 +- js/net/src/connection/close.test.ts | 5 +- js/net/src/connection/forward.test.ts | 8 +- js/net/src/connection/forward.ts | 21 +- js/net/src/connection/migrate.test.ts | 5 +- js/net/src/connection/pool.test.ts | 9 +- js/net/src/connection/reload.test.ts | 31 +- js/net/src/connection/scope.test.ts | 5 +- js/net/src/consume.test.ts | 30 +- js/net/src/consume.ts | 8 +- js/net/src/fill.test.ts | 3 +- js/net/src/goaway-requests.test.ts | 10 +- js/net/src/group-id.test.ts | 5 +- js/net/src/hop.ts | 59 +- js/net/src/ietf/connection.test.ts | 12 +- js/net/src/ietf/fetch.test.ts | 3 +- js/net/src/ietf/goaway.test.ts | 4 +- js/net/src/ietf/join.test.ts | 3 +- js/net/src/ietf/malformed.test.ts | 5 +- js/net/src/ietf/publisher.test.ts | 131 ++- js/net/src/ietf/publisher.ts | 8 +- js/net/src/ietf/subscriber.ts | 12 +- js/net/src/integration.test.ts | 33 +- js/net/src/internal.ts | 26 +- js/net/src/lite/compression.test.ts | 6 +- js/net/src/lite/connection.test.ts | 35 +- js/net/src/lite/publisher.test.ts | 25 +- js/net/src/lite/publisher.ts | 14 +- js/net/src/lite/refresh.test.ts | 5 +- js/net/src/lite/subscriber.test.ts | 6 +- js/net/src/lite/subscriber.ts | 6 +- js/net/src/lite/track_stream.test.ts | 45 +- js/net/src/lite/tracks.test.ts | 40 +- js/net/src/lite/widened_max_age.test.ts | 3 +- js/net/src/order.test.ts | 20 +- js/net/src/origin-demand.test.ts | 60 +- js/net/src/origin-request.test.ts | 320 +++---- js/net/src/origin.test.ts | 494 ++++++----- js/net/src/origin.ts | 831 +++++++++--------- js/net/src/parked-expiry.test.ts | 10 +- js/net/src/resume.model.test.ts | 4 +- js/net/src/resume.test.ts | 15 +- js/net/src/retention.test.ts | 5 +- js/net/src/subscribe_priority.test.ts | 20 +- js/net/src/tail.test.ts | 5 +- js/net/src/terminal.test.ts | 3 +- js/net/src/untimed.test.ts | 17 +- js/net/src/wire.ts | 45 +- js/publish/src/broadcast.test.ts | 8 +- js/publish/src/broadcast.ts | 20 +- js/watch/src/audio/decoder.test.ts | 2 +- js/watch/src/broadcast.test.ts | 83 +- js/watch/src/contribution.test.ts | 5 +- js/watch/src/echo.ts | 8 +- js/watch/src/player.test.ts | 3 +- js/watch/src/video/decoder.test.ts | 2 +- rs/moq-net-tests/tests/announce_allocs.rs | 22 +- .../tests/integration/hop_limit.rs | 154 ++++ .../tests/integration/ietf_conformance.rs | 2 +- rs/moq-net-tests/tests/integration/main.rs | 1 + rs/moq-net-tests/tests/integration/refresh.rs | 10 +- rs/moq-net-tests/tests/integration/restart.rs | 107 ++- rs/moq-net-tests/tests/integration/serve.rs | 16 +- rs/moq-net/benches/announce.rs | 2 +- rs/moq-net/benches/auth.rs | 44 +- rs/moq-net/benches/memory.rs | 11 +- rs/moq-net/benches/origin.rs | 181 ++-- rs/moq-net/benches/path.rs | 12 +- rs/moq-net/benches/retirement.rs | 14 +- rs/moq-net/benches/session/mod.rs | 14 +- rs/moq-net/benches/stats.rs | 6 +- rs/moq-net/benches/viewers.rs | 11 +- rs/moq-net/src/ietf/publisher.rs | 177 ++-- rs/moq-net/src/ietf/session.rs | 8 +- rs/moq-net/src/ietf/subscriber.rs | 19 +- rs/moq-net/src/lite/ietf.rs | 3 +- rs/moq-net/src/lite/publisher.rs | 43 +- rs/moq-net/src/lite/subscriber.rs | 9 +- rs/moq-net/src/model/follow.rs | 58 +- rs/moq-net/src/model/origin.rs | 553 ++++++++---- rs/moq-net/src/model/resume_model.rs | 2 +- .../integration/announce_covering_route.rs | 16 +- .../tests/integration/announce_takeover.rs | 16 +- rs/moq-net/tests/integration/auth.rs | 118 ++- .../tests/integration/broadcast_close.rs | 4 +- .../tests/integration/catalog_acquisition.rs | 14 +- rs/moq-net/tests/integration/catalog_churn.rs | 8 +- .../tests/integration/catalog_handover.rs | 8 +- rs/moq-net/tests/integration/compress.rs | 12 +- rs/moq-net/tests/integration/control_stats.rs | 7 +- rs/moq-net/tests/integration/datagram.rs | 8 +- .../tests/integration/dial_split_horizon.rs | 4 +- rs/moq-net/tests/integration/drained_claim.rs | 18 +- rs/moq-net/tests/integration/empty_group.rs | 4 +- rs/moq-net/tests/integration/errored_end.rs | 4 +- rs/moq-net/tests/integration/extensions.rs | 4 +- .../tests/integration/fastest_reader.rs | 7 +- rs/moq-net/tests/integration/fetch_cancel.rs | 4 +- rs/moq-net/tests/integration/fetch_fanout.rs | 3 +- .../tests/integration/fetch_from_feed.rs | 7 +- rs/moq-net/tests/integration/fetch_only.rs | 9 +- .../tests/integration/fetch_pipeline.rs | 8 +- .../integration/finished_broadcast_mock.rs | 4 +- rs/moq-net/tests/integration/finite_relay.rs | 4 +- rs/moq-net/tests/integration/goaway.rs | 22 +- rs/moq-net/tests/integration/group_order.rs | 14 +- .../tests/integration/history_groups.rs | 14 +- .../tests/integration/idle_cancel_refetch.rs | 7 +- rs/moq-net/tests/integration/instance.rs | 7 +- .../tests/integration/late_lower_group.rs | 21 +- rs/moq-net/tests/integration/mesh_withdraw.rs | 190 +--- rs/moq-net/tests/integration/model.rs | 16 +- rs/moq-net/tests/integration/multi_cdn.rs | 10 +- rs/moq-net/tests/integration/partial_group.rs | 7 +- rs/moq-net/tests/integration/range_anchors.rs | 7 +- rs/moq-net/tests/integration/range_read.rs | 7 +- .../tests/integration/received_rewind.rs | 11 +- rs/moq-net/tests/integration/rejoin.rs | 44 +- .../tests/integration/relay_upstream_close.rs | 7 +- rs/moq-net/tests/integration/replacement.rs | 22 +- rs/moq-net/tests/integration/route_change.rs | 67 +- rs/moq-net/tests/integration/route_health.rs | 8 +- .../tests/integration/segmented_frame.rs | 4 +- rs/moq-net/tests/integration/session_close.rs | 16 +- rs/moq-net/tests/integration/session_idle.rs | 4 +- rs/moq-net/tests/integration/session_panic.rs | 5 +- rs/moq-net/tests/integration/slow_joiner.rs | 7 +- rs/moq-net/tests/integration/source_errors.rs | 4 +- rs/moq-net/tests/integration/stream_credit.rs | 11 +- .../tests/integration/subscribe_priority.rs | 7 +- .../tests/integration/subscribe_ranges.rs | 28 +- .../tests/integration/subscribe_tracks.rs | 4 +- .../tests/integration/subscribe_with_track.rs | 3 +- .../tests/integration/subscriber_max_age.rs | 14 +- .../integration/subscription_end_integrity.rs | 12 +- rs/moq-net/tests/integration/support/mod.rs | 46 + rs/moq-net/tests/integration/synced.rs | 4 +- .../integration/track_abort_over_session.rs | 8 +- .../tests/integration/track_info_cancel.rs | 10 +- rs/moq-net/tests/integration/track_tail.rs | 4 +- rs/moq-net/tests/integration/tracks.rs | 24 +- rs/moq-net/tests/integration/tracks_ietf.rs | 4 +- .../tests/integration/unannounce_release.rs | 4 +- rs/moq-net/tests/integration/untimed.rs | 16 +- rs/moq-net/tests/integration/warm_backfill.rs | 14 +- rs/moq-net/tests/integration/wide_hop.rs | 6 +- rs/moq-net/tests/integration/wide_sequence.rs | 12 +- .../tests/integration/widened_max_age.rs | 14 +- rs/moq-net/tests/integration/zero_copy.rs | 4 +- .../clients/js/src/capture.test.ts | 18 +- test/drain/drain.ts | 6 +- test/interop/clients/js-native/hls.ts | 2 +- test/interop/clients/js-native/server.ts | 12 +- test/interop/clients/js-native/tail.ts | 6 +- test/interop/clients/js/src/finish.ts | 12 +- test/interop/compat/client.ts | 10 +- test/interop/ietf-range-updates.ts | 2 +- test/interop/sign.ts | 2 +- test/interop/track-status.ts | 5 +- test/interop/tracks.ts | 5 +- test/max-age/client.ts | 6 +- test/p2p/src/main.ts | 5 +- test/receive-credit/sender.ts | 6 +- test/video/src/captions.ts | 6 +- test/video/src/poster.ts | 6 +- 193 files changed, 3256 insertions(+), 2446 deletions(-) create mode 100644 rs/moq-net-tests/tests/integration/hop_limit.rs diff --git a/bench/browser/page/stats.ts b/bench/browser/page/stats.ts index 1af8a34d759..cee88d035c7 100644 --- a/bench/browser/page/stats.ts +++ b/bench/browser/page/stats.ts @@ -91,7 +91,7 @@ async function allocator(connection: Moq.Connection): Promise { @@ -149,7 +149,7 @@ async function setup(config: Sampling): Promise { /** Publishes one small-frame track and plays it on every connection. */ async function receive(config: Sampling): Promise { const publishing = new Moq.Origin.Producer(); - const publication = publishing.createBroadcast(Moq.Path.from(`${config.path}/live`)); + const publication = publishing.route(Moq.Path.from(`${config.path}/live`), { hidden: true }); const track = publication.broadcast.createTrack("data", { timescale: Moq.Time.Timescale.MILLI }); publication.announce(); const publisher = await Moq.Connection.connect({ @@ -249,7 +249,7 @@ async function resume(config: Sampling & { cycles: number; idle_ms: number; limi const waits: number[] = []; for (let cycle = 0; cycle < config.cycles; cycle++) { await new Promise((resolve) => setTimeout(resolve, config.idle_ms)); - const publication = origin.createBroadcast(Moq.Path.from(`${config.path}/resume/${cycle}`)); + const publication = origin.route(Moq.Path.from(`${config.path}/resume/${cycle}`), { hidden: true }); const track = publication.broadcast.createTrack("video", { priority: 1 }); const start = performance.now(); const reservation = handle.reserve(track.demand(), 2_500_000); diff --git a/bench/browser/page/transport.ts b/bench/browser/page/transport.ts index bbfce615db6..d188ee28dc2 100644 --- a/bench/browser/page/transport.ts +++ b/bench/browser/page/transport.ts @@ -32,7 +32,7 @@ async function publish(config: Transport): Promise { // Fixture generation stays outside every timed interval. const fixtures = Array.from({ length: config.frames }, (_, frame) => payload(config.size, frame)); const origin = new Moq.Origin.Producer(); - const publication = origin.createBroadcast(Moq.Path.from(config.path)); + const publication = origin.route(Moq.Path.from(config.path), { hidden: true }); const producer = publication.broadcast; // Retention covers the whole run, so a slow consumer cannot lose a group to eviction. const track = producer.createTrack("data", { timescale: Moq.Time.Timescale.MILLI, maxAge: Milli(600_000) }); diff --git a/demo/carla/web/src/truck.ts b/demo/carla/web/src/truck.ts index cfa29b3d4c7..d2d8240cfc2 100644 --- a/demo/carla/web/src/truck.ts +++ b/demo/carla/web/src/truck.ts @@ -415,8 +415,8 @@ export class Truck { const driverId = crypto.randomUUID().replaceAll("-", "").slice(0, 12); this.driverId.set(driverId); - const driverBroadcastPublication = conn.createBroadcast(driverPath(this.name, driverId)); - const driverBroadcast = driverBroadcastPublication.broadcast; + const driverBroadcastRoute = conn.route(driverPath(this.name, driverId), { hidden: true }); + const driverBroadcast = driverBroadcastRoute.broadcast; effect.cleanup(() => { driverBroadcast.close(); this.driverId.set(undefined); @@ -430,7 +430,7 @@ export class Truck { effect.run(this.#runControlTrack.bind(this, track, producer)); // A fresh instance per lease, which each publication mints: the truck binds its single // driver to this path and instance. - driverBroadcastPublication.announce(); + driverBroadcastRoute.announce(); } #runSafetyControl(connection: Moq.Connection, effect: Moq.Signals.Effect) { @@ -439,10 +439,10 @@ export class Truck { if (!conn || !command) return; const driverId = `safety-${crypto.randomUUID().replaceAll("-", "").slice(0, 12)}`; - const broadcastPublication = conn.createBroadcast(driverPath(this.name, driverId)); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = conn.route(driverPath(this.name, driverId), { hidden: true }); + const broadcast = broadcastRoute.broadcast; const safety = new SafetyCommandBroadcast(command, broadcast); - broadcastPublication.announce(); + broadcastRoute.announce(); effect.cleanup(() => safety.close()); } diff --git a/doc/lib/js/net.md b/doc/lib/js/net.md index 0b10f7e8b08..945ae840906 100644 --- a/doc/lib/js/net.md +++ b/doc/lib/js/net.md @@ -29,19 +29,19 @@ const connection = await Moq.Connection.connect({ consume: origin, }); -const publication = origin.createBroadcast(Moq.Path.from("chat.room")); -const broadcast = publication.broadcast; -const track = broadcast.createTrack("messages", { timescale: Moq.Time.Timescale.MILLI }); +// Hidden until its first track exists, then announced. +const route = origin.route(Moq.Path.from("chat.room"), { hidden: true }); +const track = route.broadcast.createTrack("messages", { timescale: Moq.Time.Timescale.MILLI }); const group = track.appendGroup(); group.writeFrame({ payload: new TextEncoder().encode("hello"), timestamp: Moq.Time.Timestamp.now() }); group.finish(); -publication.announce(); +route.announce(); ``` -- **The origin holds the broadcasts, not the connection.** Closing a session unannounces them and leaves them created for the next one. A publication controls announcements; its `broadcast` fills tracks. The broadcast is invisible, locally and remotely, until the publication calls `announce()`. -- **Answer claimed paths with `using`.** `requests(prefix)` claims a prefix and yields each requested path. Use `using prepared = request.prepare()`, fill its broadcast, then `prepared.publish()` to answer with a new stream under a fresh instance and keep the `Publication` it returns. Leaving the scope without publishing, including on a throw, refuses the request as unroutable. Explicit `prepared.close()` or closing its unpublished broadcast does the same; disposal after publishing leaves the returned publication and its fill broadcast live. Reject before preparing with `request.reject(err)`. A retained, unclosed prepared answer keeps the request pending; JavaScript garbage collection provides no prompt cleanup guarantee. +- **The origin holds the routes, not the connection.** `origin.route(path)` creates a route that owns a new broadcast; fill its tracks through `route.broadcast`. Closing a session withdraws its announcements and leaves the routes for the next one. A route is visible at once unless created `{ hidden: true }`, which keeps it invisible, locally and remotely, until `announce()`. `withdraw()` hides it again and `announce()` brings the same stream back. `close()` retracts it and closes its broadcast, as closing the broadcast does. +- **Answer claimed paths with a route.** `origin.routePrefix(prefix)` claims a prefix, and `route.requested()` yields each requested path. Answer with `request.route()`, a new exact route under a fresh instance, or `request.route({ hidden: true })` to fill its broadcast before `announce()` answers the requesters; closing it or its broadcast before then refuses them as unroutable, so `using job = request.route({ hidden: true })` refuses on a throw. Serve a broadcast you already hold with `request.serve(broadcast)`, or refuse with `request.reject(err)`. - **End content by finishing tracks.** A broadcast has no finished state. When the input ends, `finish()` each track, then `close()` it; closing a track without finishing aborts it. The broadcast stays announced and keeps serving them until you `close()` it. How long to keep it up for late readers is yours to decide. -- **Requests can pin an instance.** `consumer.request(path, { instance })` resolves only through a route announcing that [publisher instance](/concept/moq-lite#publisher-instances). The resolved broadcast's `instance` names the stream it came through, pinned or not. A publication mints a random instance and keeps it across `announce()`; pass `announce({ instance, epoch })` only for a publisher that continues its group sequences across restarts and raises the epoch each time. +- **Requests can pin an instance.** `consumer.request(path, { instance })` resolves only through a route announcing that [publisher instance](/concept/moq-lite#publisher-instances). The resolved broadcast's `instance` names the stream it came through, pinned or not. A route mints a random instance when it is created and keeps it across `withdraw()` and `announce()`; pass `origin.route(path, { instance, epoch })` only for a publisher that continues its group sequences across restarts and raises the epoch each time. - **Follow restarts.** `origin.follow(path)` follows whichever publisher instance serves the path: its `active` changes to a fresh broadcast on a restart, clears on an end, and resolves again on the next start, so read it reactively and close it when done. Instances are never stitched, so subscribe again to each new broadcast. Another route of the same instance taking over (instances travel only on `moq-lite-07-wip`; older wires mint one per announcement) keeps `active` as is, and each track subscription resumes there from the first group it lacks. A refusal ends it. Pass `{ instance }` to pin one stream, which it waits for again after an end. `request(path)` instead keeps its accepted instance and ends once that instance stops serving; while pending, it fails `Unroutable` once discovery of its path has synced without a route for it. To list what is live, iterate `announced(scope)`. See [identity and recovery](/concept/identity) to choose between following and holding one instance. - **Discovery follows what you watch.** A `consume` origin asks the relay for announcements only under the prefixes its readers watch with `announced(scope)`, `request(path)`, or `follow(path)`, stops asking about a prefix 2s after nothing at or beneath it is watched, and asks again on reconnect. Every request and follower watches its path from creation until closed, so it outlives the listing that found it. A relay that refuses an announce request downgrades that session: requests subscribe blind through it, and followers keep waiting for a session that can discover. - **Connections share by URL and versions.** `new Connection({ url })` pools and reconnects with backoff, which the elements use. An ordered `versions` list, spelled like `moq-lite-06` as in Rust, applies to both WebTransport and WebSocket; equivalent lists share, while a different order or an omitted list gets its own pool entry. Supplying your own transport options or origin selects a private loop. Receive estimates are on demand: observe `connection.probe` reactively or subscribe while you need them; `peek()` alone opens no PROBE stream. @@ -56,7 +56,7 @@ publication.announce(); - **Subscription defaults.** `Track.Subscription.default()` returns the default subscription, whose zero `delay.max` skips a superseded group at once; calling `subscribe()` with no options means the same. An omitted `delay` field means the same zero; `max: null` sets no subscriber limit. - **A subscription asks for `ranges`.** Each [range](/concept/moq-lite#subscriptions) starts and ends at an `absolute` group, one `relative` to the latest, or the group containing a `time` (a `Timestamp`), and a reader reads only its own ranges. A read whose ranges all end finishes once every group in them is handed out, dropped, or skipped, as in Rust. A time anchor needs a timed track and `moq-lite-07-wip` over a session. Passing the old `groups` key throws a `TypeError` naming `ranges`; `withRange` only narrows reads locally. - **Hidden paths** stay out of discovery unless the announce request opts in. See [hidden broadcasts](/concept/moq-lite#hidden-broadcasts). -- **Authorization is in band.** On moq-lite 07 (opt in with `versions: ["moq-lite-07-wip", "moq-lite-06"]`, listing every fallback you still want) and on moq-transport draft-18+ with the [MoQ Auth extension](/draft/moq-auth), `auth.grant` watches what the relay lets this side publish and subscribe to, and `auth.add(token)` presents another token without reconnecting. Publishing outside the grant closes the connection with `SessionCode.Unauthorized`, naming the path. On moq-lite, a subscription or track listing the grant stops covering resets with `StreamCode.Unauthorized` and the session stays up. On moq-transport, `auth.add(token)` keeps the token even without the extension, and a broadcast announced with the `Auth.Credential` it returns (`publication.announce({ auth })`) carries it on that announcement's `PUBLISH_NAMESPACE`; announcing again with another renews the request. A `Connection`'s `auth` handle (a getter on a pooled connection, following its URL) outlives its sessions: a token added there is presented on every reconnect and keeps riding the announcements that name it, with no re-add or re-announce. A one-shot session's `auth` ends with it, unless `Connection.connect` was given a `new Auth.Handle()` as `auth`. +- **Authorization is in band.** On moq-lite 07 (opt in with `versions: ["moq-lite-07-wip", "moq-lite-06"]`, listing every fallback you still want) and on moq-transport draft-18+ with the [MoQ Auth extension](/draft/moq-auth), `auth.grant` watches what the relay lets this side publish and subscribe to, and `auth.add(token)` presents another token without reconnecting. Publishing outside the grant closes the connection with `SessionCode.Unauthorized`, naming the path. On moq-lite, a subscription or track listing the grant stops covering resets with `StreamCode.Unauthorized` and the session stays up. On moq-transport, `auth.add(token)` keeps the token even without the extension, and a route created with the `Auth.Credential` it returns (`origin.route(path, { auth })`) carries it on that announcement's `PUBLISH_NAMESPACE`; `route.setAuth(other)` renews the request. A `Connection`'s `auth` handle (a getter on a pooled connection, following its URL) outlives its sessions: a token added there is presented on every reconnect and keeps riding the announcements that name it, with no re-add or re-announce. A one-shot session's `auth` ends with it, unless `Connection.connect` was given a `new Auth.Handle()` as `auth`. - **A graceful close waits.** `await connection.close()` withdraws announcements and drains for up to one second. `moq-lite-05` and newer wait for the subscriber to receive finished tails; older Lite versions wait only for transport ACKs. IETF media streams are not drained. `abort()` ends immediately. Examples: diff --git a/js/crypto/README.md b/js/crypto/README.md index 29316633daf..09b85db380c 100644 --- a/js/crypto/README.md +++ b/js/crypto/README.md @@ -36,10 +36,11 @@ const { Broadcast, SecretKey } = Sign; const key = await SecretKey.generate(); const path = Path.from(`mesh/${key.public}/agent`); -const publication = origin.createBroadcast(path); -const signed = new Broadcast.Producer(publication.broadcast, key, path); +const route = origin.route(path, { hidden: true }); +// Signs under the route's instance, which readers verify against. +const signed = new Broadcast.Producer(route.broadcast, key, { path, instance: route.instance }); const messages = signed.createTrack("messages"); -publication.announce({ instance: signed.instance }); +route.announce(); const group = messages.appendGroup(); await group.writeFrame(undefined, payload); @@ -87,15 +88,19 @@ every write is checked against it. `close()` ends the wrapped broadcast. import { E2ee } from "@moq/crypto"; import { Time } from "@moq/net"; -const { Broadcast, Credential } = E2ee; +const { Broadcast, Credential, Epoch } = E2ee; const credential = new Credential({ context, kid, secret }); const generation = credential.produce(); -const publication = origin.createBroadcast(await credential.path("meeting.hang")); -const video = await new Broadcast.Producer(publication.broadcast, generation).createTrack("video", { +// The route's instance names the generation's epoch, so subscribers find the key. +const route = origin.route(await credential.path("meeting.hang"), { + hidden: true, + instance: Epoch.instance(generation.epoch), +}); +const video = await new Broadcast.Producer(route.broadcast, generation).createTrack("video", { timescale: Time.Timescale.MILLI, }); -publication.announce({ epoch: generation.epoch }); +route.announce(); const group = video.appendGroup(); await group.writeFrame(Time.Timestamp.now(), frame); @@ -105,8 +110,8 @@ video.close(); ``` A subscriber follows `credential.path(semantic)` with `origin.follow(path)`. It takes each -instance's epoch from the broadcast it resolved, `broadcast.epoch` (or from the application's -channel on a wire without route epochs), so the key always matches the instance it reads. It +instance's epoch from the broadcast it resolved, `Epoch.of(broadcast)` (or from the application's +channel on a wire without route instances), so the key always matches the instance it reads. It binds the epoch with `credential.consume(epoch)` and wraps the broadcast in a `Broadcast.Consumer`. Its `subscribe(semantic)` opens the track a decrypted catalog names, and `close()` releases the diff --git a/js/crypto/src/e2ee/index.ts b/js/crypto/src/e2ee/index.ts index d58d299accc..cfe0725b3dd 100644 --- a/js/crypto/src/e2ee/index.ts +++ b/js/crypto/src/e2ee/index.ts @@ -7,8 +7,8 @@ * * A {@link Credential} is what the application distributes out of band. Each publisher instance * calls {@link Credential.produce} to mint a {@link Generation.Producer} and wraps its `@moq/net` - * broadcast in a {@link Broadcast.Producer}, announcing the generation's epoch as its route's - * instance. Subscribers follow the path, read each instance's epoch with {@link Epoch.of} from + * broadcast in a {@link Broadcast.Producer}, creating its route under the generation's epoch as + * its instance. Subscribers follow the path, read each instance's epoch with {@link Epoch.of} from * the broadcast it resolved, bind a {@link Generation.Consumer} with * {@link Credential.consume}, and wrap the broadcast in a {@link Broadcast.Consumer}. Both sides name tracks by their semantic names; only the * derived physical names reach `@moq/net`. @@ -16,9 +16,12 @@ * ```ts * const credential = new Credential({ context, kid, secret }); * const generation = credential.produce(); - * const publication = origin.createBroadcast(await credential.path("meeting.hang")); - * const video = await new Broadcast.Producer(publication.broadcast, generation).createTrack("video", { timescale }); - * publication.announce({ instance: Epoch.instance(generation.epoch) }); + * const route = origin.route(await credential.path("meeting.hang"), { + * hidden: true, + * instance: Epoch.instance(generation.epoch), + * }); + * const video = await new Broadcast.Producer(route.broadcast, generation).createTrack("video", { timescale }); + * route.announce(); * * const group = video.appendGroup(); * await group.writeFrame(timestamp, frame); diff --git a/js/crypto/src/e2ee/transport.test.ts b/js/crypto/src/e2ee/transport.test.ts index 93393471fcd..d1641f2b987 100644 --- a/js/crypto/src/e2ee/transport.test.ts +++ b/js/crypto/src/e2ee/transport.test.ts @@ -62,12 +62,12 @@ for (const [name, protocol, routed, timed] of transports) { const cred = credential(); const generation = cred.produce(); const path = await cred.path("meeting.hang"); - const broadcastPublication = publisher.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = publisher.route(path, { hidden: true, instance: Epoch.instance(generation.epoch) }); + const broadcast = broadcastRoute.broadcast; const video = await new Protected.Producer(broadcast, generation).createTrack("video", { timescale: Time.Timescale.MILLI, }); - broadcastPublication.announce({ instance: Epoch.instance(generation.epoch) }); + broadcastRoute.announce(); const group = video.appendGroup(); await group.writeFrame(ms(1), encoder.encode("keyframe")); @@ -119,12 +119,12 @@ for (const [name, protocol] of [ const cred = credential(); const generation = cred.produce(); const path = await cred.path("meeting.hang"); - const broadcastPublication = publisher.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = publisher.route(path, { hidden: true, instance: Epoch.instance(generation.epoch) }); + const broadcast = broadcastRoute.broadcast; const audio = await new Protected.Producer(broadcast, generation).createTrack("audio", { timescale: Time.Timescale.MILLI, }); - broadcastPublication.announce({ instance: Epoch.instance(generation.epoch) }); + broadcastRoute.announce(); // A group first, so the subscription is serving before datagrams, which are never cached. const group = audio.appendGroup(); diff --git a/js/crypto/src/sign/broadcast.ts b/js/crypto/src/sign/broadcast.ts index 07ff923b78b..716e1e83530 100644 --- a/js/crypto/src/sign/broadcast.ts +++ b/js/crypto/src/sign/broadcast.ts @@ -15,23 +15,32 @@ import * as Track from "./track.ts"; /** * The publishing side of a signed broadcast. * - * Mints a fresh instance, so a restart never signs a sequence an earlier instance already signed. - * Announce the wrapped broadcast with {@link instance} on its route. + * Signs under the instance of the route that serves it, which a route mints fresh, so a restart + * never signs a sequence an earlier instance already signed. */ export class Producer { - /** The instance this producer signs under, to announce on the broadcast's route. */ - readonly instance: Instance.Valid = Instance.random(); + /** The instance this producer signs under: the route's that serves the broadcast. */ + readonly instance: Instance.Valid; #inner: NetBroadcast.Producer; #key: SecretKey; #path: Path.Valid; // Each track's lowest unsigned sequence, kept across the track's replacements. #sequences = new Map(); - /** Sign `inner` with `key`, as the broadcast at application path `path`, taking ownership of it: {@link close} ends it. */ - constructor(inner: NetBroadcast.Producer, key: SecretKey, path: Path.Valid) { + /** + * Sign `inner` with `key`, as the broadcast at application path `path` served under `instance`, + * taking ownership of it: {@link close} ends it. Pass the instance of the route that serves it, + * such as `route.instance` for the route that owns `inner`. + */ + constructor( + inner: NetBroadcast.Producer, + key: SecretKey, + { path, instance }: { path: Path.Valid; instance: Instance.Valid }, + ) { this.#inner = inner; this.#key = key; this.#path = path; + this.instance = instance; } /** Settles with `null` once the wrapped broadcast closes, as `@moq/net`'s `closed` does. */ diff --git a/js/crypto/src/sign/index.ts b/js/crypto/src/sign/index.ts index b840f107158..8b9e5b4704d 100644 --- a/js/crypto/src/sign/index.ts +++ b/js/crypto/src/sign/index.ts @@ -13,10 +13,10 @@ * ```ts * const key = await SecretKey.generate(); * const path = Path.from(`mesh/${key.public}/agent`); - * const publication = origin.createBroadcast(path); - * const signed = new Broadcast.Producer(publication.broadcast, key, path); + * const route = origin.route(path, { hidden: true }); + * const signed = new Broadcast.Producer(route.broadcast, key, { path, instance: route.instance }); * const messages = signed.createTrack("messages"); - * publication.announce({ instance: signed.instance }); + * route.announce(); * * const group = messages.appendGroup(); * await group.writeFrame(undefined, payload); diff --git a/js/crypto/src/sign/sign.test.ts b/js/crypto/src/sign/sign.test.ts index d2f1d01da46..342bb759c24 100644 --- a/js/crypto/src/sign/sign.test.ts +++ b/js/crypto/src/sign/sign.test.ts @@ -46,15 +46,14 @@ async function active(origin: Origin.Producer, path: Path.Valid): Promise({ track, deltas: false }); - broadcastPublication.announce(); + broadcastRoute.announce(); const request = origin.request(Moq.Path.from("room/alice")); const active = request.active.peek(); if (!active) throw new Error("request did not resolve"); diff --git a/js/moq-boy/src/game.test.ts b/js/moq-boy/src/game.test.ts index 4070d14ef80..57f48e84873 100644 --- a/js/moq-boy/src/game.test.ts +++ b/js/moq-boy/src/game.test.ts @@ -58,8 +58,7 @@ test("status skips values that fail the schema and ends when the track errors", const connection = new Moq.Connection({ enabled: false }); const origin = new Moq.Origin.Producer(); - const publication = origin.createBroadcast(Moq.Path.from("game", "test")); - publication.announce(); + const publication = origin.route(Moq.Path.from("game", "test")); const track = publication.broadcast.createTrack("status"); // One finished group per status, so between statuses the loop waits on the next group. diff --git a/js/moq-boy/src/game.ts b/js/moq-boy/src/game.ts index 0a043641b3a..c5a9101ec72 100644 --- a/js/moq-boy/src/game.ts +++ b/js/moq-boy/src/game.ts @@ -321,13 +321,10 @@ export class Game { const viewerId = Math.random().toString(36).slice(2, 8); this.viewerId.set(viewerId); - const viewerBroadcastPublication = origin.createBroadcast( - Moq.Path.from(this.#viewerPrefix, this.sessionId, viewerId), - ); - const viewerBroadcast = viewerBroadcastPublication.broadcast; - viewerBroadcastPublication.announce(); + const viewerRoute = origin.route(Moq.Path.from(this.#viewerPrefix, this.sessionId, viewerId)); + const viewerBroadcast = viewerRoute.broadcast; effect.cleanup(() => { - viewerBroadcast.close(); + viewerRoute.close(); this.viewerId.set(undefined); }); diff --git a/js/net/MIGRATE.md b/js/net/MIGRATE.md index a2b0e96e2be..4a21c2ea5da 100644 --- a/js/net/MIGRATE.md +++ b/js/net/MIGRATE.md @@ -4,6 +4,48 @@ How to update your code for each breaking change, newest first. ## Unreleased +### One `Origin.Route` handle replaces publications, claims, and prepared answers + +`Origin.Producer.createBroadcast`, `requests`, and `requestsRoute`, and the `Origin.Publication`, `Origin.Prepared`, and `Origin.Requests` classes are gone. +An `Origin.Route` owns what you publish: `origin.route(path, options?)` creates an exact route that owns a new broadcast, and `origin.routePrefix(prefix, options?)` creates a prefix route that yields requests. +A route is visible at once unless created with `{ hidden: true }`; `announce()` and `withdraw()` toggle it, `announced` says which, and `close()` retracts it and closes its broadcast, as closing the broadcast does. +Its `instance` is minted when the route is created and kept across `withdraw()` and `announce()`, so a reader continues rather than restarts. A new route is a new stream. +`RouteOptions` sets what `announce(route)` took: `cost`, `auth`, and a stable `instance` with its `epoch`. Re-price with `setCost(cost)` and swap the credential with `setAuth(auth)`. + +```ts +// Before +const publication = origin.createBroadcast(path); +publication.broadcast.createTrack("catalog.json"); +publication.announce({ cost: 5n }); +publication.unannounce(); + +// After +const route = origin.route(path, { hidden: true, cost: 5n }); +route.broadcast.createTrack("catalog.json"); +route.announce(); +route.withdraw(); // announce() again continues the same instance +``` + +Drop the separate `announce()` call when nothing needs filling first: `origin.route(path)` is already visible. +A prefix route replaces `requests(prefix)`: iterate `route.requested()` as before, and answer each request with `serve(broadcast)`, `reject(err)`, or `request.route(options?)`, which replaces `prepare()` and `Prepared.publish()`. +A job's route is visible at once and answers the waiting requesters unless created hidden; a hidden one answers them on `announce()`, and closing it or its broadcast before then refuses them as `Unroutable`. + +```ts +// Before +using prepared = request.prepare(); +prepared.broadcast.createTrack("video"); +const publication = prepared.publish(); + +// After +const job = request.route({ hidden: true }); +job.broadcast.createTrack("video"); +job.announce(); +``` + +`route.broadcast` throws on a prefix route, and `requested()` ends at once on an exact one. +The route metadata interface `Origin.Route` is now the read-only `Origin.RouteInfo`, carried on announce events; applications never build one. +`Origin.Table` exposes `route` and `routePrefix` in place of `createBroadcast`, `requests`, and `requestsRoute`, and `Origin.RequestSlot` and `Origin.RouteEntry` are no longer exported. + ### A timestamp out of range at the track's timescale is a `TimestampMismatch` ([#7702](https://github.com/moq-dev/moq/pull/7702)) A frame or datagram whose timestamp leaves the safe range once converted to the track's timescale is refused at the write with `TimestampMismatch`, as Rust refuses it, rather than with a `RangeError` when it is encoded. diff --git a/js/net/api/index.api.md b/js/net/api/index.api.md index 1f88caaaaa9..0beeeed5d1b 100644 --- a/js/net/api/index.api.md +++ b/js/net/api/index.api.md @@ -11,7 +11,7 @@ export namespace Announce { export interface Announce { captures: Path.Pattern[] | undefined; prefix: Path.Valid; - route: Origin.Route; + route: Origin.RouteInfo; } export class Consumer { [Symbol.asyncIterator](): AsyncGenerator; @@ -403,37 +403,19 @@ export namespace Origin { } export type Hop = infer; export const HopSchema: $ZodBranded, "Hop", "out">; - export class Prepared { - [Symbol.dispose](): void; - readonly broadcast: Broadcast.Producer; - close(): void; - publish(): Origin.Publication; - } export class Producer implements Origin.Table { constructor(); announced(scope?: Path.Pattern, options?: Announce.Options): Announce.Consumer; close(abort?: Error): void; get closed(): Signals.GetPromise; consume(): Origin.Consumer; - createBroadcast(path: Path.Valid): Origin.Publication; get discovery(): Signals.Getter; follow(path: Path.Valid, options?: Origin.FollowOptions): Origin.Following; request(path: Path.Valid, options?: Origin.RequestOptions): Origin.Requesting; - requests(prefix: Path.Valid): Origin.Requests; + route(path: Path.Valid, options?: Origin.RouteOptions): Origin.Route; + routePrefix(prefix: Path.Valid, options?: Origin.RouteOptions): Origin.Route; scope(root: Path.Valid, patterns: Path.Patterns): Origin.Producer; } - export class Publication { - announce(route?: Origin.Route | { - auth?: Origin.Route["auth"]; - cost?: Origin.Route["cost"]; - epoch?: Origin.Route["epoch"]; - hops?: Origin.Route["hops"]; - instance?: Origin.Route["instance"]; - }): void; - readonly broadcast: Broadcast.Producer; - get route(): Origin.Route | undefined; - unannounce(): void; - } export interface Reader { announced(scope?: Path.Pattern, options?: Announce.Options): Announce.Consumer; readonly closed: Signals.GetPromise; @@ -443,8 +425,8 @@ export namespace Origin { } export class Request { readonly path: Path.Valid; - prepare(): Origin.Prepared; reject(err: Error): void; + route(options?: Origin.RouteOptions): Origin.Route; serve(source: Broadcast.Producer | Broadcast.Consumer): void; } export interface RequestOptions { @@ -456,24 +438,37 @@ export namespace Origin { readonly closed: Signals.GetPromise; readonly path: Path.Valid; } - export class Requests { + export class Route { + [Symbol.dispose](): void; + announce(): void; + get announced(): boolean; + get broadcast(): Broadcast.Producer; close(): void; - readonly prefix: Path.Valid; + get instance(): Instance.Valid; requested(): AsyncIterableIterator; - get route(): Origin.Route; - } - export interface Route { + setAuth(auth?: Auth.Credential): void; + setCost(cost: Origin.Cost): void; + withdraw(): void; + } + export interface RouteInfo { + readonly auth?: Auth.Credential; + readonly cost: Origin.Cost; + readonly epoch?: bigint; + readonly hops: readonly Origin.Hop[]; + readonly instance?: Instance.Valid; + } + export interface RouteOptions { auth?: Auth.Credential; - cost: Origin.Cost; + cost?: Origin.Cost; epoch?: bigint; - hops: Origin.Hop[]; + hidden?: boolean; instance?: Instance.Valid; } export interface Table extends Origin.Reader { - createBroadcast(path: Path.Valid): Origin.Publication; - requests(prefix: Path.Valid): Origin.Requests; + route(path: Path.Valid, options?: Origin.RouteOptions): Origin.Route; + routePrefix(prefix: Path.Valid, options?: Origin.RouteOptions): Origin.Route; } - export function isAnonymous(route: Origin.Route): boolean; + export function isAnonymous(route: Origin.RouteInfo): boolean; } export namespace Path { diff --git a/js/net/bench/broadcasts.ts b/js/net/bench/broadcasts.ts index befb87f20f6..823d8ebb23a 100644 --- a/js/net/bench/broadcasts.ts +++ b/js/net/bench/broadcasts.ts @@ -4,7 +4,7 @@ import { Signal } from "@moq/signals"; import type { Grant } from "../src/auth.ts"; import { Producer as BroadcastProducer } from "../src/broadcast.ts"; import { BroadcastCache } from "../src/consume.ts"; -import { HopSchema, Route } from "../src/hop.ts"; +import { HopSchema, RouteInfo } from "../src/hop.ts"; import * as Instance from "../src/instance.ts"; import { AnnounceRequest } from "../src/lite/announce.ts"; import { Publisher } from "../src/lite/publisher.ts"; @@ -15,6 +15,7 @@ import { createMockTransportPair } from "../src/mock.ts"; import { Producer } from "../src/origin.ts"; import * as Path from "../src/path.ts"; import { Stream, Writer } from "../src/stream.ts"; +import { wireOf } from "../src/wire.ts"; // Keep protocol diagnostics out of the measured CSV on stdout. console.debug = console.error; @@ -37,7 +38,7 @@ for (const scope of [ for (const observerCount of observerCounts) { const origin = new Producer(); const handles = Array.from({ length: routeCount }, (_, index) => - origin.requests(Path.from(`room/${index}${scope === "full-name" ? ".chat" : ""}`)), + origin.routePrefix(Path.from(`room/${index}${scope === "full-name" ? ".chat" : ""}`)), ); const touched = Path.from( scope === "rooted-producers" ? "0" : scope === "full-name" ? "room/0.chat" : "room/0", @@ -75,7 +76,7 @@ for (const scope of [ const start = performance.now(); for (let index = 0; index < updates; index++) { - handles[0].updateRoute({ cost: BigInt(index + 1) }); + handles[0].setCost(BigInt(index + 1)); await new Promise((resolve) => setImmediate(resolve)); } const elapsed = performance.now() - start; @@ -132,16 +133,14 @@ for (const pinned of [false, true]) { const origin = new Producer(); const reader = origin.consume(); const options = pinned ? { instance } : {}; - const publishers = Array.from({ length: routeCount }, (_, index) => { - const sourcePublication = origin.createBroadcast(Path.from(`room/${index}`)); - sourcePublication.announce({ instance }); - return sourcePublication; - }); + const publishers = Array.from({ length: routeCount }, (_, index) => + origin.route(Path.from(`room/${index}`), { instance }), + ); const background = publishers.map((_, index) => reader.request(Path.from(`room/${index}`), options)); const requests = Array.from({ length: readerCount }, () => reader.request(Path.from("room/0"), options)); const start = performance.now(); for (let index = 0; index < updates; index++) { - publishers[0].announce({ instance, cost: BigInt(index + 1) }); + publishers[0].setCost(BigInt(index + 1)); await Promise.resolve(); for (const request of requests) { if (!request.active.peek()) throw new Error("same-instance request lost its front"); @@ -234,7 +233,7 @@ const nextInstance = Instance.parse("01900000-0000-7000-8000-000000000002"); for (const pathCount of routeCounts) { for (const readerCount of observerCounts) { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room"), { instance }); + const dynamic = origin.routePrefix(Path.from("room"), { instance }); const pending = dynamic.requested(); const requests = Array.from({ length: pathCount }, (_, index) => Array.from({ length: readerCount }, () => origin.consume().request(Path.from(`room/${index}`))), @@ -247,7 +246,7 @@ for (const pathCount of routeCounts) { await Promise.resolve(); const before = requests.map((request) => request.active.peek()); const start = performance.now(); - dynamic.updateRoute({ instance: nextInstance }); + wireOf(dynamic).update({ instance: nextInstance }); await Promise.resolve(); const elapsed = performance.now() - start; for (const [index, request] of requests.entries()) { @@ -269,7 +268,7 @@ for (const routeCount of routeCounts) { for (const consumerCount of [8, 32, 128]) { const cache = new BroadcastCache(); const owners = Array.from({ length: routeCount }, () => ({})); - for (let i = 0; i < routeCount; i++) cache.announce(Path.from(`pool/${i}`), owners[i], Route.default); + for (let i = 0; i < routeCount; i++) cache.announce(Path.from(`pool/${i}`), owners[i], RouteInfo.default); const sources = Array.from({ length: consumerCount }, () => new BroadcastProducer()); const held = sources.map((source, i) => { const path = Path.from(`pool/${i % routeCount}/job/${i}`); @@ -278,7 +277,7 @@ for (const routeCount of routeCounts) { const touched = Path.from("pool/0/job/0"); const start = performance.now(); for (let i = 0; i < 4096; i++) { - cache.announce(Path.from("pool/0"), owners[0], { ...Route.default, cost: BigInt(i) }); + cache.announce(Path.from("pool/0"), owners[0], { ...RouteInfo.default, cost: BigInt(i) }); const shared = cache.get(touched, cache.instance(touched)); if (!shared || shared.closed !== held[0].closed) throw new Error("update replaced the source"); shared.close(); @@ -295,7 +294,7 @@ for (const routeCount of routeCounts) { for (const consumerCount of [1, 8, 32]) { const cache = new BroadcastCache(); const owners = Array.from({ length: routeCount }, () => ({})); - for (let i = 0; i < routeCount; i++) cache.announce(Path.from(`pool/${i}`), owners[i], Route.default); + for (let i = 0; i < routeCount; i++) cache.announce(Path.from(`pool/${i}`), owners[i], RouteInfo.default); const sources = Array.from({ length: consumerCount }, () => new BroadcastProducer()); const paths = sources.map((_, i) => Path.from(`pool/0/job/${i}`)); const held = sources.map((source, i) => cache.insert(paths[i], cache.instance(paths[i]), source.consume())); @@ -305,7 +304,7 @@ for (const routeCount of routeCounts) { let duplicates = 0; const start = performance.now(); for (let round = 0; round < 256; round++) { - if (round % 2 === 0) cache.announce(prefix, specific, { ...Route.default, instance }); + if (round % 2 === 0) cache.announce(prefix, specific, { ...RouteInfo.default, instance }); else cache.withdraw(prefix, specific); for (let i = 0; i < consumerCount; i++) { const instance = cache.instance(paths[i]); @@ -330,7 +329,7 @@ console.log("blind,announcements,consumers,invalidate_us,stale"); for (const routeCount of routeCounts) { for (const consumerCount of [1, 8, 32]) { const cache = new BroadcastCache(); - for (let i = 0; i < routeCount; i++) cache.announce(Path.from(`other/${i}`), {}, Route.default); + for (let i = 0; i < routeCount; i++) cache.announce(Path.from(`other/${i}`), {}, RouteInfo.default); const source = new BroadcastProducer(); const keeper = source.consume(); const paths = Array.from({ length: consumerCount }, (_, i) => Path.from(`pool/job/${i}`)); @@ -341,7 +340,7 @@ for (const routeCount of routeCounts) { for (let round = 0; round < 256; round++) { const held = paths.map((path) => cache.insert(path, cache.instance(path), source.consume())); const start = performance.now(); - cache.announce(prefix, owner, Route.default); + cache.announce(prefix, owner, RouteInfo.default); cache.withdraw(prefix, owner); elapsed += performance.now() - start; for (const path of paths) { @@ -372,7 +371,7 @@ for (const routeCount of routeCounts) { const held = []; for (let route = 0; route < routeCount; route++) { const prefix = Path.from(`route/${route}`); - cache.announce(prefix, owners[route], Route.default); + cache.announce(prefix, owners[route], RouteInfo.default); for (let consumer = 0; consumer < (route === 0 ? consumerCount : 1); consumer++) { const path = Path.from(`${prefix}/job/${consumer}`); const instance = cache.instance(path); @@ -403,9 +402,8 @@ for (const routeCount of routeCounts) { for (const observerCount of observerCounts) { const origin = new Producer(); const routes = Array.from({ length: routeCount }, (_, index) => { - const broadcastPublication = origin.createBroadcast(Path.from(`z/${index}`)); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from(`z/${index}`)); + const broadcast = broadcastRoute.broadcast; return broadcast; }); const senders = Array.from({ length: observerCount }, () => { @@ -429,9 +427,8 @@ for (const routeCount of routeCounts) { await Promise.all(senders.map((sender) => sender.entered.promise)); const start = performance.now(); for (let index = 0; index < updates; index++) { - const broadcastPublication = origin.createBroadcast(Path.from(`a/${index}`)); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from(`a/${index}`)); + const broadcast = broadcastRoute.broadcast; await new Promise((resolve) => setImmediate(resolve)); broadcast.close(); await new Promise((resolve) => setImmediate(resolve)); diff --git a/js/net/bench/fills.ts b/js/net/bench/fills.ts index df3a607ab86..498fdcb86a7 100644 --- a/js/net/bench/fills.ts +++ b/js/net/bench/fills.ts @@ -19,8 +19,7 @@ console.log("groups,subscribers,fill_us"); for (const groups of [2, 16, 128]) { for (const subscribers of [1, 8]) { const origin = new Producer(); - const publication = origin.createBroadcast(Path.from("fills")); - publication.announce(); + const publication = origin.route(Path.from("fills")); const track = publication.broadcast.createTrack("video", { maxAge: Milli(60_000) }); for (let i = 0; i < groups; i++) { const group = track.appendGroup(); diff --git a/js/net/bench/forward.ts b/js/net/bench/forward.ts index c0aaa6f030f..3840a68d126 100644 --- a/js/net/bench/forward.ts +++ b/js/net/bench/forward.ts @@ -10,7 +10,7 @@ import { AuthSession } from "../src/auth_session.ts"; import { Producer as BroadcastProducer } from "../src/broadcast.ts"; import type { Established } from "../src/connection/established.ts"; import { forwardAnnounced } from "../src/connection/forward.ts"; -import { Route } from "../src/hop.ts"; +import { RouteInfo } from "../src/hop.ts"; import { Producer } from "../src/origin.ts"; import * as Path from "../src/path.ts"; import { registerWire } from "../src/wire.ts"; @@ -52,7 +52,7 @@ class FakeSession { } const announce = (stream: Announce.Producer, prefix: Path.Valid, cost: bigint, kind: "start" | "update") => - stream.append({ prefix, captures: undefined, kind, route: Route.normalize({ cost }) }); + stream.append({ prefix, captures: undefined, kind, route: RouteInfo.normalize({ cost }) }); console.log("touched,heads,routes,update_us"); for (const touched of ["covering", "single"] as const) { diff --git a/js/net/bench/refresh.ts b/js/net/bench/refresh.ts index 815fa3e7274..0d15dc59c0e 100644 --- a/js/net/bench/refresh.ts +++ b/js/net/bench/refresh.ts @@ -16,9 +16,8 @@ for (const retained of [1, 64, 1024]) const installed = clock.install(); const source = new Producer(); const destination = new Producer(); - const broadcastPublication = source.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = source.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producers = Array.from({ length: tracks }, (_, i) => broadcast.createTrack(`data${i}`, { refresh: 1 }), ); diff --git a/js/net/bench/requests.ts b/js/net/bench/requests.ts index 5bd6a4fa82e..44e1da5645d 100644 --- a/js/net/bench/requests.ts +++ b/js/net/bench/requests.ts @@ -28,9 +28,8 @@ for (const touched of ["watched", "unrelated"]) const origin = new Producer(); const path = Path.from("room/0"); const broadcasts = Array.from({ length: routes }, (_, i) => { - const broadcastPublication = origin.createBroadcast(Path.from(`room/${i}`)); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from(`room/${i}`)); + const broadcast = broadcastRoute.broadcast; return broadcast; }); const requests = Array.from({ length: followers }, () => origin.follow(path)); @@ -41,9 +40,8 @@ for (const touched of ["watched", "unrelated"]) for (let round = 0; round < 6; round++) { const start = performance.now(); for (let i = 0; i < 128; i++) { - const nextPublication = origin.createBroadcast(touched === "watched" ? path : Path.from("other")); - const next = nextPublication.broadcast; - nextPublication.announce(); + const nextRoute = origin.route(touched === "watched" ? path : Path.from("other")); + const next = nextRoute.broadcast; if (touched === "watched") { current.close(); current = next; @@ -73,7 +71,7 @@ console.log("unrelated,waiters,cancel_us"); for (const unrelated of [8, 128, 2048]) for (const waiters of [1, 8, 32]) { const origin = new Producer(); - origin.requestsRoute(Path.from("pending")); + origin.routePrefix(Path.from("pending")); const held = Array.from({ length: unrelated }, (_, i) => origin.request(Path.from(`pending/${i}`))); const wire = wireOf(origin.consume()); const samples: number[] = []; @@ -141,9 +139,9 @@ for (const failovers of [0, 1, 16, 128]) const sources: Broadcast[] = []; for (let i = 0; i < failovers; i++) { const instance = Instance.random(); - const primary = origin.requestsRoute(prefix, { instance, cost: 0n }); + const primary = origin.routePrefix(prefix, { instance, cost: 0n }); const ar = primary.requested(); - const br = origin.requestsRoute(prefix, { instance, cost: 1n }).requested(); + const br = origin.routePrefix(prefix, { instance, cost: 1n }).requested(); const held = origin.request(path); const source = new Broadcast(); sources.push(source); @@ -153,8 +151,8 @@ for (const failovers of [0, 1, 16, 128]) entries.push({ primary, ar, br, held }); } const instance = Instance.random(); - origin.requestsRoute(prefix, { instance }); - for (let i = 0; i < extraRoutes; i++) origin.requestsRoute(prefix, { instance, cost: BigInt(i + 1) }); + origin.routePrefix(prefix, { instance }); + for (let i = 0; i < extraRoutes; i++) origin.routePrefix(prefix, { instance, cost: BigInt(i + 1) }); const pending = []; for (const entry of entries) { entry.primary.close(); @@ -216,7 +214,7 @@ for (const operation of ["cancel-forward", "cancel-reverse", "drain-local"]) const settled: number[] = []; for (let round = 0; round < 4; round++) { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("pending")); + const dynamic = origin.routePrefix(Path.from("pending")); const requests = dynamic.requested(); const wire = wireOf(origin.consume()); const names = Array.from({ length: paths }, (_, i) => Path.from(`pending/${i}`)); @@ -274,7 +272,7 @@ for (const survivor of [false, true]) const origin = new Producer(); const prefix = Path.from("competing"); const path = Path.from("competing/touched"); - for (let i = 0; i < routes; i++) origin.requestsRoute(prefix, { cost: BigInt(i) }); + for (let i = 0; i < routes; i++) origin.routePrefix(prefix, { cost: BigInt(i) }); const wire = wireOf(origin.consume()); const kept = survivor ? new AbortController() : undefined; const remaining = kept ? wire.demand(path, undefined, kept.signal).catch(() => {}) : undefined; @@ -314,9 +312,8 @@ for (const [version, alpn] of [ const sources = []; for (const prefix of ["a", "b"]) for (let i = 0; i < namespaces; i++) { - const sourcePublication = origin.createBroadcast(Path.from(`${prefix}/${i}`)); - const source = sourcePublication.broadcast; - sourcePublication.announce(); + const sourceRoute = origin.route(Path.from(`${prefix}/${i}`)); + const source = sourceRoute.broadcast; sources.push(source); } const peers = await Promise.all( diff --git a/js/net/bench/resume-history.ts b/js/net/bench/resume-history.ts index a5e2d63bd63..fd417fbf752 100644 --- a/js/net/bench/resume-history.ts +++ b/js/net/bench/resume-history.ts @@ -216,8 +216,7 @@ async function measureOn(clock: Manual, { fronts, names: perRoute, routes, histo const publisher = new OriginProducer(); const paths = Array.from({ length: fronts }, (_, index) => Path.from(`room/${index}`)); const broadcasts: BroadcastProducer[] = paths.map((path) => { - const publication = publisher.createBroadcast(path); - publication.announce(); + const publication = publisher.route(path); return publication.broadcast; }); const payload = new Uint8Array(PAYLOAD).fill(7); diff --git a/js/net/bench/serve-browser-entry.ts b/js/net/bench/serve-browser-entry.ts index f70d07346b9..bde56cddf01 100644 --- a/js/net/bench/serve-browser-entry.ts +++ b/js/net/bench/serve-browser-entry.ts @@ -17,9 +17,8 @@ import { Timescale, Timestamp } from "../src/time.ts"; async function measure(protocol: string, groups: number, viewers: number) { const origin = new Origin(); - const broadcastPublication = origin.createBroadcast(Path.from("bench")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("bench")); + const broadcast = broadcastRoute.broadcast; const track = broadcast.createTrack("data", { maxAge: Milli(60_000), timescale: Timescale.MICRO }); const pair = createMockTransportPair(protocol === "lite" ? ALPN_05 : ALPN.DRAFT_22); const version = protocol === "lite" ? LiteVersion.DRAFT_05 : IetfVersion.DRAFT_22; diff --git a/js/net/bench/subscribe-drop.ts b/js/net/bench/subscribe-drop.ts index 892a8d9a7c0..bf4d9af8f59 100644 --- a/js/net/bench/subscribe-drop.ts +++ b/js/net/bench/subscribe-drop.ts @@ -23,9 +23,8 @@ try { for (let rep = 0; rep < reps; rep++) { const origins = Array.from({ length: publishers }, () => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("bench")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("bench")); + const broadcast = broadcastRoute.broadcast; const track = broadcast.createTrack("video", { timescale: Timescale.MILLI }); for (let sequence = 0n; sequence < BigInt(groups); sequence++) { const group = track.createGroup(sequence); diff --git a/js/net/examples/publish.ts b/js/net/examples/publish.ts index 90d90d6be64..7b1b7b27d09 100644 --- a/js/net/examples/publish.ts +++ b/js/net/examples/publish.ts @@ -7,10 +7,9 @@ async function main() { const origin = new Moq.Origin.Producer(); const connection = await Moq.Connection.connect({ url, publish: origin.consume() }); - // Create a broadcast (a collection of tracks) at a path on the origin - const broadcastPublication = origin.createBroadcast(Moq.Path.from("my-broadcast")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + // Route a path on the origin. The route owns a broadcast (a collection of tracks) and announces it. + const route = origin.route(Moq.Path.from("my-broadcast")); + const broadcast = route.broadcast; // Create the "chat" track up front. A subscriber is served directly from this // track, no requested() round-trip needed. Mirrors Rust's create_track. diff --git a/js/net/src/announced.test-util.ts b/js/net/src/announced.test-util.ts index daee64e6ad2..f5375fe8826 100644 --- a/js/net/src/announced.test-util.ts +++ b/js/net/src/announced.test-util.ts @@ -1,13 +1,13 @@ import { Signal } from "@moq/signals"; import type { Options } from "./announced"; -import type { Route } from "./hop"; +import type { RouteInfo } from "./hop"; import type { Table } from "./origin"; import type * as Path from "./path"; /** A closeable announcement snapshot for tests and benchmarks. @internal */ export async function announcedView(origin: Pick, scope?: Path.Pattern, options?: Options) { const stream = origin.announced(scope, options); - const value = new Signal>(new Map()); + const value = new Signal>(new Map()); const done = (async () => { for await (const event of stream) value.update((previous) => { diff --git a/js/net/src/announced.test.ts b/js/net/src/announced.test.ts index f9da2f5b217..1e0d2fa882c 100644 --- a/js/net/src/announced.test.ts +++ b/js/net/src/announced.test.ts @@ -2,15 +2,14 @@ import { expect, test } from "bun:test"; import { yieldNow } from "@moq/clock"; import * as Announce from "./announced.ts"; import type { Producer as BroadcastProducer } from "./broadcast.ts"; -import { Route } from "./hop.ts"; +import { RouteInfo } from "./hop.ts"; import { Producer as OriginProducer } from "./origin.ts"; import * as Path from "./path.ts"; import { wireOf } from "./wire.ts"; function publish(origin: OriginProducer, path: Path.Valid): BroadcastProducer { - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(path); + const broadcast = broadcastRoute.broadcast; return broadcast; } @@ -20,7 +19,7 @@ test("next streams every appended event in order", async () => { const producer = new Announce.Producer(); const consumer = producer.consume(); - const route = Route.default; + const route = RouteInfo.default; producer.append({ prefix: p("a"), captures: undefined, kind: "start", route }); producer.append({ prefix: p("a"), captures: undefined, kind: "end", route }); @@ -32,7 +31,7 @@ test("the consumer is an async iterable of the same events", async () => { const producer = new Announce.Producer(); const consumer = producer.consume(); - const route = Route.default; + const route = RouteInfo.default; producer.append({ prefix: p("a"), captures: undefined, kind: "start", route }); producer.append({ prefix: p("a"), captures: undefined, kind: "end", route }); @@ -51,7 +50,7 @@ test("a same-name re-announce is a distinct update", async () => { // The stream is a log, not a set: it carries a redundant announce as its own update rather // than collapsing it. Deciding what a repeat means belongs to the session layer, which resolves // a restart into either nothing (an identical route) or an in-place update. - const route = Route.default; + const route = RouteInfo.default; producer.append({ prefix: p("a"), captures: undefined, kind: "start", route }); producer.append({ prefix: p("a"), captures: undefined, kind: "start", route }); @@ -84,7 +83,7 @@ test("closing a consumer releases only that handle", async () => { expect(producer.closed.peek()).toBeUndefined(); // The other reader keeps the stream: an event still reaches it. - const route = Route.default; + const route = RouteInfo.default; producer.append({ prefix: p("a"), captures: undefined, kind: "start", route }); expect((await second.next())?.prefix).toBe(p("a")); @@ -165,7 +164,7 @@ const start = (prefix: string): Announce.Event => ({ prefix: p(prefix), captures: undefined, kind: "start", - route: Route.default, + route: RouteInfo.default, }); test("a stream syncs once the reader is past what was queued at the boundary", async () => { diff --git a/js/net/src/announced.ts b/js/net/src/announced.ts index 64dca8800b3..a9126fb3426 100644 --- a/js/net/src/announced.ts +++ b/js/net/src/announced.ts @@ -4,7 +4,7 @@ * @module */ import { type GetPromise, type Getter, Once, Signal } from "@moq/signals"; -import type { Route } from "./hop.js"; +import type { RouteInfo } from "./hop.js"; import type * as Path from "./path.js"; /** @@ -26,7 +26,7 @@ export interface Announce { /** What the filter's wildcards stood for, when this prefix pins all of them. */ captures: Path.Pattern[] | undefined; /** Hops and cost of the route; on a retraction, its last advertised values. */ - route: Route; + route: RouteInfo; } /** diff --git a/js/net/src/auth.test.ts b/js/net/src/auth.test.ts index 517dbe8ea8a..2d10ad75f72 100644 --- a/js/net/src/auth.test.ts +++ b/js/net/src/auth.test.ts @@ -311,8 +311,8 @@ describe.each([Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_22])("%s", (protocol) => { })(); await waitFor(client.auth.grant, (g) => g !== undefined); - origin.createBroadcast(Path.from("baz/ok")).announce(); - origin.createBroadcast(Path.from("foo/bar")).announce(); + origin.route(Path.from("baz/ok"), { hidden: true }).announce(); + origin.route(Path.from("foo/bar"), { hidden: true }).announce(); const info = await transport.closed; expect(info.closeCode).toBe(SessionCode.Unauthorized); @@ -332,15 +332,14 @@ describe.each([Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_22])("%s", (protocol) => { try { const unanswered = await requests.next(); if (!unanswered) throw new Error("missing token"); - const withdrawn = origin.createBroadcast(Path.from("foo/bar")); - withdrawn.announce(); + const withdrawn = origin.route(Path.from("foo/bar")); await yieldNow(); - withdrawn.unannounce(); + withdrawn.withdraw(); await yieldNow(); const issued = unanswered.accept(grant(["other"], [])); await adding; // Still enforcing: the next uncovered broadcast is the one named. - origin.createBroadcast(Path.from("still-bad")).announce(); + origin.route(Path.from("still-bad"), { hidden: true }).announce(); const info = await transport.closed; expect(info.closeCode).toBe(SessionCode.Unauthorized); expect(info.reason).toBe("unauthorized: still-bad"); @@ -367,7 +366,7 @@ describe.each([Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_22])("%s", (protocol) => { })(); await waitFor(client.auth.grant, (g) => g !== undefined); - origin.createBroadcast(Path.from("a/x")).announce(); + origin.route(Path.from("a/x"), { hidden: true }).announce(); const announced = server.announced(); const first = await nextRoute(announced); @@ -459,9 +458,8 @@ describe.each([Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_22])("%s", (protocol) => { const installed = clock.install(); const logged = spyOn(console, "debug"); const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room/x")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room/x")); + const broadcast = broadcastRoute.broadcast; const published = broadcast.createTrack("video"); published.appendGroup().writeFrame({ payload: new Uint8Array([1]) }); const { client, server } = await connect({ serverPublish: origin, protocol }); @@ -527,7 +525,9 @@ describe.each([Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_22])("%s", (protocol) => { try { const unanswered = await requests.next(); if (!unanswered) throw new Error("missing token"); - const track = new OriginProducer().createBroadcast(Path.from("room/x")).broadcast.createTrack("video"); + const track = new OriginProducer() + .route(Path.from("room/x"), { hidden: true }) + .broadcast.createTrack("video"); const reader = track.subscribe(); const ready = wireOf(client).auth.ready(Path.from("room/x"), "subscribe", { until: () => abandoned(track.demand()), @@ -552,9 +552,8 @@ describe.each([Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_22])("%s", (protocol) => { test("a subscribe abandoned while its token waits never reaches the wire", async () => { const logged = spyOn(console, "debug"); const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room/x")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room/x")); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("video"); const { client, server, transport } = await connect({ serverPublish: origin, protocol }); const requests = server.auth.requests(); @@ -591,9 +590,8 @@ describe.each([Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_22])("%s", (protocol) => { "a subscribe that regains a reader while its token waits keeps waiting (%d)", async (gap) => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room/x")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room/x")); + const broadcast = broadcastRoute.broadcast; const published = broadcast.createTrack("video"); published.appendGroup().writeFrame({ payload: new Uint8Array([7]) }); const { client, server } = await connect({ serverPublish: origin, protocol }); @@ -628,9 +626,8 @@ describe.each([Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_22])("%s", (protocol) => { test("a session's close is not a revocation of its subscriptions", async () => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room/x")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room/x")); + const broadcast = broadcastRoute.broadcast; broadcast .createTrack("video") .appendGroup() @@ -1020,9 +1017,8 @@ test("lite-07 ignores a draining session's late refusal while its successor retr test("a fetch abandoned while its token waits never reaches the wire", async () => { const logged = spyOn(console, "debug"); const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room/x")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room/x")); + const broadcast = broadcastRoute.broadcast; broadcast .createTrack("video") .appendGroup() @@ -1064,9 +1060,8 @@ test("a fetch abandoned while its token waits never reaches the wire", async () // The peer refuses a listing its token has not yet authorized, so the request waits for it. test("a listing waits for its token before reaching the wire", async () => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room/x")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room/x")); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("video"); const { client, server, transport } = await connect({ serverPublish: origin, protocol: Lite.ALPN_07_WIP }); const requests = server.auth.requests(); @@ -1102,9 +1097,8 @@ test.each(Array.from({ length: 17 }, (_, gap) => gap))( "a fetch that regains a caller while its token waits keeps waiting (%d)", async (gap) => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room/x")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room/x")); + const broadcast = broadcastRoute.broadcast; broadcast .createTrack("video") .appendGroup() @@ -1274,15 +1268,13 @@ test.each([ // moq-transport has no stream code for it, so only moq-lite resets with UNAUTHORIZED. test("a revoked grant resets its subscriptions with UNAUTHORIZED", async () => { const clientOrigin = new OriginProducer(); - const upPublication = clientOrigin.createBroadcast(Path.from("up/y")); - const up = upPublication.broadcast; - upPublication.announce(); + const upRoute = clientOrigin.route(Path.from("up/y")); + const up = upRoute.broadcast; const upTrack = up.createTrack("video"); const serverOrigin = new OriginProducer(); - const downPublication = serverOrigin.createBroadcast(Path.from("room/x")); - const down = downPublication.broadcast; - downPublication.announce(); + const downRoute = serverOrigin.route(Path.from("room/x")); + const down = downRoute.broadcast; const downTrack = down.createTrack("video"); const { client, server } = await connect({ diff --git a/js/net/src/broadcast.ts b/js/net/src/broadcast.ts index c45a2a6ba25..3f8668384cc 100644 --- a/js/net/src/broadcast.ts +++ b/js/net/src/broadcast.ts @@ -6,7 +6,6 @@ import { type GetPromise, Once, Signal } from "@moq/signals"; import { NotFound, StreamCode, StreamError, toStreamCode } from "./error.ts"; import type { Consumer as GroupConsumer } from "./group.ts"; -import type { Route } from "./hop.ts"; import type * as Instance from "./instance.ts"; import { hooks } from "./internal.ts"; import { Listing, listTracks, makeLister, type Tracks } from "./listing.ts"; @@ -17,17 +16,6 @@ import { registerWire, trackOf } from "./wire.ts"; export { Tracks, type TracksEvent } from "./listing.ts"; -/** The origin callback a created broadcast uses to advertise its exact path. @internal */ -export interface Announcer { - /** Advertise or re-price this broadcast's path. */ - announce(route: Route): void; - /** Retract the advertisement from local consumers and peers alike. */ - unannounce(): void; - /** The route this broadcast's path is advertised with, if it is. */ - route(): Route | undefined; -} - -let attachAnnouncer: (producer: Producer, announcer: Announcer) => void; let stampProducer: (producer: Producer, path: Path.Valid) => void; // Info lookups pending or held on a track. @@ -311,7 +299,6 @@ function adopt(state: BroadcastState, producer: track.Producer, info: track.Info */ export class Producer { #state = new BroadcastState(); - #announcer?: Announcer; #path = Path.empty(); constructor() { @@ -327,11 +314,6 @@ export class Producer { } static { - attachAnnouncer = (producer, announcer) => { - producer.#announcer = announcer; - }; - hooks.attachAnnouncer = attachAnnouncer; - hooks.onClosed = (producer, fn) => { const closers = producer.#state.closers; closers.add(fn); @@ -408,10 +390,8 @@ export class Producer { return trackOf(name, this); } - /** End the broadcast for good: retract its route and serve no new tracks. Idempotent. */ + /** End the broadcast for good: serve no new tracks. Idempotent. */ close(): void { - this.#announcer?.unannounce(); - this.#announcer = undefined; closeState(this.#state); } } diff --git a/js/net/src/connection/close.test.ts b/js/net/src/connection/close.test.ts index fc4dbb53761..1ac1e3d17ee 100644 --- a/js/net/src/connection/close.test.ts +++ b/js/net/src/connection/close.test.ts @@ -57,9 +57,8 @@ for (const protocol of [Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_18]) { const fin = holdFin(pair.server); const source = new Producer(); const destination = new Producer(); - const broadcastPublication = source.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = source.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const url = new URL("https://localhost/test"); const [client, server] = await Promise.all([ connect({ url, transport: pair.client, consume: destination }), diff --git a/js/net/src/connection/forward.test.ts b/js/net/src/connection/forward.test.ts index e53f77a50cd..3c06b59bfac 100644 --- a/js/net/src/connection/forward.test.ts +++ b/js/net/src/connection/forward.test.ts @@ -3,7 +3,7 @@ import { type Installed, Manual, Milli, Nano } from "@moq/clock"; import * as Announce from "../announced.ts"; import { AuthSession } from "../auth_session.ts"; import { type Consumer as BroadcastConsumer, Producer as BroadcastProducer } from "../broadcast.ts"; -import { Route } from "../hop.ts"; +import { RouteInfo } from "../hop.ts"; import * as Instance from "../instance.ts"; import { Producer as OriginProducer } from "../origin.ts"; import * as Path from "../path.ts"; @@ -132,7 +132,7 @@ class FakeSession { } } -function start(stream: Announce.Producer, prefix: string, route: Route = Route.default) { +function start(stream: Announce.Producer, prefix: string, route: RouteInfo = RouteInfo.default) { stream.append({ prefix: Path.from(prefix), captures: undefined, kind: "start", route }); } @@ -411,12 +411,12 @@ for (const [name, instances] of [ const narrow = origin.announced(Path.Pattern.subtree(Path.from("a/b"))); await settle(); - start(session.stream("a/b/**"), "a/b/x", { ...Route.default, instance: instances[0] }); + start(session.stream("a/b/**"), "a/b/x", { ...RouteInfo.default, instance: instances[0] }); await settle(); const broad = origin.announced(Path.Pattern.subtree(Path.from("a"))); const events = record(broad); await settle(); - start(session.stream("a/**"), "a/b/x", { ...Route.default, instance: instances[1] }); + start(session.stream("a/**"), "a/b/x", { ...RouteInfo.default, instance: instances[1] }); await settle(); expect(events).toEqual(["start a/b/x"]); diff --git a/js/net/src/connection/forward.ts b/js/net/src/connection/forward.ts index b93b9f55bad..b20b0158f09 100644 --- a/js/net/src/connection/forward.ts +++ b/js/net/src/connection/forward.ts @@ -7,12 +7,12 @@ import { Milli, Nano } from "@moq/clock"; import { type Dispose, race } from "@moq/signals"; import type * as Announce from "../announced.ts"; -import { type Route, routesEqual } from "../hop.ts"; +import { type RouteInfo, routesEqual } from "../hop.ts"; import { coveringPrefixes } from "../internal.ts"; -import type { Producer as OriginProducer, RequestSlot, Requests } from "../origin.ts"; +import type { Producer as OriginProducer, Route } from "../origin.ts"; import * as Path from "../path.ts"; import { after } from "../util/timer.ts"; -import { wireOf } from "../wire.ts"; +import { type RequestSlot, wireOf } from "../wire.ts"; import type { Established } from "./established.ts"; /** Why a connection refuses the removed `discovery` option rather than ignoring it. */ @@ -39,9 +39,9 @@ interface Interest { * request handing over to another never retracts it. The first reporter drives it. */ interface Reported { - handle: Requests; + handle: Route; /** Each request's latest route for the prefix. */ - readonly reporters: Map; + readonly reporters: Map; } /** @@ -118,16 +118,17 @@ export function forwardAnnounced(conn: Established, origin: OriginProducer): voi * instance, so nothing resolved through the old one is joined again, and an in-place * update otherwise. */ - const updateReported = (existing: Reported, prefix: Path.Valid, route: Route, restart: boolean) => { - if (restart || route.epoch !== existing.handle.route.epoch) { + const updateReported = (existing: Reported, prefix: Path.Valid, route: RouteInfo, restart: boolean) => { + const current = wireOf(existing.handle).info; + if (restart || route.epoch !== current?.epoch) { // Inserted before the old one leaves, so local readers see one restart rather than // an end and a start. const handle = originWire.receive(prefix, route); existing.handle.close(); existing.handle = handle; void drive(handle, conn); - } else if (!routesEqual(existing.handle.route, route)) { - existing.handle.updateRoute(route); + } else if (!routesEqual(current, route)) { + wireOf(existing.handle).update(route); } }; @@ -289,7 +290,7 @@ export function forwardAnnounced(conn: Established, origin: OriginProducer): voi } /** Answer the requests under a received route by consuming them from the session. */ -async function drive(handle: Requests, conn: Established): Promise { +async function drive(handle: Route, conn: Established): Promise { const session = wireOf(conn); try { for await (const request of handle.requested()) { diff --git a/js/net/src/connection/migrate.test.ts b/js/net/src/connection/migrate.test.ts index 0eaef291ca2..eede71cf3e2 100644 --- a/js/net/src/connection/migrate.test.ts +++ b/js/net/src/connection/migrate.test.ts @@ -79,9 +79,8 @@ test("an empty GOAWAY migrates the follower to the replacement session", async ( const clock = new Manual(); const installed = clock.install(); const { dials, origin } = fleet(); - const broadcastPublication = origin.createBroadcast(Path.from("cam")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("cam")); + const broadcast = broadcastRoute.broadcast; const consume = new OriginProducer(); const reload = new Reload({ diff --git a/js/net/src/connection/pool.test.ts b/js/net/src/connection/pool.test.ts index f849baf5145..b129c57db12 100644 --- a/js/net/src/connection/pool.test.ts +++ b/js/net/src/connection/pool.test.ts @@ -13,11 +13,8 @@ import { type AcceptProps, accept as acceptSession } from "./index.ts"; import { Connection, resetShared } from "./pool.ts"; import { Reload } from "./reload.ts"; -function publish(origin: Pick, path: Path.Valid) { - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); - return broadcast; +function publish(origin: Pick, path: Path.Valid) { + return origin.route(path).broadcast; } const url = new URL("https://example.com/pool"); @@ -262,7 +259,7 @@ test("a borrowed connection origin exposes live routes and dynamic serving", asy announcement = event; }); const prefix = Path.from("on-demand"); - const route = table.requestsRoute(prefix); + const route = table.routePrefix(prefix); await advance(); expect(announcement).toMatchObject({ kind: "start", prefix }); let withdrawal: unknown; diff --git a/js/net/src/connection/reload.test.ts b/js/net/src/connection/reload.test.ts index 5adcd6e91c8..e2ae7a7d73d 100644 --- a/js/net/src/connection/reload.test.ts +++ b/js/net/src/connection/reload.test.ts @@ -4,7 +4,7 @@ import { Effect, Signal } from "@moq/signals"; import * as Announce from "../announced.ts"; import type { Producer as BroadcastProducer } from "../broadcast.ts"; import { ConnectTimeout, SessionCode, SessionError, StreamCode, toTransport } from "../error.ts"; -import { Route } from "../hop.ts"; +import { RouteInfo } from "../hop.ts"; import { ALPN as IetfALPN } from "../ietf/version.ts"; import * as Lite from "../lite/index.ts"; import { createMockTransportPair, type MockTransport, textFrame } from "../mock.ts"; @@ -24,9 +24,8 @@ function accept(transport: WebTransport, url: URL, props: Omit handle.origin.peek() !== undefined); const origin = handle.origin.peek(); if (!origin) throw new Error("no origin"); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); await waitUntil(() => dials.length > 0); const first = dials[0]; @@ -826,9 +824,8 @@ for (const [name, drainEnd] of Object.entries(drainEnds)) { globalThis.WebTransport = stub as unknown as typeof WebTransport; const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const reload = new Reload({ url: new URL("https://example.com/a"), @@ -887,9 +884,8 @@ test("a retired GOAWAY predecessor still closes by its handover cap", async () = globalThis.WebTransport = stub as unknown as typeof WebTransport; const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const reload = new Reload({ url: new URL("https://example.com/"), @@ -971,9 +967,8 @@ test("closing the loop keeps the tokens until the session drains", async () => { const origin = new OriginProducer(); const reload = new Reload({ url, websocket: { enabled: false }, publish: origin.consume() }); await reload.auth.add("token"); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const first = dials[0]; if (!first) throw new Error("no first dial"); @@ -1025,7 +1020,7 @@ test("closing an announce consumer during upstream teardown does not append retr prefix: Path.from("alice/camera.hang"), captures: undefined, kind: "start", - route: Route.default, + route: RouteInfo.default, }); await consumer.next(); upstream.close(); @@ -1131,7 +1126,7 @@ test("a pump owes the retractions of the upstream it replaces", async () => { const consumer = producer.consume(); const first = new Announce.Producer(); - first.append({ prefix: Path.from("a"), captures: undefined, kind: "start", route: Route.default }); + first.append({ prefix: Path.from("a"), captures: undefined, kind: "start", route: RouteInfo.default }); first.synced(); const upstream = new Signal(first); const pump = new Effect((effect) => pumpAnnounced(effect, effect.get(upstream).consume(), producer)); diff --git a/js/net/src/connection/scope.test.ts b/js/net/src/connection/scope.test.ts index c4d8e4fe784..d2d878aaba7 100644 --- a/js/net/src/connection/scope.test.ts +++ b/js/net/src/connection/scope.test.ts @@ -22,9 +22,8 @@ for (const protocol of [Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_18]) { new Path.Patterns(["room/**", "other/**"].map(Path.Pattern.parse)), ); const broadcasts = ["room/live", "room/.hidden", "other/live", "outside"].map((path) => { - const broadcastPublication = publish.createBroadcast(Path.from(path)); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = publish.route(Path.from(path)); + const broadcast = broadcastRoute.broadcast; return broadcast; }); const [client, server] = await Promise.all([ diff --git a/js/net/src/consume.test.ts b/js/net/src/consume.test.ts index 562ff925d99..04a42fa4f34 100644 --- a/js/net/src/consume.test.ts +++ b/js/net/src/consume.test.ts @@ -2,7 +2,7 @@ import { expect, test } from "bun:test"; import { Producer } from "./broadcast.ts"; import { BroadcastCache } from "./consume.ts"; import { StreamCode, StreamError } from "./error.ts"; -import { Route } from "./hop.ts"; +import { RouteInfo } from "./hop.ts"; import * as Instance from "./instance.ts"; import * as Path from "./path.ts"; @@ -13,16 +13,16 @@ test("cache identity follows the serving announcement, preserving held tracks", const broad = {}; const specific = {}; const instance = Instance.random(); - cache.announce(pool, broad, { ...Route.default, instance }); + cache.announce(pool, broad, { ...RouteInfo.default, instance }); const source = new Producer(); const track = source.createTrack("video"); const held = cache.insert(job, cache.instance(job), source.consume()); const ordered = held.track("video").subscribe().ordered(); - cache.announce(job, specific, { ...Route.default, instance }); + cache.announce(job, specific, { ...RouteInfo.default, instance }); const same = cache.get(job, cache.instance(job)); expect(same?.closed).toBe(held.closed); - cache.announce(job, specific, Route.default, true); + cache.announce(job, specific, RouteInfo.default, true); expect(cache.instance(job).route.instance).toBeUndefined(); expect(cache.get(job, cache.instance(job))).toBeUndefined(); const replacement = new Producer(); @@ -46,7 +46,7 @@ test("withdrawing one interest keeps another interest's explicit identity", () = const path = Path.from("room"); const first = {}; const second = {}; - const route = { ...Route.default, instance: Instance.random() }; + const route = { ...RouteInfo.default, instance: Instance.random() }; cache.announce(path, first, route); cache.announce(path, second, route); const source = new Producer(); @@ -70,7 +70,7 @@ test("an announcement lifecycle retires a blind cache without disturbing unrelat const held = cache.insert(path, cache.instance(path), source.consume()); const otherHeld = cache.insert(other, cache.instance(other), unrelated.consume()); const owner = {}; - cache.announce(Path.from("pool"), owner, Route.default); + cache.announce(Path.from("pool"), owner, RouteInfo.default); cache.withdraw(Path.from("pool"), owner); expect(cache.get(path, cache.instance(path))).toBeUndefined(); const same = cache.get(other, cache.instance(other)); @@ -87,10 +87,10 @@ test.each([false, true])("route alternation reuses every held instance (instance const broad = Path.from("pool"); const ownerA = {}; const ownerB = {}; - cache.announce(broad, ownerA, { ...Route.default, instance: explicit ? Instance.random() : undefined }); + cache.announce(broad, ownerA, { ...RouteInfo.default, instance: explicit ? Instance.random() : undefined }); const a = new Producer(); const heldA = cache.insert(path, cache.instance(path), a.consume()); - cache.announce(path, ownerB, { ...Route.default, instance: explicit ? Instance.random() : undefined }); + cache.announce(path, ownerB, { ...RouteInfo.default, instance: explicit ? Instance.random() : undefined }); const b = new Producer(); const heldB = cache.insert(path, cache.instance(path), b.consume()); cache.withdraw(path, ownerB); @@ -107,13 +107,13 @@ test("request validity cancels one selection period and permits the held fallbac const broad = Path.from("pool"); const a = {}; const b = {}; - cache.announce(broad, a, Route.default); + cache.announce(broad, a, RouteInfo.default); const sourceA = new Producer(); const instanceA = cache.instance(path); const heldA = cache.insert(path, instanceA, sourceA.consume()); const first = instanceA.validity?.signal; expect(first?.aborted).toBe(false); - cache.announce(path, b, Route.default); + cache.announce(path, b, RouteInfo.default); expect(first?.aborted).toBe(true); // A more specific route taking over ends the old instance's requests the way Rust does, so // players treat it as the instance going offline rather than an unexpected failure. @@ -142,16 +142,16 @@ test("request validity follows the selected interest and ignores unrelated withd const broad = {}; const first = {}; const second = {}; - cache.announce(Path.from("pool"), broad, Route.default); - cache.announce(path, first, Route.default); - cache.announce(path, second, Route.default); + cache.announce(Path.from("pool"), broad, RouteInfo.default); + cache.announce(path, first, RouteInfo.default); + cache.announce(path, second, RouteInfo.default); const source = new Producer(); const instance = cache.instance(path); const held = cache.insert(path, instance, source.consume()); const signal = instance.validity?.signal; cache.withdraw(Path.from("pool"), broad); cache.withdraw(path, second); - cache.announce(path, first, { ...Route.default, cost: 1n }); + cache.announce(path, first, { ...RouteInfo.default, cost: 1n }); expect(instance.validity?.signal).toBe(signal); expect(signal?.aborted).toBe(false); cache.withdraw(path, first); @@ -167,7 +167,7 @@ test("a blind selection retires on discovery while explicit instances need no pa const source = new Producer(); const held = cache.insert(path, blind, source.consume()); const owner = {}; - cache.announce(Path.from("pool"), owner, { ...Route.default, instance: Instance.random() }); + cache.announce(Path.from("pool"), owner, { ...RouteInfo.default, instance: Instance.random() }); expect(blind.validity?.signal.aborted).toBe(true); expect(cache.instance(path).validity).toBeUndefined(); cache.withdraw(Path.from("pool"), owner); diff --git a/js/net/src/consume.ts b/js/net/src/consume.ts index 3e19f1159dd..86b89c379c3 100644 --- a/js/net/src/consume.ts +++ b/js/net/src/consume.ts @@ -1,6 +1,6 @@ import type * as broadcast from "./broadcast.ts"; import { StreamCode, StreamError } from "./error.ts"; -import type { Route } from "./hop.ts"; +import type { RouteInfo } from "./hop.ts"; import * as Instance from "./instance.ts"; import { compareRouteCandidates, coveringPrefixes, Epochs } from "./internal.ts"; import type * as Path from "./path.ts"; @@ -52,13 +52,13 @@ export class BroadcastCache { Path.Valid, Map >(); - #announced = new Map>(); + #announced = new Map>(); #blind = new Map(); #blindPrefixes = new Map>(); #paths = new Map>(); /** Record this interest's live advertisement, preserving identity across route updates. */ - announce(path: Path.Valid, owner: object, route: Route, restart = false): void { + announce(path: Path.Valid, owner: object, route: RouteInfo, restart = false): void { // Only unannounced consumers covered by this advertisement lose their blind identity. for (const covered of this.#blindPrefixes.get(path) ?? []) this.#forgetBlind(covered); let entries = this.#announced.get(path); @@ -84,7 +84,7 @@ export class BroadcastCache { for (const prefix of coveringPrefixes(path)) { const entries = this.#announced.get(prefix); if (!entries) continue; - let best: { identity: object; route: Route } | undefined; + let best: { identity: object; route: RouteInfo } | undefined; const epochs = new Epochs([...entries.values()].map((entry) => entry.route)); for (const entry of entries.values()) { if (epochs.supersedes(entry.route)) continue; diff --git a/js/net/src/fill.test.ts b/js/net/src/fill.test.ts index d1b17886121..f4b64878d3f 100644 --- a/js/net/src/fill.test.ts +++ b/js/net/src/fill.test.ts @@ -750,8 +750,7 @@ async function session(alpn: string) { connectSession({ url, transport: pair.client }), acceptSession({ transport: pair.server, url, publish: origin.consume() }), ]); - const publication = origin.createBroadcast(Path.from("archive")); - publication.announce(); + const publication = origin.route(Path.from("archive")); const broadcast = publication.broadcast; const track = broadcast.createTrack("video", { timescale: Timescale.MILLI }); // Groups 0 to 2 were published before this producer existed. diff --git a/js/net/src/goaway-requests.test.ts b/js/net/src/goaway-requests.test.ts index 7bebb5f4ef9..87ec8c4d994 100644 --- a/js/net/src/goaway-requests.test.ts +++ b/js/net/src/goaway-requests.test.ts @@ -107,9 +107,8 @@ async function handover(kind: "lite" | "ietf"): Promise { const consume = new OriginProducer(); const publish = new OriginProducer(); - const broadcastPublication = publish.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = publish.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const served: TrackProducer[] = []; let armVideo = true; @@ -297,9 +296,8 @@ async function routeDeath(kind: "lite" | "ietf", after: boolean): Promise const consume = new OriginProducer(); const publish = new OriginProducer(); - const broadcastPublication = publish.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = publish.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const served: TrackProducer[] = []; const serving = (async () => { diff --git a/js/net/src/group-id.test.ts b/js/net/src/group-id.test.ts index 812c4aba7ef..8581126e2c9 100644 --- a/js/net/src/group-id.test.ts +++ b/js/net/src/group-id.test.ts @@ -76,11 +76,10 @@ for (const wire of WIRES) { ]); const path = Path.from("big"); - const publication = source.createBroadcast(path); - publication.announce(); + const publication = source.route(path); const track = publication.broadcast.createTrack("video"); - const dynamic = relay.requestsRoute(path); + const dynamic = relay.routePrefix(path); const inputs: BroadcastConsumer[] = []; const forwarding = (async () => { for await (const request of dynamic.requested()) { diff --git a/js/net/src/hop.ts b/js/net/src/hop.ts index 2319ebcbfb8..d01492d599b 100644 --- a/js/net/src/hop.ts +++ b/js/net/src/hop.ts @@ -89,59 +89,48 @@ export const Cost = { }; /** - * The path a route took through the mesh and what using it costs. + * The stream a received route serves, the path it took through the mesh, and what using it + * costs: read-only facts on an announcement. Mirrors `RouteInfo` in rs/moq-net. * - * The metadata half of an advertisement: an origin `requests()` pairs it with the - * pattern it covers, a broadcast `announce()` with the broadcast's exact path, and - * an announce event carries it so consumers can read it back. + * Carried by an announce event. Applications never build one: an origin `Route` takes + * `RouteOptions`, and the origin and the relays fill in the rest. */ -export interface Route { +export interface RouteInfo { /** * The stream the route serves: routes with one instance serve one continuous sequence - * space, so a subscription resumes from one to another. Changing it on a standing - * advertisement is a restart. Always set on a route the origin delivers; given to an - * announcing handle, unset keeps the instance its route already has, a fresh random one - * minted when the handle was made. Mirrors `Route::instance` in rs/moq-net. - * - * Set one only for a publisher that continues its group sequences across restarts and - * raises {@link epoch} on each: readers stitch every route of one instance together, so - * restarting the sequences under an old instance splices unrelated groups into their tracks. - * Do not start a named instance with `~`: that marks one a relay minted (see - * {@link Instance.isMinted}), which signing refuses to bind and a catalog's instance check - * skips. The mark is not refused, since a relay forwarding a route keeps the one it received. + * space, so a subscription resumes from one to another. Always set on a route the origin + * delivers; pass it to an origin `request` to pin this stream. */ - instance?: Instance.Valid; + readonly instance?: Instance.Valid; /** * Which incarnation of {@link instance} this is: among its routes at one prefix only the - * highest epoch is eligible, cheaper or not. Never compared across instances. Ignored - * without an instance. + * highest epoch is eligible, cheaper or not. Never compared across instances. */ - epoch?: bigint; - /** The chain of hops the route has traversed, oldest first. */ - hops: Hop[]; + readonly epoch?: bigint; + /** + * The chain of hops the route has traversed, oldest first. A 0 entry is the anonymous mark; + * see {@link isAnonymous}. A route announced on this origin has none. + */ + readonly hops: readonly Hop[]; /** What pulling content via this route costs; lower wins. */ - cost: Cost; + readonly cost: Cost; /** * The token the request advertising this route carries, from `auth.add()`, or undefined * for the session's own credential. Only the session that issued it carries it, as the * token on its moq-transport PUBLISH_NAMESPACE: any other session, the inline NAMESPACE * answering a solicited SUBSCRIBE_NAMESPACE, and moq-lite advertise the route unnamed. - * Swapping it renews the request with REQUEST_UPDATE. Local: a relay never forwards it. Mirrors `Route::auth` in rs/moq-net. + * Swapping it renews the request with REQUEST_UPDATE. Local: a relay never forwards it. */ - auth?: Credential; + readonly auth?: Credential; } -/** Constructors and helpers for {@link Route}. */ -export const Route = { +/** Constructors and helpers for {@link RouteInfo}. @internal */ +export const RouteInfo = { /** An empty hop chain at zero cost: what a publisher seeds for a live broadcast. */ - default: { hops: [], cost: Cost.zero } as Route, + default: { hops: [], cost: Cost.zero } as RouteInfo, /** Fill route defaults and saturate the static price at the wire ceiling. */ - normalize( - route: - | Route - | { instance?: Instance.Valid; epoch?: bigint; hops?: readonly Hop[]; cost?: Cost; auth?: Credential } = {}, - ): Route { + normalize(route: Partial = {}): RouteInfo { const cost = route.cost ?? Cost.zero; if (typeof cost !== "bigint" || cost < 0n) throw new RangeError("route cost must be a non-negative bigint"); const max = 2n ** 62n - 1n; @@ -162,12 +151,12 @@ export const Route = { * An empty chain is a local announcement, not the anonymous mark. Ingress fills a * received empty list with the anonymous hop before yielding it. */ -export function isAnonymous(route: Route): boolean { +export function isAnonymous(route: RouteInfo): boolean { return route.hops.includes(UNKNOWN_HOP); } /** Whether two routes name the same instance, epoch, hop chain, cost, and auth. */ -export function routesEqual(a: Route | undefined, b: Route | undefined): boolean { +export function routesEqual(a: RouteInfo | undefined, b: RouteInfo | undefined): boolean { if (a === b) return true; if (!a || !b) return false; return ( diff --git a/js/net/src/ietf/connection.test.ts b/js/net/src/ietf/connection.test.ts index e70ec2dfe06..5156b07ef7e 100644 --- a/js/net/src/ietf/connection.test.ts +++ b/js/net/src/ietf/connection.test.ts @@ -162,7 +162,7 @@ test("SUBSCRIBE_NAMESPACE gets the published namespaces", async () => { const pair = createMockTransportPair(ALPN.DRAFT_18); const control = await Stream.open(pair.server, { version }); const origin = new OriginProducer(); - origin.createBroadcast(Path.from("room")).announce(); + origin.route(Path.from("room"), { hidden: true }).announce(); const connection = new Connection({ url: new URL("https://example.com"), quic: pair.server, @@ -397,9 +397,8 @@ for (const [version, alpn] of [[Version.DRAFT_22, ALPN.DRAFT_22]] as const) { const pair = createMockTransportPair(alpn); const control = await Stream.open(pair.server, { version }); const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("video", { timescale: Timescale.MILLI }); const connection = new Connection({ url: new URL("https://example.com"), @@ -433,9 +432,8 @@ async function serving(version: IetfVersion, alpn: string) { const pair = createMockTransportPair(alpn); const control = await Stream.open(pair.server, { version }); const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("video", { timescale: Timescale.MILLI }); const connection = new Connection({ url: new URL("https://example.com"), diff --git a/js/net/src/ietf/fetch.test.ts b/js/net/src/ietf/fetch.test.ts index cd3ae2921ea..00c4f7e0e98 100644 --- a/js/net/src/ietf/fetch.test.ts +++ b/js/net/src/ietf/fetch.test.ts @@ -46,8 +46,7 @@ function serve(version: IetfVersion, grant?: Signal, priority requiresSolicitation: false, grant, }); - const publication = origin.createBroadcast(Path.from("room")); - publication.announce(); + const publication = origin.route(Path.from("room")); const track = publication.broadcast.createTrack("video", { timescale: Timescale.MILLI, priority }); const uni = pair.client.incomingUnidirectionalStreams.getReader() as ReadableStreamDefaultReader< ReadableStream diff --git a/js/net/src/ietf/goaway.test.ts b/js/net/src/ietf/goaway.test.ts index c93c19eb45d..cf90c588c46 100644 --- a/js/net/src/ietf/goaway.test.ts +++ b/js/net/src/ietf/goaway.test.ts @@ -235,7 +235,7 @@ for (const [version, alpn] of [ const control = await Stream.open(pair.server, { version }); await Stream.accept(pair.client, version); const origin = new OriginProducer(); - origin.createBroadcast(Path.from("room")).announce(); + origin.route(Path.from("room"), { hidden: true }).announce(); const connection = new Connection({ url: new URL("https://relay.example/"), quic: pair.server, @@ -265,7 +265,7 @@ for (const [version, alpn] of [ const control = await Stream.open(pair.server, { version }); await Stream.accept(pair.client, version); const origin = new OriginProducer(); - origin.createBroadcast(Path.from("room")).announce(); + origin.route(Path.from("room"), { hidden: true }).announce(); const connection = new Connection({ url: new URL("https://relay.example/"), quic: pair.server, diff --git a/js/net/src/ietf/join.test.ts b/js/net/src/ietf/join.test.ts index 9cb0a6563bf..2498f5dddb6 100644 --- a/js/net/src/ietf/join.test.ts +++ b/js/net/src/ietf/join.test.ts @@ -585,8 +585,7 @@ async function publishing(version: IetfVersion) { server.abort(); }); - const publication = origin.createBroadcast(Path.from("room")); - publication.announce(); + const publication = origin.route(Path.from("room")); const broadcast = publication.broadcast; // Written once, before anyone subscribed, and left open: only the head can deliver it. const catalog = broadcast.createTrack("catalog.json", { timescale: Timescale.MILLI }); diff --git a/js/net/src/ietf/malformed.test.ts b/js/net/src/ietf/malformed.test.ts index 0382758948f..19bf77af8d2 100644 --- a/js/net/src/ietf/malformed.test.ts +++ b/js/net/src/ietf/malformed.test.ts @@ -57,9 +57,8 @@ async function serving(version: IetfVersion, alpn: string) { const pair = createMockTransportPair(alpn); const control = await Stream.open(pair.server, { version }); const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("video", { timescale: Timescale.MILLI }); const connection = new Connection({ url: new URL("https://example.com"), diff --git a/js/net/src/ietf/publisher.test.ts b/js/net/src/ietf/publisher.test.ts index a4d14dac0d9..99a95b1d801 100644 --- a/js/net/src/ietf/publisher.test.ts +++ b/js/net/src/ietf/publisher.test.ts @@ -43,9 +43,8 @@ import { TrackStatusOk, TrackStatusRequest } from "./track.ts"; import { ALPN, type IetfVersion, Version } from "./version.ts"; function publish(origin: OriginProducer, path: Path.Valid) { - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(path); + const broadcast = broadcastRoute.broadcast; return broadcast; } @@ -296,7 +295,7 @@ test("TRACK_STATUS finished at once is answered on every draft", async () => { const pair = createMockTransportPair(ALPNS[version]); const session = new NativeSession(pair.server, version, true); const { pub, origin } = publisher(pair.server, { session }); - const requests = origin.requestsRoute(Path.from("room")).requested(); + const requests = origin.routePrefix(Path.from("room")).requested(); // The FIN arrives while the broadcast still resolves. const { stream, wire, finish } = requestStream(version); @@ -342,7 +341,7 @@ test("TRACK_STATUS outside the grant is refused on every draft", async () => { const session = new NativeSession(pair.server, version, true); const grant = new Signal(nothing()); const { pub, origin } = publisher(pair.server, { session, grant }); - const requests = origin.requestsRoute(Path.from("room")).requested(); + const requests = origin.routePrefix(Path.from("room")).requested(); const outside = requestStream(version); await pub.runTrackStatusRequest(trackStatus("room"), outside.stream); @@ -369,7 +368,7 @@ test("a second GOAWAY on an unanswered SUBSCRIBE closes the session", async () = const pair = createMockTransportPair(ALPNS[version]); const session = new NativeSession(pair.server, version, true); const { pub, origin } = publisher(pair.server, { session }); - const requests = origin.requests(Path.from("room")).requested(); + const requests = origin.routePrefix(Path.from("room")).requested(); const held = requestStream(version); const task = pub.runSubscribe( @@ -427,7 +426,7 @@ test("a cancelled TRACK_STATUS releases its demand on every draft", async () => const pair = createMockTransportPair(ALPNS[version]); const session = new NativeSession(pair.server, version, true); const { pub, origin } = publisher(pair.server, { session }); - const requests = origin.requestsRoute(Path.from("room")).requested(); + const requests = origin.routePrefix(Path.from("room")).requested(); // The broadcast is still resolving: its handler never answers. const early = requestStream(version); @@ -479,7 +478,7 @@ test("a SUBSCRIBE withdrawn during setup releases its demand on every draft", as const pair = createMockTransportPair(ALPNS[version]); const session = new NativeSession(pair.server, version, true); const { pub, origin } = publisher(pair.server, { session }); - const requests = origin.requestsRoute(Path.from("room")).requested(); + const requests = origin.routePrefix(Path.from("room")).requested(); // The broadcast is still resolving: its handler never answers. const early = requestStream(version); @@ -646,7 +645,7 @@ test("reserved namespace requests get DOES_NOT_EXIST while other dot namespaces // Navigation segments cannot be published. A covering application // route still proves these reserved requests are refused before lookup. const navigation = path.split("/")[0] === "."; - const claim = navigation ? origin.requests(Path.empty()) : undefined; + const claim = navigation ? origin.routePrefix(Path.empty()) : undefined; const requested = claim?.requested().next(); const broadcast = navigation ? undefined : publish(origin, Path.from(path)); const track = broadcast?.createTrack("video", { timescale: Timescale.MILLI }); @@ -1155,7 +1154,7 @@ test("a subscription outside a covering route's claim does not hear it", async ( const pair = createMockTransportPair(ALPN.DRAFT_18); const { pub, origin } = publisher(pair.server, { requiresSolicitation: true }); const chat = origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.subtree(Path.from("room/chat"))])); - const dynamic = chat.requestsRoute(Path.from("room")); + const dynamic = chat.routePrefix(Path.from("room")); const subscription = await Stream.open(pair.client, { version: VERSION }); const accepted = await Stream.accept(pair.server, VERSION); @@ -1187,8 +1186,8 @@ test("a subscription hears the best covering route its claim allows", async () = const { pub, origin } = publisher(pair.server, { requiresSolicitation: true }); const scoped = (path: string) => origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.subtree(Path.from(path))])); - const chat = scoped("room/chat").requestsRoute(Path.from("room"), { cost: 1n }); - const video = scoped("room/video").requestsRoute(Path.from("room"), { cost: 5n }); + const chat = scoped("room/chat").routePrefix(Path.from("room"), { cost: 1n }); + const video = scoped("room/video").routePrefix(Path.from("room"), { cost: 5n }); const subscription = await Stream.open(pair.client, { version: VERSION }); const accepted = await Stream.accept(pair.server, VERSION); @@ -1228,8 +1227,8 @@ test("a subscription hears a broader covering route when the narrowest cannot se }); const chat = origin .scope(Path.empty(), new Path.Patterns([Path.Pattern.subtree(Path.from("tenant/chat"))])) - .requestsRoute(Path.from("tenant")); - const broad = origin.requestsRoute(Path.empty(), { cost: 5n }); + .routePrefix(Path.from("tenant")); + const broad = origin.routePrefix(Path.empty(), { cost: 5n }); const subscription = await Stream.open(pair.client, { version: VERSION }); const accepted = await Stream.accept(pair.server, VERSION); @@ -1266,7 +1265,7 @@ test("a covering route's claim is compared relative to the served root", async ( requiresSolicitation: true, }); const chat = origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.subtree(Path.from("tenant/room/chat"))])); - const dynamic = chat.requestsRoute(Path.from("tenant/room")); + const dynamic = chat.routePrefix(Path.from("tenant/room")); const subscription = await Stream.open(pair.client, { version: VERSION }); const accepted = await Stream.accept(pair.server, VERSION); @@ -1350,8 +1349,7 @@ test("a new instance at the same path clears a refusal", async () => { const pair = createMockTransportPair(ALPN.DRAFT_18); const { pub, origin } = publisher(pair.server); - const broadcast = origin.createBroadcast(Path.from("restarted")); - broadcast.announce({ instance: Instance.random() }); + const broadcast = origin.route(Path.from("restarted"), { instance: Instance.random() }); void pub.runPublishNamespaces(); @@ -1361,7 +1359,7 @@ test("a new instance at the same path clears a refusal", async () => { await declinePublishNamespace(declined, 0n); await sleep(Nano.fromMilli(Milli(SETTLE))); - broadcast.announce({ ...broadcast.route, instance: Instance.random() }); + wireOf(broadcast).update({ ...wireOf(broadcast).info, instance: Instance.random() }); const retried = await nextStream(pair.client); if (!retried) throw new Error("the new instance was never offered"); @@ -1562,18 +1560,18 @@ const OTHER: Hop = HopSchema.parse(5n); test("a price change on a held namespace is one REQUEST_UPDATE, not a withdrawal", async () => { const { clock, self, pub, origin, streams, close } = clustered(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n }); void pub.runPublishNamespaces(); const stream = await take(clock, streams); expect(await acceptClustered(stream)).toEqual({ hops: [VIA, self], cost: 4n }); - broadcast.announce({ hops: [VIA], cost: 8n }); + wireOf(broadcast).update({ hops: [VIA], cost: 8n }); expect(await readUpdate(stream)).toEqual({ hops: undefined, cost: 8n }); await acceptPublishNamespace(stream); - broadcast.announce({ hops: [VIA], cost: 0n }); + wireOf(broadcast).update({ hops: [VIA], cost: 0n }); expect(await readUpdate(stream)).toEqual({ hops: undefined, cost: 0n }); await acceptPublishNamespace(stream); @@ -1590,14 +1588,14 @@ test("a price change on a held namespace is one REQUEST_UPDATE, not a withdrawal test("a hop path change behind the same publisher is one REQUEST_UPDATE carrying HOP_PATH", async () => { const { clock, self, pub, origin, streams, close } = clustered(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n }); void pub.runPublishNamespaces(); const stream = await take(clock, streams); await acceptClustered(stream); - broadcast.announce({ hops: [VIA, MID], cost: 4n }); + wireOf(broadcast).update({ hops: [VIA, MID], cost: 4n }); expect(await readUpdate(stream)).toEqual({ hops: [VIA, MID, self], cost: undefined }); await acceptPublishNamespace(stream); @@ -1620,8 +1618,8 @@ test.each([ ] as const)("a solicited namespace takes %s as one NAMESPACE and no NAMESPACE_DONE", async (_, hops, cost) => { const { clock, self, pair, pub, origin, close } = clustered(true); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n }); const subscription = await Stream.open(pair.client, { version: VERSION }); const stream = await Stream.accept(pair.server, VERSION); @@ -1640,7 +1638,7 @@ test.each([ params: { cluster: { hops: [VIA, self], cost: 4n } }, }); - broadcast.announce({ hops: [...hops], cost }); + wireOf(broadcast).update({ hops: [...hops], cost }); expect(await entry()).toMatchObject({ suffix: Path.from("mine"), params: { cluster: { hops: [...hops, self], cost } }, @@ -1662,14 +1660,14 @@ test.each([ test("a first-hop change is one REQUEST_UPDATE carrying HOP_PATH, not a withdrawal", async () => { const { clock, self, pub, origin, streams, close } = clustered(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n }); void pub.runPublishNamespaces(); const stream = await take(clock, streams); await acceptClustered(stream); - broadcast.announce({ hops: [OTHER], cost: 4n }); + wireOf(broadcast).update({ hops: [OTHER], cost: 4n }); expect(await readUpdate(stream)).toEqual({ hops: [OTHER, self], cost: undefined }); await acceptPublishNamespace(stream); @@ -1684,8 +1682,8 @@ test("a first-hop change is one REQUEST_UPDATE carrying HOP_PATH, not a withdraw /** A different broadcast is not an update: it withdraws the old one and advertises again. */ function republish(origin: OriginProducer, old: BroadcastProducer) { - const next = origin.createBroadcast(Path.from("mine")); - next.announce({ hops: [VIA], cost: 4n }); + const next = origin.route(Path.from("mine"), { hidden: true }); + wireOf(next).update({ hops: [VIA], cost: 4n }); old.close(); } @@ -1749,15 +1747,15 @@ test("swapping a route's token is one REQUEST_UPDATE carrying it", async () => { const { clock, pub, origin, streams, close } = clustered(false, tokens); const { sent, restore } = carriedTokens(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n, auth: tokens.issue("first") }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n, auth: tokens.issue("first") }); void pub.runPublishNamespaces(); const stream = await take(clock, streams); await acceptClustered(stream); expect(sent).toEqual(["first"]); - broadcast.announce({ hops: [VIA], cost: 4n, auth: tokens.issue("second") }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n, auth: tokens.issue("second") }); expect(await readUpdate(stream)).toEqual({ hops: undefined, cost: undefined }); await acceptPublishNamespace(stream); expect(sent).toEqual(["first", "second"]); @@ -1774,13 +1772,13 @@ test("a foreign route token is not carried", async () => { const { clock, pub, origin, streams, close } = clustered(false, new Tokens()); const { sent, restore } = carriedTokens(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n, auth: foreign.issue("first") }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n, auth: foreign.issue("first") }); void pub.runPublishNamespaces(); const stream = await take(clock, streams); await acceptClustered(stream); - broadcast.announce({ hops: [VIA], cost: 4n, auth: foreign.issue("second") }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n, auth: foreign.issue("second") }); const more = watch(stream.reader.u53()); await clock.advance(Nano.zero); expect(more.state).toBe("pending"); @@ -1797,13 +1795,13 @@ test("naming a token on an unnamed request makes it again", async () => { const { clock, pub, origin, streams, close } = clustered(false, tokens); const { sent, restore } = carriedTokens(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n }); void pub.runPublishNamespaces(); const old = await take(clock, streams); await acceptClustered(old); - broadcast.announce({ hops: [VIA], cost: 4n, auth: tokens.issue("first") }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n, auth: tokens.issue("first") }); expect(await old.reader.done().catch(error)).toMatchObject({ code: StreamCode.Cancel }); await acceptClustered(await take(clock, streams)); @@ -1820,9 +1818,9 @@ test("closing a route's token makes its request again without it", async () => { const { clock, pub, origin, streams, close } = clustered(false, tokens); const { sent, restore } = carriedTokens(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); const token = tokens.issue("first"); - broadcast.announce({ hops: [VIA], cost: 4n, auth: token }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n, auth: token }); void pub.runPublishNamespaces(); const old = await take(clock, streams); @@ -1841,9 +1839,9 @@ test("closing a route's token makes its request again without it", async () => { test("a republish withdraws the PUBLISH_NAMESPACE and advertises again", async () => { const { clock, pub, origin, streams, close } = clustered(); try { - const broadcastPublication = origin.createBroadcast(Path.from("mine")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce({ hops: [VIA], cost: 4n }); + const broadcastRoute = origin.route(Path.from("mine"), { hidden: true }); + const broadcast = broadcastRoute.broadcast; + wireOf(broadcastRoute).update({ hops: [VIA], cost: 4n }); void pub.runPublishNamespaces(); const old = await take(clock, streams); @@ -1863,9 +1861,9 @@ test("a republish withdraws the PUBLISH_NAMESPACE and advertises again", async ( test("a republish withdraws the solicited NAMESPACE and sends it again", async () => { const { pair, pub, origin, close } = clustered(true); try { - const broadcastPublication = origin.createBroadcast(Path.from("mine")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce({ hops: [VIA], cost: 4n }); + const broadcastRoute = origin.route(Path.from("mine"), { hidden: true }); + const broadcast = broadcastRoute.broadcast; + wireOf(broadcastRoute).update({ hops: [VIA], cost: 4n }); const subscription = await Stream.open(pair.client, { version: VERSION }); const stream = await Stream.accept(pair.server, VERSION); @@ -1902,14 +1900,14 @@ test.each([ ])("a refused update %s", async (_, retryInterval) => { const { clock, pub, origin, streams, close } = clustered(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n }); void pub.runPublishNamespaces(); const stream = await take(clock, streams); await acceptClustered(stream); - broadcast.announce({ hops: [VIA], cost: 8n }); + wireOf(broadcast).update({ hops: [VIA], cost: 8n }); await readUpdate(stream); await declinePublishNamespace(stream, retryInterval); @@ -1943,8 +1941,8 @@ test.each([ test("a refused update whose peer closes the request keeps the loop running", async () => { const { clock, pub, origin, streams, close } = clustered(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n }); let failed: unknown; void pub.runPublishNamespaces().catch((err: unknown) => { failed = err; @@ -1953,7 +1951,7 @@ test("a refused update whose peer closes the request keeps the loop running", as const stream = await take(clock, streams); await acceptClustered(stream); - broadcast.announce({ hops: [VIA], cost: 8n }); + wireOf(broadcast).update({ hops: [VIA], cost: 8n }); await readUpdate(stream); await declinePublishNamespace(stream, 1n); stream.close(); @@ -1974,17 +1972,17 @@ test("a refused update whose peer closes the request keeps the loop running", as test("a change while an update is unanswered waits for its answer", async () => { const { clock, pub, origin, streams, close } = clustered(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n }); void pub.runPublishNamespaces(); const stream = await take(clock, streams); await acceptClustered(stream); - broadcast.announce({ hops: [VIA], cost: 8n }); + wireOf(broadcast).update({ hops: [VIA], cost: 8n }); expect(await readUpdate(stream)).toEqual({ hops: undefined, cost: 8n }); - broadcast.announce({ hops: [VIA], cost: 12n }); + wireOf(broadcast).update({ hops: [VIA], cost: 12n }); const second = watch(stream.reader.u53()); await clock.advance(Nano.fromMilli(Milli(1_000))); expect(second.state).toBe("pending"); @@ -2012,7 +2010,7 @@ test("a change while an update is unanswered waits for its answer", async () => test("an advertisement the peer keeps ending comes back on a growing backoff", async () => { const { clock, pub, origin, streams, close } = clustered(); try { - origin.createBroadcast(Path.from("mine")).announce({ hops: [VIA], cost: 4n }); + wireOf(origin.route(Path.from("mine"), { hidden: true })).update({ hops: [VIA], cost: 4n }); void pub.runPublishNamespaces(); let stream = await take(clock, streams); @@ -2040,14 +2038,14 @@ test("an advertisement the peer keeps ending comes back on a growing backoff", a test("an unanswered update drops the request and re-offers the namespace fresh", async () => { const { clock, pub, origin, streams, close } = clustered(); try { - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ hops: [VIA], cost: 4n }); + const broadcast = origin.route(Path.from("mine"), { hidden: true }); + wireOf(broadcast).update({ hops: [VIA], cost: 4n }); void pub.runPublishNamespaces(); const stream = await take(clock, streams); await acceptClustered(stream); - broadcast.announce({ hops: [VIA], cost: 8n }); + wireOf(broadcast).update({ hops: [VIA], cost: 8n }); await readUpdate(stream); const reset = watch(stream.reader.u53()); @@ -2078,8 +2076,7 @@ test.each([ const self: Hop = HopSchema.parse(7n); const pair = createMockTransportPair(ALPN.DRAFT_18); const { pub, origin } = publisher(pair.server, { cluster: { self, peer } }); - const broadcast = origin.createBroadcast(Path.from("mine")); - broadcast.announce({ cost: 4n }); + const broadcast = origin.route(Path.from("mine"), { cost: 4n }); void pub.runPublishNamespaces(); const stream = await nextStream(pair.client); @@ -2089,7 +2086,7 @@ test.each([ expect(msg.trackNamespace).toBe(Path.from("mine")); await acceptPublishNamespace(stream); - broadcast.announce({ cost: peer === undefined ? 8n : 4n }); + broadcast.setCost(peer === undefined ? 8n : 4n); await noStream(pair.client, clock); origin.close(); diff --git a/js/net/src/ietf/publisher.ts b/js/net/src/ietf/publisher.ts index 43f59665270..dff76bd9a70 100644 --- a/js/net/src/ietf/publisher.ts +++ b/js/net/src/ietf/publisher.ts @@ -21,7 +21,7 @@ import { unauthorized, } from "../error.ts"; import type * as group from "../group.ts"; -import type { Hop, Route } from "../hop.ts"; +import type { Hop, RouteInfo } from "../hop.ts"; import { finalSequence, firstEligible, hiddenBelow, hooks, presented } from "../internal.ts"; import type { Consumer as OriginConsumer } from "../origin.ts"; import * as Path from "../path.ts"; @@ -81,7 +81,7 @@ const RETRY_BASE = 100; const RETRY_MAX = 5000; /** Cluster parameters for one snapshot: the advertised hops, then our own id last. */ -function clusterFor(base: Cluster.Advert | undefined, route: Route): Cluster.Advert | undefined { +function clusterFor(base: Cluster.Advert | undefined, route: RouteInfo): Cluster.Advert | undefined { if (!base) return undefined; const self = base.hops.at(-1); if (self === undefined) return undefined; @@ -1876,7 +1876,7 @@ export class Publisher { /** * The extension parameters an advertisement of `route` carries. */ - #params(route: Route): AdvertParams { + #params(route: RouteInfo): AdvertParams { return { cluster: clusterFor(this.#advert, route) }; } @@ -1885,7 +1885,7 @@ export class Publisher { * is logged and skipped: a peer that wants none of this rejects each one and stays * connected. */ - async #advertise(path: Path.Valid, requests: Requests, route: Route): Promise { + async #advertise(path: Path.Valid, requests: Requests, route: RouteInfo): Promise { const params = this.#params(route); const auth = this.#carry(route.auth); const requestId = await this.#session.nextRequestId(); diff --git a/js/net/src/ietf/subscriber.ts b/js/net/src/ietf/subscriber.ts index c181b66a7f0..0445b8007ec 100644 --- a/js/net/src/ietf/subscriber.ts +++ b/js/net/src/ietf/subscriber.ts @@ -19,7 +19,7 @@ import { unauthorized, } from "../error.ts"; import type * as netGroup from "../group.ts"; -import { Cost, type Route, routesEqual, UNKNOWN_HOP } from "../hop.ts"; +import { Cost, type RouteInfo, routesEqual, UNKNOWN_HOP } from "../hop.ts"; import * as Instance from "../instance.ts"; import { finalSequence, hiddenBelow, hooks, maxDelayOf, scopeCaptures, scopeHead, scopeOverlaps } from "../internal.ts"; import type { Lister } from "../listing.ts"; @@ -119,7 +119,7 @@ type SubscribeSetupState = { }; /** An announced path: each live advertisement referencing it, oldest first, and the route it holds. */ -type Announced = { adverts: { id: number; route: Route }[]; route: Route }; +type Announced = { adverts: { id: number; route: RouteInfo }[]; route: RouteInfo }; /** A local announce reader's filter: its scope, the prefix it asked for, and its hidden opt-in. */ type Filter = { scope: Path.Pattern; prefix: Path.Valid; hidden: boolean; covering: boolean }; @@ -264,7 +264,7 @@ export class Subscriber { } // What a route costs once the peer has asked us to leave. - #priced(route: Route): Route { + #priced(route: RouteInfo): RouteInfo { if (!this.#goingAway()) return route; if (route.cost === DRAIN_COST) return route; return { ...route, cost: DRAIN_COST }; @@ -298,7 +298,7 @@ export class Subscriber { /** * The route an advertisement carries, before it is minted an instance; one without a path is anonymous and free. */ - #route({ cluster }: AdvertParams): Route { + #route({ cluster }: AdvertParams): RouteInfo { return cluster === undefined ? { hops: [UNKNOWN_HOP], cost: Cost.zero } : { ...cluster }; } @@ -368,7 +368,7 @@ export class Subscriber { * Record one more advertisement for a path, returning the id that names it. Consumers * hear `start` for the first; a later one stands as the newest (see `#settleAnnounce`). */ - #attachAnnounce(path: Path.Valid, route: Route): number { + #attachAnnounce(path: Path.Valid, route: RouteInfo): number { const id = this.#nextAdvert++; const existing = this.#announced.get(path); if (existing) { @@ -394,7 +394,7 @@ export class Subscriber { } /** Replace the route of advertisement `id`, which moves the path only while it is the newest. */ - #updateAnnounce(path: Path.Valid, id: number, route: Route) { + #updateAnnounce(path: Path.Valid, id: number, route: RouteInfo) { const existing = this.#announced.get(path); const advert = existing?.adverts.find((advert) => advert.id === id); if (existing === undefined || advert === undefined) return; diff --git a/js/net/src/integration.test.ts b/js/net/src/integration.test.ts index 063438c8dc2..f88bedc9878 100644 --- a/js/net/src/integration.test.ts +++ b/js/net/src/integration.test.ts @@ -33,9 +33,8 @@ import { withTimeout } from "./util/timeout.ts"; import { wireOf } from "./wire.ts"; function publish(origin: OriginProducer, path: Path.Valid) { - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(path); + const broadcast = broadcastRoute.broadcast; return broadcast; } @@ -1124,10 +1123,9 @@ test("integration: a peer is served the cheaper route it was offered, not the lo const path = Path.from("test"); // One publisher instance, so the two compete on cost alone. const instance = Instance.random(); - const localPublication = origin.createBroadcast(path); - const local = localPublication.broadcast; - localPublication.announce({ instance, cost: 5n }); - const dynamic = origin.requestsRoute(path, { instance, cost: 1n }); + const localRoute = origin.route(path, { instance, cost: 5n }); + const local = localRoute.broadcast; + const dynamic = origin.routePrefix(path, { instance, cost: 1n }); const [client, server] = await Promise.all([ connect(url, { transport: pair.client }), @@ -2786,12 +2784,12 @@ test("create then announce is discoverable on the wire", async () => { ]); const announced = client.announced(); - const broadcastPublication = origin.createBroadcast(Path.from("later")); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = origin.route(Path.from("later"), { hidden: true }); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("chat", { timescale: Timescale.MILLI }); const pending = announced.next(); - broadcastPublication.announce(); + broadcastRoute.announce(); const entry = await pending; expect(entry?.prefix).toBe("later" as Path.Valid); expect(entry?.kind).toBe("start"); @@ -2809,7 +2807,7 @@ test.each([Lite.ALPN_06, Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_18, Ietf.ALPN.DRAFT_2 const pair = createMockTransportPair(protocol); const origin = new OriginProducer(); const consumer = new OriginProducer(); - const handle = origin.requests(Path.empty()); + const handle = origin.routePrefix(Path.empty()); const held = new BroadcastProducer(); held.createTrack("chat", { timescale: Timescale.MILLI }).writeFrame(textFrame("hello")); const serving = (async () => { @@ -2843,14 +2841,15 @@ test.each([Lite.ALPN_06, Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_18, Ietf.ALPN.DRAFT_2 const pair = createMockTransportPair(protocol); const origin = new OriginProducer(); const consumer = new OriginProducer(); - const handle = origin.requests(Path.empty()); + const handle = origin.routePrefix(Path.empty()); const serving = (async () => { const requests = handle.requested(); const request = (await requests.next()).value; if (!request) throw new Error("missing job request"); - const prepared = request.prepare(); - prepared.broadcast.createTrack("chat", { timescale: Timescale.MILLI }).writeFrame(textFrame("job")); - return prepared.publish(); + const job = request.route({ hidden: true }); + job.broadcast.createTrack("chat", { timescale: Timescale.MILLI }).writeFrame(textFrame("job")); + job.announce(); + return job; })(); const [client, server] = await Promise.all([ connect(url, { transport: pair.client, consume: consumer }), @@ -2861,11 +2860,11 @@ test.each([Lite.ALPN_06, Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_18, Ietf.ALPN.DRAFT_2 if (!remote) throw new Error("request did not resolve"); const track = remote.track("chat").subscribe().ordered(); await expect(track.readString()).rejects.toBeInstanceOf(Error); - const publication = await serving; + const job = await serving; track.close(); requested.close(); handle.close(); - publication.broadcast.close(); + job.close(); client.abort(); server.abort(); origin.close(); diff --git a/js/net/src/internal.ts b/js/net/src/internal.ts index 0f503cff677..6934fb0869c 100644 --- a/js/net/src/internal.ts +++ b/js/net/src/internal.ts @@ -12,7 +12,7 @@ import type { Datagram } from "./datagram.ts"; import type { Delivered } from "./delivered.ts"; import { toStreamCode } from "./error.ts"; import type { Frame, FrameConsumer, Consumer as GroupConsumer, Producer as GroupProducer } from "./group.ts"; -import { isAnonymous, type Route } from "./hop.ts"; +import { isAnonymous, type RouteInfo } from "./hop.ts"; import type * as Instance from "./instance.ts"; import * as Path from "./path.ts"; import type { Timestamp } from "./time.ts"; @@ -121,12 +121,12 @@ export function presented( * candidate supersedes. Supersession is decided among what the reader may see, so a higher epoch * it cannot see never hides a route it can. */ -export function firstEligible( +export function firstEligible( candidates: readonly T[], admits: (candidate: T) => boolean = () => true, ): T | undefined { const admitted = candidates.filter(admits); - const byPrefix = new Map(); + const byPrefix = new Map(); for (const candidate of admitted) { const routes = byPrefix.get(candidate.prefix); if (routes) routes.push(candidate.route); @@ -688,12 +688,6 @@ export const hooks: { * mirror is released too: not when its group reads on, or may yet, from another copy. */ evictGroup: (group: GroupConsumer) => boolean; - /** Attach the origin advertisement of a created broadcast. */ - attachAnnouncer: ( - producer: BroadcastProducer, - announcer: { announce(route: Route): void; unannounce(): void; route(): Route | undefined }, - ) => void; - /** Call `fn` synchronously when an open broadcast closes, from any handle. */ onClosed: (producer: BroadcastProducer, fn: () => void) => Dispose; /** Name a broadcast handle by the path an origin created or resolved it at. */ @@ -948,10 +942,6 @@ export const hooks: { evictGroup: () => { throw new Error("group.ts not loaded"); }, - attachAnnouncer: () => { - throw new Error("broadcast.ts not loaded"); - }, - onClosed: () => { throw new Error("broadcast.ts not loaded"); }, @@ -1019,7 +1009,7 @@ export function* coveringPrefixes(path: Path.Valid): Generator { * a higher epoch at the same prefix. An older incarnation of an instance is never eligible, * however cheap, since its publisher was replaced. */ -export function superseded(route: Route, others: Iterable): boolean { +export function superseded(route: RouteInfo, others: Iterable): boolean { return new Epochs(others).supersedes(route); } @@ -1031,7 +1021,7 @@ export function superseded(route: Route, others: Iterable): boolean { export class Epochs { readonly #highest = new Map(); - constructor(routes: Iterable) { + constructor(routes: Iterable) { for (const route of routes) { const epoch = route.epoch ?? 0n; if (epoch === 0n) continue; @@ -1041,14 +1031,14 @@ export class Epochs { } /** Whether a route carries `route`'s instance at a higher epoch. */ - supersedes(route: Route): boolean { + supersedes(route: RouteInfo): boolean { const highest = this.#highest.get(route.instance); return highest !== undefined && highest > (route.epoch ?? 0n); } } /** Prefer identified publishers, then lower static cost. */ -export function compareRoutes(a: Route, b: Route): number { +export function compareRoutes(a: RouteInfo, b: RouteInfo): number { return Number(isAnonymous(a)) - Number(isAnonymous(b)) || (a.cost < b.cost ? -1 : a.cost > b.cost ? 1 : 0); } @@ -1060,7 +1050,7 @@ export function compareRoutes(a: Route, b: Route): number { * matching `route_order` in rs/moq-net for routes a node did not get from a cluster peer, which * is every route here. */ -export function compareRouteCandidates(path: Path.Valid, prefix: Path.Valid, a: Route, b: Route): number { +export function compareRouteCandidates(path: Path.Valid, prefix: Path.Valid, a: RouteInfo, b: RouteInfo): number { const order = compareRoutes(a, b) || a.hops.length - b.hops.length; if (order !== 0 || path === prefix) return order; const ha = spreadHash(path, a.instance ?? ""); diff --git a/js/net/src/lite/compression.test.ts b/js/net/src/lite/compression.test.ts index d352c314648..0230b61439f 100644 --- a/js/net/src/lite/compression.test.ts +++ b/js/net/src/lite/compression.test.ts @@ -13,10 +13,10 @@ for (const downstream of [ALPN_06, ALPN_07_WIP]) { const installed = clock.install(); const source = new Producer(); const destination = new Producer(); - const broadcastPublication = source.createBroadcast(Path.from("compressed")); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = source.route(Path.from("compressed"), { hidden: true }); + const broadcast = broadcastRoute.broadcast; const track = broadcast.createTrack("data", { compress: true }); - broadcastPublication.announce(); + broadcastRoute.announce(); const peers: { abort(): void }[] = []; async function link(publish: Producer, consume: Producer, alpn: string) { const pair = createMockTransportPair(alpn); diff --git a/js/net/src/lite/connection.test.ts b/js/net/src/lite/connection.test.ts index 7af5f8d8db9..0050de38fa3 100644 --- a/js/net/src/lite/connection.test.ts +++ b/js/net/src/lite/connection.test.ts @@ -309,9 +309,8 @@ for (const [alpn, version] of [ const pair = createMockTransportPair(alpn); const fin = holdFins(pair.server, "uni"); const origin = new Producer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const url = new URL("https://localhost/test"); const client = new Connection({ url, quic: pair.client, version }); @@ -371,9 +370,8 @@ for (const [alpn, version] of [ deliverWhole(pair.client); if (overtaken === "fin") finAfterClose(pair.client); const origin = new Producer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const url = new URL("https://localhost/test"); const client = new Connection({ url, quic: pair.client, version }); @@ -423,9 +421,8 @@ for (const [alpn, version] of [ const pair = createMockTransportPair(alpn); finAfterClose(pair.client); const origin = new Producer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const url = new URL("https://localhost/test"); const client = new Connection({ url, quic: pair.client, version }); @@ -468,9 +465,8 @@ for (const [alpn, version] of [ test(`a peer close finishes a FIN'd track over qmux ${versionName(version)}`, async () => { const pair = qmuxPair(); const origin = new Producer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const url = new URL("https://localhost/test"); const client = new Connection({ url, quic: pair.client, version }); @@ -509,9 +505,8 @@ for (const [alpn, version] of [ async function servedRawSubscription(alpn: string = ALPN_07_WIP, version: Version = Version.DRAFT_07) { const pair = createMockTransportPair(alpn); const origin = new Producer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const server = new Connection({ url: new URL("https://relay.example/"), @@ -628,9 +623,8 @@ test("close waits for a served FETCH to be acknowledged", async () => { const pair = createMockTransportPair(ALPN_05); const fin = holdFins(pair.server, "incoming-bidi"); const origin = new Producer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const group = producer.appendGroup(); group.writeFrame(textFrame("last")); @@ -681,9 +675,8 @@ test("close waits for a request served while withdrawals are in flight", async ( const fin = holdFins(pair.server, "incoming-bidi"); const source = new Producer(); const destination = new Producer(); - const broadcastPublication = source.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = source.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const group = producer.appendGroup(); group.writeFrame(textFrame("last")); diff --git a/js/net/src/lite/publisher.test.ts b/js/net/src/lite/publisher.test.ts index caeb08eb484..b35414f5f91 100644 --- a/js/net/src/lite/publisher.test.ts +++ b/js/net/src/lite/publisher.test.ts @@ -33,9 +33,8 @@ import { Track as TrackMessage } from "./track.ts"; import { ALPN_05, ALPN_06, ALPN_07_WIP, keepsSubscribeOpen, Version } from "./version.ts"; function publish(origin: OriginProducer, path: Path.Valid) { - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(path); + const broadcast = broadcastRoute.broadcast; return broadcast; } @@ -107,9 +106,8 @@ test.each([ const pair = createMockTransportPair(ALPN_05); const origin = new OriginProducer(); const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); - const broadcastPublication = origin.createBroadcast(Path.from("cam")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce({ cost: 7n }); + const broadcastRoute = origin.route(Path.from("cam"), { cost: 7n }); + const broadcast = broadcastRoute.broadcast; const written: Uint8Array[] = []; const stream = new Stream({ @@ -127,7 +125,7 @@ test.each([ const initial = written.length; expect(initial).toBeGreaterThan(0); - broadcastPublication.announce({ cost: 9n }); + broadcastRoute.setCost(9n); await settle(); expect(written.length > initial).toBe(sent); @@ -719,7 +717,7 @@ async function servedSubscription( broadcast = new BroadcastProducer(); const front = new Front(); front.serve(broadcast.consume()); - const dynamic = origin.requestsRoute(Path.from("test")); + const dynamic = origin.routePrefix(Path.from("test")); void (async () => { for await (const request of dynamic.requested()) request.serve(front.consumer); })(); @@ -2714,9 +2712,8 @@ test("lite draft-06: announces wait for the setup grant", async () => { answered = resolve; }); const publisher = new Publisher(pair.server, Version.DRAFT_06, randomHop(), origin.consume(), { grant, ready }); - const broadcastPublication = origin.createBroadcast(Path.from("foo/bar")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("foo/bar")); + const broadcast = broadcastRoute.broadcast; const written: Uint8Array[] = []; const stream = new Stream({ @@ -2792,7 +2789,7 @@ test("lite draft-06: closing while announces wait for the setup grant does not h test("lite draft-06: a grant that shrinks while a TRACK resolves refuses it", async () => { const pair = createMockTransportPair(ALPN_06); const origin = new OriginProducer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const requests = handle.requested(); const grant = new Signal(grantOf("live")); const publisher = new Publisher(pair.server, Version.DRAFT_06, randomHop(), origin.consume(), { @@ -2833,7 +2830,7 @@ test("lite draft-06: a grant that shrinks while a TRACK resolves refuses it", as test("lite draft-06: a grant that shrinks while TRACK_INFO is blocked resets it", async () => { const pair = createMockTransportPair(ALPN_06); const origin = new OriginProducer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const requests = handle.requested(); const grant = new Signal(grantOf("live")); const publisher = new Publisher(pair.server, Version.DRAFT_06, randomHop(), origin.consume(), { @@ -2896,7 +2893,7 @@ test("lite draft-06: a grant that shrinks while TRACK_INFO is blocked resets it" test("lite draft-06: a grant that shrinks while the broadcast resolves resets the subscription", async () => { const pair = createMockTransportPair(ALPN_06); const origin = new OriginProducer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const requests = handle.requested(); const grant = new Signal(grantOf("live")); const publisher = new Publisher(pair.server, Version.DRAFT_06, randomHop(), origin.consume(), { diff --git a/js/net/src/lite/publisher.ts b/js/net/src/lite/publisher.ts index 89ed83f74fd..89fd25d2040 100644 --- a/js/net/src/lite/publisher.ts +++ b/js/net/src/lite/publisher.ts @@ -19,7 +19,7 @@ import { } from "../error.ts"; import { stored } from "../flate/group.ts"; import type * as group from "../group.ts"; -import { Cost, type Hop, type Route, routesEqual } from "../hop.ts"; +import { Cost, type Hop, type RouteInfo, routesEqual } from "../hop.ts"; import { finalSequence, hiddenBelow, hooks, insertRun, presented, type Run, runGaps } from "../internal.ts"; import type { Consumer as OriginConsumer } from "../origin.ts"; import * as Path from "../path.ts"; @@ -560,15 +560,15 @@ export class Publisher { let nextAnnounceId = 0n; const announceIds = new Map(); - const wireHops = (route: Route): Hop[] => { - if (hasAnnounceOk(this.version)) return route.hops; + const wireHops = (route: RouteInfo): Hop[] => { + if (hasAnnounceOk(this.version)) return [...route.hops]; return [...route.hops, this.hop]; }; // What the peer decodes for a route: pre-lite-06 wires carry no cost, so a re-price // there must not restart. // moq-lite carries no per-request auth, so a swap alone sends nothing. - const onWire = (route: Route): Route => ({ + const onWire = (route: RouteInfo): RouteInfo => ({ ...route, cost: hasRouteCost(this.version) ? route.cost : Cost.zero, auth: undefined, @@ -580,7 +580,7 @@ export class Publisher { !sameInstance(prev, next) || (hasInstance(this.version) && (prev.route.epoch ?? 0n) !== (next.route.epoch ?? 0n)); - const announce = async (suffix: Path.Valid, route: Route) => { + const announce = async (suffix: Path.Valid, route: RouteInfo) => { console.debug(`announce: broadcast=${suffix} active=true instance=${route.instance}`); if (hasAnnounceId(this.version)) announceIds.set(suffix, nextAnnounceId++); await encodeAnnounceBroadcast( @@ -597,7 +597,7 @@ export class Publisher { ); }; - const update = async (suffix: Path.Valid, route: Route) => { + const update = async (suffix: Path.Valid, route: RouteInfo) => { if (!hasAnnounceId(this.version)) { await retract(suffix); await announce(suffix, route); @@ -617,7 +617,7 @@ export class Publisher { }; // Another instance or epoch: ANNOUNCE_RESTART on lite-07, an end and a start before it. - const restart = async (suffix: Path.Valid, route: Route) => { + const restart = async (suffix: Path.Valid, route: RouteInfo) => { const id = announceIds.get(suffix); if (id === undefined || !hasAnnounceRestart(this.version)) { await retract(suffix); diff --git a/js/net/src/lite/refresh.test.ts b/js/net/src/lite/refresh.test.ts index cac0a6741a8..2bd1b91fe69 100644 --- a/js/net/src/lite/refresh.test.ts +++ b/js/net/src/lite/refresh.test.ts @@ -13,9 +13,8 @@ test.each([ALPN_06, ALPN_07_WIP])("refresh joins reach a browser publisher on %s const installed = clock.install(); const source = new Producer(); const b = new Producer(); - const broadcastPublication = source.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = source.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("data", { refresh: 1 }); const pair = createMockTransportPair(alpn); const url = new URL("https://localhost/refresh"); diff --git a/js/net/src/lite/subscriber.test.ts b/js/net/src/lite/subscriber.test.ts index 088b6fdcbed..f3a84a1c124 100644 --- a/js/net/src/lite/subscriber.test.ts +++ b/js/net/src/lite/subscriber.test.ts @@ -16,7 +16,7 @@ import { TimestampMismatch, } from "../error.ts"; import type { Consumer as GroupConsumer } from "../group.ts"; -import { HopSchema, isAnonymous, MAX_HOPS, Route, UNKNOWN_HOP } from "../hop.ts"; +import { HopSchema, isAnonymous, MAX_HOPS, RouteInfo, UNKNOWN_HOP } from "../hop.ts"; import * as Instance from "../instance.ts"; import { hooks } from "../internal.ts"; import { GRACE } from "../ledger.ts"; @@ -198,8 +198,8 @@ test("an announce consumer closed while its stream opens sends nothing on it", a }); test("a local empty hop chain is not anonymous", () => { - expect(isAnonymous(Route.default)).toBe(false); - expect(isAnonymous({ hops: [UNKNOWN_HOP], cost: Route.default.cost })).toBe(true); + expect(isAnonymous(RouteInfo.default)).toBe(false); + expect(isAnonymous({ hops: [UNKNOWN_HOP], cost: RouteInfo.default.cost })).toBe(true); }); test("a max-length chain plus withheld responder is dropped", async () => { diff --git a/js/net/src/lite/subscriber.ts b/js/net/src/lite/subscriber.ts index 3815b0de301..8848f88b9cd 100644 --- a/js/net/src/lite/subscriber.ts +++ b/js/net/src/lite/subscriber.ts @@ -20,7 +20,7 @@ import { unauthorized, } from "../error.ts"; import * as netGroup from "../group.ts"; -import { Cost, type Hop, MAX_HOPS, type Route, routesEqual, UNKNOWN_HOP } from "../hop.ts"; +import { Cost, type Hop, MAX_HOPS, type RouteInfo, routesEqual, UNKNOWN_HOP } from "../hop.ts"; import * as Instance from "../instance.ts"; import { hiddenBelow, hooks, maxDelayOf, minDelayOf, scopeCaptures, scopeHead, scopeOverlaps } from "../internal.ts"; import type { Lister } from "../listing.ts"; @@ -390,7 +390,7 @@ export class Subscriber { // retract that one's state. type Advertisement = { live: boolean; - route: Route; + route: RouteInfo; captures: Path.Pattern[] | undefined; }; // Each holds one of the session's announce slots, reflected and hidden ones included. @@ -702,7 +702,7 @@ export class Subscriber { }); continue; } - const route: Route = { instance, epoch, hops: fullHops, cost: this.#cost(cost) }; + const route: RouteInfo = { instance, epoch, hops: fullHops, cost: this.#cost(cost) }; const captures = scopeCaptures(scope, path); if (!visible(path)) { advertised.set(path, { live: false, route, captures }); diff --git a/js/net/src/lite/track_stream.test.ts b/js/net/src/lite/track_stream.test.ts index cb396508eb3..3ef3a0341f4 100644 --- a/js/net/src/lite/track_stream.test.ts +++ b/js/net/src/lite/track_stream.test.ts @@ -117,9 +117,8 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver const pair = createMockTransportPair(ALPN_05); const origin = new OriginProducer(); const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; let producer: TrackProducer | undefined; const serving = (async () => { for (;;) { @@ -155,9 +154,8 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver const closing = spyOn(pair.server, "close"); const origin = new OriginProducer(); const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const client = await Stream.open(pair.client, { version }); const server = await Stream.accept(pair.server, version); @@ -179,9 +177,8 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver const pair = createMockTransportPair(ALPN_05); const origin = new OriginProducer(); const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; let producer: TrackProducer | undefined; const serving = (async () => { for (;;) { @@ -227,9 +224,8 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver const pair = createMockTransportPair(ALPN_05); const origin = new OriginProducer(); const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producers: TrackProducer[] = []; const serving = (async () => { for (;;) { @@ -269,9 +265,8 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver const pair = createMockTransportPair(ALPN_05); const origin = new OriginProducer(); const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const producers: TrackProducer[] = []; const serving = (async () => { for (;;) { @@ -328,9 +323,8 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver const pair = createMockTransportPair(ALPN_05); const origin = new OriginProducer(); const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; // Answered by hand, once every requester has left. const requested = wireOf(broadcast).requested(); @@ -356,9 +350,8 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver const pair = createMockTransportPair(ALPN_05); const origin = new OriginProducer(); const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const requested = wireOf(broadcast).requested(); await requester(pair, publisher, kind); @@ -379,9 +372,8 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver const pair = createMockTransportPair(ALPN_05); const origin = new OriginProducer(); const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; // Answered by hand, after the first TRACK stream has left. const requested = wireOf(broadcast).requested(); @@ -410,9 +402,8 @@ describe.each([Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07])("%s", (ver const pair = createMockTransportPair(ALPN_05); const origin = new OriginProducer(); const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const serving = (async () => { for (;;) { const request = await wireOf(broadcast).requested(); diff --git a/js/net/src/lite/tracks.test.ts b/js/net/src/lite/tracks.test.ts index c35c7780250..c8b947d4f8b 100644 --- a/js/net/src/lite/tracks.test.ts +++ b/js/net/src/lite/tracks.test.ts @@ -350,9 +350,8 @@ function publisher(origin: OriginProducer) { test("data after a TRACKS request closes the session", async () => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("a"); const { list, closing } = publisher(origin); const listing = await list("room"); @@ -366,9 +365,8 @@ test("data after a TRACKS request closes the session", async () => { test("a publisher lists its broadcast's own tracks, never one served on request", async () => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("a", { priority: 5 }); // Served on request: answered when asked, never listed. void wireOf(broadcast) @@ -389,9 +387,8 @@ test("a publisher lists its broadcast's own tracks, never one served on request" test("a newer listing of a broadcast on one session replaces the older", async () => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("a"); const { list } = publisher(origin); const older = await list("room"); @@ -408,7 +405,7 @@ test("a newer listing of a broadcast on one session replaces the older", async ( test("a path served through a covering prefix route is NOT_FOUND", async () => { const origin = new OriginProducer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); void (async () => { for await (const request of dynamic.requested()) { const served = new BroadcastProducer(); @@ -425,7 +422,7 @@ test("a path served through a covering prefix route is NOT_FOUND", async () => { test("a local read through a covering prefix route is NOT_FOUND, and through its exact route lists", async () => { const origin = new OriginProducer(); for (const prefix of ["room", "room/bob"]) { - const dynamic = origin.requestsRoute(Path.from(prefix)); + const dynamic = origin.routePrefix(Path.from(prefix)); void (async () => { for await (const request of dynamic.requested()) { const served = new BroadcastProducer(); @@ -461,9 +458,8 @@ test("a listing over a session carries each track's info, end to end", async () connect({ url, transport: pair.client }), accept({ transport: pair.server, url, publish: origin.consume() }), ]); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("a", { timescale: Timescale.MILLI, maxAge: Milli(3000), @@ -497,10 +493,13 @@ test("an instance-pinned front lists its serving route's tracks", async () => { connect({ url, transport: pair.client, consume: clientOrigin }), accept({ transport: pair.server, url, publish: serverOrigin.consume() }), ]); - const broadcastPublication = serverOrigin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = serverOrigin.route(Path.from("room"), { + hidden: true, + instance: Instance.parse("01900000-0000-7000-8000-000000000001"), + }); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("a"); - broadcastPublication.announce({ instance: Instance.parse("01900000-0000-7000-8000-000000000001") }); + broadcastRoute.announce(); const reader = clientOrigin.consume(); const announced = reader.announced(); @@ -525,7 +524,7 @@ test("an instance-pinned front lists its serving route's tracks", async () => { test("a front pinned to a named instance served through a covering prefix route is NOT_FOUND", async () => { const origin = new OriginProducer(); - const dynamic = origin.requestsRoute(Path.from("room"), { instance: Instance.parse("named") }); + const dynamic = origin.routePrefix(Path.from("room"), { instance: Instance.parse("named") }); void (async () => { for await (const request of dynamic.requested()) { const served = new BroadcastProducer(); @@ -551,9 +550,8 @@ test("lite-06 cannot list over a session", async () => { connect({ url, transport: pair.client }), accept({ transport: pair.server, url, publish: origin.consume() }), ]); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; const tracks = wireOf(client).consume(Path.from("room")).tracks(); expect(await next(tracks)).toMatch(/requires moq-lite-07/); broadcast.close(); diff --git a/js/net/src/lite/widened_max_age.test.ts b/js/net/src/lite/widened_max_age.test.ts index d1f41fda63a..1c53519bf67 100644 --- a/js/net/src/lite/widened_max_age.test.ts +++ b/js/net/src/lite/widened_max_age.test.ts @@ -28,8 +28,7 @@ async function received(reader: TrackSubscriber, count: number): Promise { const pair = createMockTransportPair(ALPN_07_WIP); const origin = new OriginProducer(); - const publication = origin.createBroadcast(Path.from("room")); - publication.announce(); + const publication = origin.route(Path.from("room")); const broadcast = publication.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); // One group per second, so a budget picks how far back a reader reaches. diff --git a/js/net/src/order.test.ts b/js/net/src/order.test.ts index ea3ba400207..5b803552045 100644 --- a/js/net/src/order.test.ts +++ b/js/net/src/order.test.ts @@ -119,9 +119,8 @@ async function backlog(protocol: string, order: Order, update?: Order) { const origin = new OriginProducer(); const { client, server, transport } = await session(protocol, origin); - const broadcastPublication = origin.createBroadcast(Path.from("test")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("test")); + const broadcast = broadcastRoute.broadcast; const video = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const groups = [0, 1, 2].map(() => writeGroup(video)); @@ -173,9 +172,8 @@ test.each(["ascending", "descending"] as const)("ietf serves GROUP_ORDER %s", as const origin = new OriginProducer(); const { client, server, transport } = await session(Ietf.ALPN.DRAFT_18, origin); - const broadcastPublication = origin.createBroadcast(Path.from("test")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("test")); + const broadcast = broadcastRoute.broadcast; const video = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const remote = wireOf(client).consume(Path.from("test")); @@ -241,9 +239,8 @@ test("ietf keeps a closing group stream ranked until it settles", async () => { const { client, server, transport } = await session(Ietf.ALPN.DRAFT_18, origin); const fins = holdFins(transport); - const broadcastPublication = origin.createBroadcast(Path.from("test")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("test")); + const broadcast = broadcastRoute.broadcast; const video = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const remote = wireOf(client).consume(Path.from("test")); @@ -282,9 +279,8 @@ test("a shared track aggregates descending and serves each subscriber in its own session(Lite.ALPN_07_WIP, origin), ]); - const broadcastPublication = origin.createBroadcast(Path.from("test")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("test")); + const broadcast = broadcastRoute.broadcast; const video = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const ascendingRemote = wireOf(ascending.client).consume(Path.from("test")); diff --git a/js/net/src/origin-demand.test.ts b/js/net/src/origin-demand.test.ts index 018a10d7679..a3511747e5d 100644 --- a/js/net/src/origin-demand.test.ts +++ b/js/net/src/origin-demand.test.ts @@ -27,7 +27,7 @@ test.each(["lite", "ietf", "fetch", "track"] as const)( async (kind) => { const pair = createMockTransportPair(); const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const publisher = kind === "ietf" ? new IetfPublisher({ @@ -106,7 +106,7 @@ test.each(["lite", "ietf", "fetch", "track"] as const)( test("last cancellation finishes the internal wait and discards a late consumer", async () => { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const requests = dynamic.requested(); const hold = new AbortController(); const wait = wireOf(origin.consume()).demand(path, undefined, hold.signal); @@ -134,7 +134,7 @@ test("last cancellation finishes the internal wait and discards a late consumer" expect(source.closed.peek()).toBeUndefined(); fresh.serve(source); await settle(); - expect(next.active.peek()?.instance).toBe(dynamic.route.instance); + expect(next.active.peek()?.instance).toBe(dynamic.instance); next.close(); keeper.close(); source.close(); @@ -149,7 +149,7 @@ test.each([true, false])( "shared local/remote demand is withdrawn whichever leaves last (local first: %s)", async (localFirst) => { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const requests = dynamic.requested(); const hold = new AbortController(); const wait = wireOf(origin.consume()) @@ -193,13 +193,13 @@ test.each([ ] as const)("cancelling one waiter preserves a second %s requester across %i routes", async (other, routes) => { const origin = new Producer(); const prefix = Path.from("room"); - const dynamics = Array.from({ length: routes }, (_, i) => origin.requestsRoute(prefix, { cost: BigInt(i) })); + const dynamics = Array.from({ length: routes }, (_, i) => origin.routePrefix(prefix, { cost: BigInt(i) })); const hold = new AbortController(); const wire = wireOf(origin.consume()); const first = wire.demand(path, undefined, hold.signal).catch(() => undefined); // With competing routes, re-price the cancelled waiter's route so the survivor pends on another. const cancelled = dynamics[0]; - if (routes > 1) cancelled.updateRoute({ ...cancelled.route, cost: BigInt(routes) }); + if (routes > 1) cancelled.setCost(BigInt(routes)); const requests = dynamics[routes > 1 ? 1 : 0].requested(); const second = other === "peer" ? wire.demand(path) : undefined; const local = other === "local" ? origin.request(path) : undefined; @@ -212,7 +212,7 @@ test.each([ request.serve(source); await settle(); if (other === "peer") expect((await second)?.closed).toBe(source.closed); - else expect(local?.active.peek()?.instance).toBe(dynamics[routes > 1 ? 1 : 0].route.instance); + else expect(local?.active.peek()?.instance).toBe(dynamics[routes > 1 ? 1 : 0].instance); } finally { local?.close(); origin.close(); @@ -223,7 +223,7 @@ test.each([ test("an already cancelled signal never enqueues or subscribes to abort", async () => { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const requests = dynamic.requested(); const hold = new AbortController(); hold.abort(); @@ -245,7 +245,7 @@ test.each(["accept", "reject", "cancel"] as const)( "%s releases the abort listener without closing a shared producer", async (action) => { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const requests = dynamic.requested(); const source = new Broadcast(); const keeper = source.consume(); @@ -281,12 +281,12 @@ test.each(["accept", "reject", "cancel"] as const)( test("a pending local request changing routes withdraws the old route's work", async () => { const origin = new Producer(); - const first = origin.requestsRoute(Path.from("room"), { cost: 5n }); + const first = origin.routePrefix(Path.from("room"), { cost: 5n }); const a = first.requested(); const local = origin.request(path); const old = (await a.next()).value; if (!old) throw new Error("expected a pending request"); - const second = origin.requestsRoute(Path.from("room"), { cost: 1n }); + const second = origin.routePrefix(Path.from("room"), { cost: 1n }); const b = second.requested(); const fresh = (await b.next()).value; if (!fresh) throw new Error("expected a pending request"); @@ -299,7 +299,7 @@ test("a pending local request changing routes withdraws the old route's work", a expect(close).toHaveBeenCalledTimes(1); fresh.serve(source); await settle(); - expect(local.active.peek()?.instance).toBe(second.route.instance); + expect(local.active.peek()?.instance).toBe(second.instance); } finally { close.mockRestore(); local.close(); @@ -314,7 +314,7 @@ test("a pending local request changing routes withdraws the old route's work", a test("cancelling an old instance waiter does not decrement a new instance's demand", async () => { const origin = new Producer(); const instance = Instance.random(); - const dynamic = origin.requestsRoute(Path.from("room"), { instance }); + const dynamic = origin.routePrefix(Path.from("room"), { instance }); const requests = dynamic.requested(); const wire = wireOf(origin.consume()); const hold = new AbortController(); @@ -322,7 +322,7 @@ test("cancelling an old instance waiter does not decrement a new instance's dema const old = (await requests.next()).value; if (!old) throw new Error("expected old request"); const next = Instance.random(); - dynamic.updateRoute({ instance: next }); + wireOf(dynamic).update({ instance: next }); const after = wire.demand(path, next); hold.abort(); await before; @@ -346,8 +346,8 @@ test.each(["answer", "release"] as const)( const origin = new Producer(); const instance = Instance.random(); const prefix = Path.from("room"); - const a = origin.requestsRoute(prefix, { instance, cost: 1n }); - const b = origin.requestsRoute(prefix, { instance, cost: 5n }); + const a = origin.routePrefix(prefix, { instance, cost: 1n }); + const b = origin.routePrefix(prefix, { instance, cost: 5n }); const ar = a.requested(); const br = b.requested(); const held = origin.request(path); @@ -355,7 +355,7 @@ test.each(["answer", "release"] as const)( (await ar.next()).value.serve(source); await settle(); // Another instance wins new requests. The old handle stays on its own instance. - const c = origin.requestsRoute(prefix, { instance: Instance.random(), cost: 0n }); + const c = origin.routePrefix(prefix, { instance: Instance.random(), cost: 0n }); a.close(); await settle(); const pending = (await br.next()).value; @@ -407,8 +407,8 @@ test.each([0, 1])( // Each instance undercuts the last, so it wins the path for the request made now. const instance = Instance.parse(`instance-${i + 1}`); const cost = BigInt(4 - 2 * i); - const primary = origin.requestsRoute(prefix, { instance, cost }); - const standby = origin.requestsRoute(prefix, { instance, cost: cost + 1n }); + const primary = origin.routePrefix(prefix, { instance, cost }); + const standby = origin.routePrefix(prefix, { instance, cost: cost + 1n }); const ar = primary.requested(); const br = standby.requested(); const held = origin.request(path); @@ -418,7 +418,7 @@ test.each([0, 1])( await settle(); entries.push({ primary, ar, br, held }); } - origin.requestsRoute(prefix, { instance: Instance.parse("instance-3"), cost: 0n }); + origin.routePrefix(prefix, { instance: Instance.parse("instance-3"), cost: 0n }); const pending = []; for (const entry of entries) { entry.primary.close(); @@ -459,7 +459,7 @@ test.each([0, 1])( test("a normal FETCH request FIN keeps unanswered origin demand alive", async () => { const pair = createMockTransportPair(); const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const requests = dynamic.requested(); const publisher = new LitePublisher(pair.server, LiteVersion.DRAFT_06, randomHop(), origin.consume()); let input!: ReadableStreamDefaultController; @@ -500,7 +500,7 @@ test.each(["accept", "reject"] as const)( "cancellation racing %s releases only the cancelled waiter", async (answer) => { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const requests = dynamic.requested(); const wire = wireOf(origin.consume()); const hold = new AbortController(); @@ -529,7 +529,7 @@ test.each(["accept", "reject"] as const)( test.each([true, false])("last waiter cancellation and accept in one turn (cancel first: %s)", async (cancelFirst) => { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const requests = dynamic.requested(); const wire = wireOf(origin.consume()); const hold = new AbortController(); @@ -570,7 +570,7 @@ test.each([true, false])("last waiter cancellation and accept in one turn (cance test.each([true, false])("local demand survives same-turn cancellation only when rejoined: %s", async (rejoin) => { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const requests = dynamic.requested(); const local = origin.request(path); const hold = new AbortController(); @@ -592,7 +592,7 @@ test.each([true, false])("local demand survives same-turn cancellation only when expect(close).toHaveBeenCalledTimes(rejoin ? 0 : 1); if (replacement) { await settle(); - expect(replacement.active.peek()?.instance).toBe(dynamic.route.instance); + expect(replacement.active.peek()?.instance).toBe(dynamic.instance); } else { const fresh = origin.request(path); const next = (await requests.next()).value; @@ -600,7 +600,7 @@ test.each([true, false])("local demand survives same-turn cancellation only when if (!next) throw new Error("expected fresh request"); next.serve(source); await settle(); - expect(fresh.active.peek()?.instance).toBe(dynamic.route.instance); + expect(fresh.active.peek()?.instance).toBe(dynamic.instance); fresh.close(); } } finally { @@ -616,7 +616,7 @@ test.each([true, false])("local demand survives same-turn cancellation only when test("queued cancellation preserves order, replacement identity, and empty-queue wakeup", async () => { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const requests = dynamic.requested(); const wire = wireOf(origin.consume()); const holds = Array.from({ length: 4 }, () => new AbortController()); @@ -642,7 +642,7 @@ test("queued cancellation preserves order, replacement identity, and empty-queue test("reset clears queued work while a handler is suspended and admits the new instance", async () => { const origin = new Producer(); const instance = Instance.random(); - const dynamic = origin.requestsRoute(Path.from("room"), { instance }); + const dynamic = origin.routePrefix(Path.from("room"), { instance }); const requests = dynamic.requested(); const wire = wireOf(origin.consume()); const waits = [path, Path.from("room/obsolete")].map((name) => wire.demand(name, instance).catch(() => {})); @@ -650,7 +650,7 @@ test("reset clears queued work while a handler is suspended and admits the new i const old = (await requests.next()).value; expect(old?.path).toBe(path); const next = Instance.random(); - dynamic.updateRoute({ instance: next }); + wireOf(dynamic).update({ instance: next }); waits.push(wire.demand(path, next).catch(() => {})); const fresh = (await requests.next()).value; expect(fresh?.path).toBe(path); @@ -666,7 +666,7 @@ test("reset clears queued work while a handler is suspended and admits the new i test("concurrent handlers consume queued requests once across empty batches", async () => { const origin = new Producer(); - const dynamic = origin.requestsRoute(Path.from("room")); + const dynamic = origin.routePrefix(Path.from("room")); const handlers = [dynamic.requested(), dynamic.requested()]; const wire = wireOf(origin.consume()); const waits: Promise[] = []; diff --git a/js/net/src/origin-request.test.ts b/js/net/src/origin-request.test.ts index 38074e798ee..aabf3d94108 100644 --- a/js/net/src/origin-request.test.ts +++ b/js/net/src/origin-request.test.ts @@ -1,9 +1,9 @@ import { expect, test } from "bun:test"; import { Producer as BroadcastProducer } from "./broadcast"; import { StreamCode, StreamError } from "./error"; -import { Route } from "./hop"; +import { RouteInfo } from "./hop"; import * as Instance from "./instance.ts"; -import { type Following, Producer, type Publication, type Requesting } from "./origin"; +import { type Following, Producer, type Requesting } from "./origin"; import * as Path from "./path"; import { wireOf } from "./wire"; @@ -12,25 +12,22 @@ const settle = () => new Promise((resolve) => setImmediate(resolve)); test("a follower moves through restart, end and a later start", async () => { const origin = new Producer(); const path = Path.from("room/audio"); - const firstPublication = origin.createBroadcast(path); - const first = firstPublication.broadcast; - firstPublication.announce(); + const firstRoute = origin.route(path); + const first = firstRoute.broadcast; const request: Following = origin.follow(path); - expect(request.active.peek()?.instance).toBe(firstPublication.route?.instance); - const secondPublication = origin.createBroadcast(path); - const second = secondPublication.broadcast; - secondPublication.announce(); + expect(request.active.peek()?.instance).toBe(firstRoute.instance); + const secondRoute = origin.route(path); + const second = secondRoute.broadcast; await settle(); - expect(request.active.peek()?.instance).toBe(secondPublication.route?.instance); + expect(request.active.peek()?.instance).toBe(secondRoute.instance); second.close(); await settle(); expect(request.active.peek()).toBeUndefined(); expect(request.closed.peek()).toBeUndefined(); - const thirdPublication = origin.createBroadcast(path); - const third = thirdPublication.broadcast; - thirdPublication.announce(); + const thirdRoute = origin.route(path); + const third = thirdRoute.broadcast; await settle(); - expect(request.active.peek()?.instance).toBe(thirdPublication.route?.instance); + expect(request.active.peek()?.instance).toBe(thirdRoute.instance); request.close(); third.close(); first.close(); @@ -41,15 +38,13 @@ test("an instance-pinned follower refuses another instance", async () => { const origin = new Producer(); const path = Path.from("room/audio"); const instance = Instance.random(); - const firstPublication = origin.createBroadcast(path); - const first = firstPublication.broadcast; - firstPublication.announce({ instance }); + const firstRoute = origin.route(path, { instance }); + const first = firstRoute.broadcast; const request = origin.follow(path, { instance }); - const secondPublication = origin.createBroadcast(path); - const second = secondPublication.broadcast; - secondPublication.announce({ instance: Instance.random() }); + const secondRoute = origin.route(path, { instance: Instance.random() }); + const second = secondRoute.broadcast; await settle(); - expect(request.active.peek()?.instance).not.toBe(secondPublication.route?.instance); + expect(request.active.peek()?.instance).not.toBe(secondRoute.instance); request.close(); first.close(); second.close(); @@ -59,14 +54,14 @@ test("an instance-pinned follower refuses another instance", async () => { test("a follower changes its handle on an in-place instance restart", async () => { const origin = new Producer(); const path = Path.from("room/audio"); - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; const before = Instance.random(); - broadcastPublication.announce({ instance: before }); + const broadcastRoute = origin.route(path, { instance: before }); + const broadcast = broadcastRoute.broadcast; const request = origin.follow(path); const old = request.active.peek(); const after = Instance.random(); - broadcastPublication.announce({ instance: after }); + // A session's in-place restart: the route's instance changes under it. + wireOf(broadcastRoute).update({ instance: after }); await settle(); expect(request.active.peek()?.instance).toBe(after); expect(request.active.peek()).not.toBe(old); @@ -80,9 +75,8 @@ test("a closed follower never acquires another publisher", async () => { const path = Path.from("room/audio"); const request = origin.follow(path); request.close(); - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(path); + const broadcast = broadcastRoute.broadcast; await settle(); expect(request.active.peek()).toBeUndefined(); expect(request.closed.peek()).toBeNull(); @@ -108,11 +102,10 @@ test("unrelated routes never notify followers", async () => { await settle(); let changes = 0; const stops = requests.map((request) => request.active.subscribe(() => changes++)); - const otherPublication = origin.createBroadcast(Path.from("unrelated")); - const other = otherPublication.broadcast; - otherPublication.announce(); + const otherRoute = origin.route(Path.from("unrelated")); + const other = otherRoute.broadcast; await settle(); - otherPublication.announce({ cost: 5n }); + otherRoute.setCost(5n); await settle(); other.close(); await settle(); @@ -167,29 +160,27 @@ test("followers track the serving prefix, ignoring descendants and re-prices", a const origin = new Producer(); const source = new BroadcastProducer(); const keeper = source.consume(); - const prefix = origin.requestsRoute(Path.from("pool")); + const prefix = origin.routePrefix(Path.from("pool")); const serving = (async () => { for await (const request of prefix.requested()) request.serve(source.consume()); })(); const request = origin.follow(Path.from("pool/job")); await settle(); - expect(request.active.peek()?.instance).toBe(prefix.route.instance); - const belowPublication = origin.createBroadcast(Path.from("pool/job/thumb")); - const below = belowPublication.broadcast; - belowPublication.announce(); + expect(request.active.peek()?.instance).toBe(prefix.instance); + const belowRoute = origin.route(Path.from("pool/job/thumb")); + const below = belowRoute.broadcast; await settle(); - expect(request.active.peek()?.instance).toBe(prefix.route.instance); - const exactPublication = origin.createBroadcast(Path.from("pool/job")); - const exact = exactPublication.broadcast; - exactPublication.announce(); + expect(request.active.peek()?.instance).toBe(prefix.instance); + const exactRoute = origin.route(Path.from("pool/job")); + const exact = exactRoute.broadcast; await settle(); - expect(request.active.peek()?.instance).toBe(exactPublication.route?.instance); - prefix.updateRoute({ cost: 5n }); + expect(request.active.peek()?.instance).toBe(exactRoute.instance); + prefix.setCost(5n); await settle(); - expect(request.active.peek()?.instance).toBe(exactPublication.route?.instance); + expect(request.active.peek()?.instance).toBe(exactRoute.instance); exact.close(); await settle(); - expect(request.active.peek()?.instance).toBe(prefix.route.instance); + expect(request.active.peek()?.instance).toBe(prefix.instance); prefix.close(); await settle(); expect(request.active.peek()).toBeUndefined(); @@ -205,12 +196,11 @@ test("followers track the serving prefix, ignoring descendants and re-prices", a test("a follower ignores a covering route whose scope excludes its path", async () => { const origin = new Producer(); const scoped = origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.parse("room/*/chat")])); - const prefix = scoped.requestsRoute(Path.from("room/alice")); - const exactPublication = origin.createBroadcast(Path.from("room/alice")); - const exact = exactPublication.broadcast; - exactPublication.announce({ cost: 5n }); + const prefix = scoped.routePrefix(Path.from("room/alice")); + const exactRoute = origin.route(Path.from("room/alice"), { cost: 5n }); + const exact = exactRoute.broadcast; const request = origin.follow(Path.from("room/alice")); - expect(request.active.peek()?.instance).toBe(exactPublication.route?.instance); + expect(request.active.peek()?.instance).toBe(exactRoute.instance); exact.close(); await settle(); expect(request.active.peek()).toBeUndefined(); @@ -223,7 +213,7 @@ test("a follower tracks a route replaced by an identical one", async () => { const origin = new Producer(); const path = Path.from("room"); const serve = (source: BroadcastProducer) => { - const route = origin.requestsRoute(path); + const route = origin.routePrefix(path); void (async () => { for await (const request of route.requested()) request.serve(source.consume()); })(); @@ -233,7 +223,7 @@ test("a follower tracks a route replaced by an identical one", async () => { const first = serve(firstSource); const request = origin.follow(path); await settle(); - expect(request.active.peek()?.instance).toBe(first.route.instance); + expect(request.active.peek()?.instance).toBe(first.instance); // Same (default) route metadata: only the instance each claim minted differs. const secondSource = new BroadcastProducer(); @@ -241,7 +231,7 @@ test("a follower tracks a route replaced by an identical one", async () => { await settle(); first.close(); await settle(); - expect(request.active.peek()?.instance).toBe(second.route.instance); + expect(request.active.peek()?.instance).toBe(second.instance); request.close(); second.close(); @@ -254,7 +244,7 @@ test("an origin closing settles a follower a served route resolved", async () => const origin = new Producer(); const path = Path.from("room"); const source = new BroadcastProducer(); - const route = origin.requestsRoute(path); + const route = origin.routePrefix(path); void (async () => { for await (const request of route.requested()) request.serve(source.consume()); })(); @@ -273,14 +263,14 @@ test("an origin closing settles a follower a served route resolved", async () => test("a follower keeps a refusal that lands with a re-price", async () => { const origin = new Producer(); const path = Path.from("room"); - const route = origin.requestsRoute(path); + const route = origin.routePrefix(path); const requested = route.requested(); const request = origin.follow(path); const pending = (await requested.next()).value; if (!pending) throw new Error("expected a request"); // Both land in one turn: the watch notification must not retry the refused request. - route.updateRoute({ cost: 5n }); + route.setCost(5n); const denied = new Error("denied"); pending.reject(denied); await settle(); @@ -304,7 +294,7 @@ for (const received of [false, true]) { const events: string[] = []; const stop = wireOf(origin).interests((prefix, wanted) => events.push(`${prefix} ${wanted}`)); const source = new BroadcastProducer(); - const route = received ? wireOf(origin).receive(path, Route.default) : origin.requestsRoute(path); + const route = received ? wireOf(origin).receive(path, RouteInfo.default) : origin.routePrefix(path); void (async () => { for await (const request of route.requested()) request.serve(source.consume()); })(); @@ -325,55 +315,85 @@ for (const received of [false, true]) { }); } -test("a claim answer is hidden until published under its own instance", async () => { +test("a hidden job route is hidden until announced under its own instance", async () => { const origin = new Producer(); const path = Path.from("room/alice"); - const claim = origin.requests(Path.from("room")); + const claim = origin.routePrefix(Path.from("room")); const requests = claim.requested(); const request = origin.request(path); const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - const prepared = pending.prepare(); - prepared.broadcast.createTrack("video"); + const job = pending.route({ hidden: true }); + job.broadcast.createTrack("video"); await settle(); expect(request.active.peek()).toBeUndefined(); - const published = prepared.publish(); + job.announce(); await settle(); - expect(published.route?.instance).toBeDefined(); - expect(request.active.peek()?.instance).toBe(published.route?.instance); + expect(request.active.peek()?.instance).toBe(job.instance); request.close(); - published.broadcast.close(); + job.close(); claim.close(); origin.close(); }); -test("a prepared answer cannot announce itself before publish", async () => { +test("a visible job route answers its waiting requesters at once", async () => { const origin = new Producer(); const path = Path.from("room/alice"); - const claim = origin.requests(Path.from("room")); + const claim = origin.routePrefix(Path.from("room")); + const requests = claim.requested(); + const first = origin.request(path); + const pending = (await requests.next()).value; + if (!pending) throw new Error("expected a request"); + const shared = origin.request(path); + const job = pending.route(); + expect(job.announced).toBe(true); + expect(job.instance).not.toBe(claim.instance); + await settle(); + for (const request of [first, shared]) expect(request.active.peek()?.instance).toBe(job.instance); + // The request is answered: routing it again is refused. + expect(() => pending.route()).toThrow("request is closed"); + + // Ending the job withdraws only its path: the claim keeps answering later requests. + job.close(); + await settle(); + const later = origin.request(path); + const next = (await requests.next()).value; + if (!next) throw new Error("expected another request"); + const again = next.route({ instance: Instance.parse("stable"), epoch: 2n }); + await settle(); + expect(again.instance).toBe(Instance.parse("stable")); + expect(later.active.peek()?.instance).toBe(again.instance); + for (const request of [first, shared, later]) request.close(); + again.close(); + claim.close(); + origin.close(); +}); + +test("a hidden job route's broadcast cannot announce itself", async () => { + const origin = new Producer(); + const path = Path.from("room/alice"); + const claim = origin.routePrefix(Path.from("room")); const requests = claim.requested(); const request = origin.request(path); const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - const prepared = pending.prepare(); - expect(prepared.broadcast).not.toHaveProperty("announce"); - expect(prepared.broadcast).not.toHaveProperty("route"); + const job = pending.route({ hidden: true }); + expect(job.broadcast).not.toHaveProperty("announce"); + expect(job.broadcast).not.toHaveProperty("route"); await settle(); expect(request.active.peek()).toBeUndefined(); - const published = prepared.publish(); - const instance = published.route?.instance; - expect(instance).toBeDefined(); + job.announce(); await settle(); - expect(request.active.peek()?.instance).toBe(instance); + expect(request.active.peek()?.instance).toBe(job.instance); request.close(); - published.broadcast.close(); + job.close(); claim.close(); origin.close(); }); test("an application serves held content without an exact route", async () => { const origin = new Producer(); - const claim = origin.requests(Path.from("room")); + const claim = origin.routePrefix(Path.from("room")); const requests = claim.requested(); const request = origin.request(Path.from("room/alice")); const pending = (await requests.next()).value; @@ -392,20 +412,20 @@ test("an application serves held content without an exact route", async () => { origin.close(); }); -for (const withdraw of ["unannounce", "replace"] as const) { - test(`a published answer is not cached after ${withdraw}`, async () => { +for (const withdraw of ["withdraw", "replace"] as const) { + test(`a job's route is not cached after ${withdraw}`, async () => { const origin = new Producer(); - const claim = origin.requests(Path.from("room")); + const claim = origin.routePrefix(Path.from("room")); const requests = claim.requested(); const path = Path.from("room/alice"); const first = origin.request(path); const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - const publication = pending.prepare().publish(); + const job = pending.route(); await settle(); const held = first.active.peek()?.clone(); - if (withdraw === "unannounce") publication.unannounce(); - else origin.createBroadcast(path).broadcast.close(); + if (withdraw === "withdraw") job.withdraw(); + else origin.route(path, { hidden: true }).broadcast.close(); const next = origin.request(path); await settle(); expect(next.active.peek()).toBeUndefined(); @@ -415,41 +435,43 @@ for (const withdraw of ["unannounce", "replace"] as const) { held?.close(); next.close(); first.close(); - publication.broadcast.close(); + job.close(); claim.close(); origin.close(); }); } -test("closing a prepared answer refuses the request and closes its broadcast", async () => { +test("closing a hidden job route refuses the request and closes its broadcast", async () => { const origin = new Producer(); - const claim = origin.requests(Path.from("room")); + const claim = origin.routePrefix(Path.from("room")); const requests = claim.requested(); const request = origin.request(Path.from("room/alice")); const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - const prepared = pending.prepare(); - prepared.close(); - prepared.close(); - prepared[Symbol.dispose](); + const job = pending.route({ hidden: true }); + job.close(); + job.close(); + job[Symbol.dispose](); await settle(); expect(request.closed.peek()).toBeInstanceOf(Error); - expect(prepared.broadcast.closed.peek()).toBeDefined(); + expect(job.broadcast.closed.peek()).toBeDefined(); claim.close(); origin.close(); }); -test("an answer prepared for an abandoned claim is never announced", async () => { +test("a job route for an abandoned claim is never announced", async () => { const origin = new Producer(); const path = Path.from("room/alice"); - const claim = origin.requests(Path.from("room")); + const claim = origin.routePrefix(Path.from("room")); const requests = claim.requested(); const request = origin.request(path); const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - const prepared = pending.prepare(); + const job = pending.route({ hidden: true }); claim.close(); - expect(() => prepared.publish()).toThrow("request is closed"); + expect(() => job.announce()).toThrow("unroutable"); + expect(job.announced).toBe(false); + expect(job.broadcast.closed.peek()).toBeDefined(); const announced = origin.follow(path); await settle(); expect(announced.active.peek()).toBeUndefined(); @@ -459,31 +481,31 @@ test("an answer prepared for an abandoned claim is never announced", async () => }); for (const cleanup of ["close", "dispose", "broadcast"] as const) { - test(`prepared ${cleanup} releases shared requesters and admits a new request`, async () => { + test(`a hidden job route's ${cleanup} releases shared requesters and admits a new request`, async () => { const origin = new Producer(); const path = Path.from("room/alice"); - const claim = origin.requests(Path.from("room")); + const claim = origin.routePrefix(Path.from("room")); const requests = claim.requested(); const first = origin.request(path); const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - const prepared = pending.prepare(); + const job = pending.route({ hidden: true }); const shared = origin.request(path); - if (cleanup === "close") prepared.close(); - else if (cleanup === "dispose") prepared[Symbol.dispose](); - else prepared.broadcast.close(); + if (cleanup === "close") job.close(); + else if (cleanup === "dispose") job[Symbol.dispose](); + else job.broadcast.close(); // Requested in the same turn, so the release cannot wait on a reactive notification. const later = origin.request(path); await settle(); - prepared.close(); - prepared[Symbol.dispose](); + job.close(); + job[Symbol.dispose](); for (const request of [first, shared]) { expect(request.closed.peek()).toBeInstanceOf(StreamError); expect((request.closed.peek() as StreamError).code).toBe(StreamCode.Unroutable); } expect(later.closed.peek()).toBeUndefined(); - expect(() => prepared.publish()).toThrow("prepared answer is closed"); + expect(() => job.announce()).toThrow("broadcast is closed"); const next = (await requests.next()).value; if (!next) throw new Error("expected another request"); expect(next).not.toBe(pending); @@ -495,14 +517,14 @@ for (const cleanup of ["close", "dispose", "broadcast"] as const) { }); } -test("a throwing handler disposes its prepared answer and leaves the claim answerable", async () => { +test("a throwing handler disposes its job route and leaves the claim answerable", async () => { const origin = new Producer(); const path = Path.from("room/alice"); - const claim = origin.requests(Path.from("room")); + const claim = origin.routePrefix(Path.from("room")); const failed = (async () => { for await (const request of claim.requested()) { - using prepared = request.prepare(); - prepared.broadcast.createTrack("video"); + using job = request.route({ hidden: true }); + job.broadcast.createTrack("video"); throw new Error("handler failed"); } })(); @@ -515,8 +537,8 @@ test("a throwing handler disposes its prepared answer and leaves the claim answe const pending = (await requests.next()).value; if (!pending) throw new Error("expected another request"); { - using prepared = pending.prepare(); - prepared.close(); + using job = pending.route({ hidden: true }); + job.close(); } await settle(); expect((later.closed.peek() as StreamError).code).toBe(StreamCode.Unroutable); @@ -524,44 +546,40 @@ test("a throwing handler disposes its prepared answer and leaves the claim answe origin.close(); }); -test("using transfers a published answer without closing it on disposal", async () => { +test("announcing a job route again keeps it answering under one instance", async () => { const origin = new Producer(); const path = Path.from("room/alice"); - const claim = origin.requests(Path.from("room")); + const claim = origin.routePrefix(Path.from("room")); const requests = claim.requested(); const request = origin.request(path); const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - let published: Publication; - { - using prepared = pending.prepare(); - prepared.broadcast.createTrack("data").writeFrame({ payload: new TextEncoder().encode("published") }); - published = prepared.publish(); - expect(() => prepared.publish()).toThrow("prepared answer is closed"); - prepared.close(); - } + const job = pending.route({ hidden: true }); + job.broadcast.createTrack("data").writeFrame({ payload: new TextEncoder().encode("published") }); + job.announce(); + job.announce(); await settle(); - expect(published.broadcast.closed.peek()).toBeUndefined(); - expect(request.active.peek()?.instance).toBe(published.route?.instance); + expect(job.broadcast.closed.peek()).toBeUndefined(); + expect(request.active.peek()?.instance).toBe(job.instance); const reader = request.active.peek()?.track("data").subscribe().ordered(); expect(await reader?.readString()).toBe("published"); reader?.close(); request.close(); - published.broadcast.close(); + job.close(); claim.close(); origin.close(); }); -for (const cleanup of ["close", "dispose", "broadcast", "publish"] as const) { - test(`an old prepared ${cleanup} cannot refuse the next request for its path`, async () => { +for (const cleanup of ["close", "dispose", "broadcast", "announce"] as const) { + test(`an old job route's ${cleanup} cannot refuse the next request for its path`, async () => { const origin = new Producer(); const path = Path.from("room/alice"); - const claim = origin.requests(Path.from("room")); + const claim = origin.routePrefix(Path.from("room")); const requests = claim.requested(); const first = origin.request(path); const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - const old = pending.prepare(); + const old = pending.route({ hidden: true }); first.close(); await settle(); const later = origin.request(path); @@ -570,34 +588,33 @@ for (const cleanup of ["close", "dispose", "broadcast", "publish"] as const) { if (cleanup === "close") old.close(); else if (cleanup === "dispose") old[Symbol.dispose](); else if (cleanup === "broadcast") old.broadcast.close(); - else expect(() => old.publish()).toThrow("request is closed"); + else expect(() => old.announce()).toThrow("unroutable"); await settle(); expect(later.closed.peek()).toBeUndefined(); - using prepared = next.prepare(); - prepared.broadcast.createTrack("data").writeFrame({ payload: new TextEncoder().encode(cleanup) }); - const published = prepared.publish(); + using job = next.route({ hidden: true }); + job.broadcast.createTrack("data").writeFrame({ payload: new TextEncoder().encode(cleanup) }); + job.announce(); await settle(); - expect(later.active.peek()?.instance).toBe(published.route?.instance); + expect(later.active.peek()?.instance).toBe(job.instance); const reader = later.active.peek()?.track("data").subscribe().ordered(); expect(await reader?.readString()).toBe(cleanup); reader?.close(); old.close(); later.close(); - published.broadcast.close(); claim.close(); origin.close(); }); } -test("a forwarded request cannot be prepared by setting a publisher property", async () => { +test("a forwarded request cannot be routed by setting a publisher property", async () => { const origin = new Producer(); - const route = origin.requestsRoute(Path.from("room")); + const route = wireOf(origin).receive(Path.from("room")); const requests = route.requested(); const request = origin.request(Path.from("room/alice")); const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); Object.assign(pending, { publisher: origin }); - expect(() => pending.prepare()).toThrow("forwarded requests cannot be prepared"); + expect(() => pending.route()).toThrow("unroutable"); pending.reject(new Error("refused")); request.close(); route.close(); @@ -611,7 +628,7 @@ test("an instance-pinned follower resumes when its instance returns after a gap" const source = new BroadcastProducer(); const keeper = source.consume(); const serve = (instance: Instance.Valid, broadcast: BroadcastProducer) => { - const route = origin.requestsRoute(path, { instance: instance }); + const route = origin.routePrefix(path, { instance: instance }); void (async () => { for await (const request of route.requested()) request.serve(broadcast.consume()); })(); @@ -681,10 +698,9 @@ test("a follower keeps its scoped discovery across instances until closed", asyn synced?.(); await settle(); expect(follower.closed.peek()).toBeUndefined(); - const publication = origin.createBroadcast(path); - publication.announce(); + const publication = origin.route(path); await settle(); - expect(follower.active.peek()?.instance).toBe(publication.route?.instance); + expect(follower.active.peek()?.instance).toBe(publication.instance); publication.broadcast.close(); await settle(); // The instance ending keeps the follower and its discovery open for the next one. @@ -763,7 +779,7 @@ test("a pending request waits for a session before concluding absence", async () test("a follower retains a selected handler's explicit unroutable refusal", async () => { const origin = new Producer(); const path = Path.from("room/audio"); - const route = origin.requestsRoute(path); + const route = origin.routePrefix(path); const pending = route.requested(); const requested = origin.follow(path); const request = (await pending.next()).value; @@ -780,25 +796,24 @@ test("a follower retains a selected handler's explicit unroutable refusal", asyn test("a pending request retries a route gap and never retargets after resolving", async () => { const origin = new Producer(); const path = Path.from("room/audio"); - const first = origin.requestsRoute(path); + const first = origin.routePrefix(path); const requested = origin.request(path); const before = await first.requested().next(); expect(before.value).toBeDefined(); first.close(); await settle(); expect(requested.closed.peek()).toBeUndefined(); - const second = origin.requestsRoute(path); + const second = origin.routePrefix(path); const pending = (await second.requested().next()).value; if (!pending) throw new Error("replacement route was not requested"); const source = new BroadcastProducer(); const keeper = source.consume(); pending.serve(source.consume()); await settle(); - expect(requested.active.peek()?.instance).toBe(second.route.instance); - const replacement = origin.createBroadcast(path); - replacement.announce(); + expect(requested.active.peek()?.instance).toBe(second.instance); + const replacement = origin.route(path); await settle(); - expect(requested.active.peek()?.instance).toBe(second.route.instance); + expect(requested.active.peek()?.instance).toBe(second.instance); second.close(); await settle(); expect(requested.closed.peek()).toBeInstanceOf(StreamError); @@ -834,8 +849,8 @@ test.each(["request", "follow"] as const)("a %s pinned to a losing instance reso const origin = new Producer(); const path = Path.from("room/audio"); const pinned = Instance.random(); - const losing = origin.requestsRoute(path, { instance: pinned, cost: 9n }); - const winning = origin.requestsRoute(path, { instance: Instance.random(), cost: 1n }); + const losing = origin.routePrefix(path, { instance: pinned, cost: 9n }); + const winning = origin.routePrefix(path, { instance: Instance.random(), cost: 1n }); const asked = losing.requested(); const requested = origin[method](path, { instance: pinned }); const pending = (await asked.next()).value; @@ -855,12 +870,12 @@ test.each(["request", "follow"] as const)("a %s pinned to a losing instance reso const other = new BroadcastProducer(); answer.serve(other.consume()); await settle(); - expect(plain.active.peek()?.instance).toBe(winning.route.instance); + expect(plain.active.peek()?.instance).toBe(winning.instance); requested.close(); again.close(); await settle(); - expect(plain.active.peek()?.instance).toBe(winning.route.instance); + expect(plain.active.peek()?.instance).toBe(winning.instance); plain.close(); source.close(); other.close(); @@ -873,10 +888,9 @@ test("a peer's pin is served by a local broadcast that loses the path", async () const origin = new Producer(); const wire = wireOf(origin.consume()); const path = Path.from("room/audio"); - const publication = origin.createBroadcast(path); const pinned = Instance.random(); - publication.announce({ instance: pinned, cost: 9n }); - const winning = origin.requestsRoute(path, { instance: Instance.random(), cost: 1n }); + const publication = origin.route(path, { instance: pinned, cost: 9n }); + const winning = origin.routePrefix(path, { instance: Instance.random(), cost: 1n }); expect(wire.local(path)).toBeUndefined(); expect(wire.local(path, pinned)).toBeDefined(); expect(await wire.demand(path, pinned)).toBeDefined(); diff --git a/js/net/src/origin.test.ts b/js/net/src/origin.test.ts index a26e5198008..f09a3d4e126 100644 --- a/js/net/src/origin.test.ts +++ b/js/net/src/origin.test.ts @@ -4,7 +4,7 @@ import { getter, Once, race, Signal } from "@moq/signals"; import { announcedView } from "./announced.test-util"; import { type Consumer as BroadcastConsumer, Producer as BroadcastProducer } from "./broadcast.ts"; import { StreamCode, StreamError } from "./error.ts"; -import { HopSchema, Route } from "./hop.ts"; +import { type Cost, HopSchema, RouteInfo } from "./hop.ts"; import * as Instance from "./instance.ts"; import { chainHash, presented, spreadHash } from "./internal.ts"; import { SessionBroadcast, textFrame } from "./mock.ts"; @@ -16,9 +16,8 @@ import { Timescale } from "./time.ts"; import { overrideBroadcastWire, wireOf } from "./wire.ts"; function publish(origin: Producer, path: Path.Valid) { - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(path); + const broadcast = broadcastRoute.broadcast; return broadcast; } @@ -28,7 +27,12 @@ const PEER = HopSchema.parse(10n); const INSTANCE = Instance.parse("01900000-0000-7000-8000-000000000001"); /** Land a received prefix, served from `consume`, the way a session does. */ -function serve(origin: Producer, prefix: Path.Valid, consume: () => BroadcastConsumer, route: Route = Route.default) { +function serve( + origin: Producer, + prefix: Path.Valid, + consume: () => BroadcastConsumer, + route: RouteInfo = RouteInfo.default, +) { const handle = wireOf(origin).receive(prefix, route); void (async () => { try { @@ -72,35 +76,35 @@ test("a borrowed table exposes dynamic serving and a live scoped broadcast map", const table: Table = origin; const scope = Path.Pattern.parse("room/**"); const live = await announcedView(table, scope); - const changes: ReadonlyMap[] = []; + const changes: ReadonlyMap[] = []; const stop = live.subscribe((value) => changes.push(value)); await new Promise((resolve) => setImmediate(resolve)); expect(live.peek().size).toBe(0); const other = publish(origin, Path.from("other")); const localPath = Path.from("room/alice"); - const localPublication = table.createBroadcast(localPath); - const local = localPublication.broadcast; + const localRoute = table.route(localPath, { hidden: true, instance: INSTANCE, cost: 4n }); + const local = localRoute.broadcast; await new Promise((resolve) => setImmediate(resolve)); expect(live.peek().has(localPath)).toBe(false); await new Promise((resolve) => setImmediate(resolve)); expect(live.peek().has(Path.from("other"))).toBe(false); - localPublication.announce({ instance: INSTANCE, cost: 4n }); + localRoute.announce(); await settle(); await new Promise((resolve) => setImmediate(resolve)); - expect(live.peek().get(localPath)).toEqual(Route.normalize({ instance: INSTANCE, cost: 4n })); + expect(live.peek().get(localPath)).toEqual(RouteInfo.normalize({ instance: INSTANCE, cost: 4n })); await new Promise((resolve) => setImmediate(resolve)); expect(changes.some((value) => value.get(localPath)?.cost === 4n)).toBe(true); const prefix = Path.from("room"); - const dynamic = table.requestsRoute(prefix, { cost: 2n }); + const dynamic = table.routePrefix(prefix, { cost: 2n }); await new Promise((resolve) => setImmediate(resolve)); - expect(live.peek().get(prefix)).toEqual(Route.normalize({ ...dynamic.route, cost: 2n })); - dynamic.updateRoute({ cost: 3n }); + expect(live.peek().get(prefix)).toEqual(RouteInfo.normalize({ ...wireOf(dynamic).info, cost: 2n })); + dynamic.setCost(3n); await settle(); await new Promise((resolve) => setImmediate(resolve)); - expect(live.peek().get(prefix)).toEqual(Route.normalize({ ...dynamic.route, cost: 3n })); + expect(live.peek().get(prefix)).toEqual(RouteInfo.normalize({ ...wireOf(dynamic).info, cost: 3n })); dynamic.close(); local.close(); @@ -119,26 +123,26 @@ test("an announced local path competes with a received route on cost", async () const remote = wireOf(origin).receive(path, { instance: INSTANCE, hops: [PEER], cost: 5n }); const live = await announcedView(consumer); await new Promise((resolve) => setImmediate(resolve)); - expect(live.peek().get(path)).toEqual(Route.normalize({ instance: INSTANCE, hops: [PEER], cost: 5n })); + expect(live.peek().get(path)).toEqual(RouteInfo.normalize({ instance: INSTANCE, hops: [PEER], cost: 5n })); // Unannounced, it competes for nothing. - const localPublication = origin.createBroadcast(path); - const local = localPublication.broadcast; + const localRoute = origin.route(path, { hidden: true, instance: INSTANCE, cost: 9n }); + const local = localRoute.broadcast; await new Promise((resolve) => setImmediate(resolve)); - expect(live.peek().get(path)).toEqual(Route.normalize({ instance: INSTANCE, hops: [PEER], cost: 5n })); + expect(live.peek().get(path)).toEqual(RouteInfo.normalize({ instance: INSTANCE, hops: [PEER], cost: 5n })); // Cheaper wins; a tie falls to the local broadcast. - localPublication.announce({ instance: INSTANCE, cost: 9n }); + localRoute.announce(); await new Promise((resolve) => setImmediate(resolve)); - expect(live.peek().get(path)).toEqual(Route.normalize({ instance: INSTANCE, hops: [PEER], cost: 5n })); - localPublication.announce({ instance: INSTANCE, cost: 5n }); + expect(live.peek().get(path)).toEqual(RouteInfo.normalize({ instance: INSTANCE, hops: [PEER], cost: 5n })); + localRoute.setCost(5n); await new Promise((resolve) => setImmediate(resolve)); - expect(live.peek().get(path)).toEqual(Route.normalize({ instance: INSTANCE, cost: 5n })); + expect(live.peek().get(path)).toEqual(RouteInfo.normalize({ instance: INSTANCE, cost: 5n })); local.close(); await settle(); await new Promise((resolve) => setImmediate(resolve)); - expect(live.peek().get(path)).toEqual(Route.normalize({ instance: INSTANCE, hops: [PEER], cost: 5n })); + expect(live.peek().get(path)).toEqual(RouteInfo.normalize({ instance: INSTANCE, hops: [PEER], cost: 5n })); remote.close(); await settle(); @@ -159,7 +163,7 @@ test("a scoped route remains visible when an exact local path is outside the sco await new Promise((resolve) => setImmediate(resolve)); - expect((await announcedView(origin)).peek().get(path)).toMatchObject(Route.default); + expect((await announcedView(origin)).peek().get(path)).toMatchObject(RouteInfo.default); await new Promise((resolve) => setImmediate(resolve)); expect(live.peek().get(path)).toMatchObject({ cost: 5n }); @@ -261,7 +265,7 @@ test("a superseded broadcast closes, and its subscribers keep reading", async () const consumer = origin.consume(); const path = Path.from("room"); - const publication = origin.createBroadcast(path); + const publication = origin.route(path, { hidden: true }); const first = publication.broadcast; const track = first.createTrack("video", { timescale: Timescale.MILLI }); publication.announce(); @@ -269,13 +273,12 @@ test("a superseded broadcast closes, and its subscribers keep reading", async () const subscriber = mine?.track("video").subscribe(); if (!subscriber) throw new Error("expected a subscriber"); - const replacement = origin.createBroadcast(path); - replacement.announce(); + const replacement = origin.route(path); // The origin closes the old producer itself, whoever still holds a handle on it. expect(first.closed.peek()).toBeNull(); // Its stale publication never displaces or retracts the replacement. - expect(() => publication.announce({ instance: INSTANCE })).toThrow("broadcast is closed"); - publication.unannounce(); + expect(() => publication.announce()).toThrow("broadcast is closed"); + publication.withdraw(); const current = await routed(consumer, path); expect(readsFrom(current, replacement.broadcast)).toBe(true); current?.close(); @@ -390,7 +393,7 @@ test("a remote entry resolves by path and retracts on dispose", async () => { // Announced streams include remote entries. const announced = consumer.announced(); - expect(await announced.next()).toMatchObject({ prefix: path, kind: "start", route: Route.default }); + expect(await announced.next()).toMatchObject({ prefix: path, kind: "start", route: RouteInfo.default }); dispose(); expect(await announced.next()).toMatchObject({ prefix: path, kind: "end" }); @@ -442,7 +445,7 @@ test("a local publish shadows a remote entry", async () => { // One path, one announcement, even though both tables route it. const announced = consumer.announced(); - expect(await announced.next()).toMatchObject({ prefix: path, kind: "start", route: Route.default }); + expect(await announced.next()).toMatchObject({ prefix: path, kind: "start", route: RouteInfo.default }); // Dropping the local publish falls back to the remote entry without a retraction. local.close(); @@ -671,7 +674,7 @@ test("an identical reconnect restarts without an instance and is quiet with one" const consumer = origin.consume(); const path = Path.from("room"); const announced = consumer.announced(); - const route = Route.normalize({ instance, hops: [PEER] }); + const route = RouteInfo.normalize({ instance, hops: [PEER] }); const old = wireOf(origin).receive(path, route); expect(await announced.next()).toMatchObject({ prefix: path, kind: "start" }); @@ -682,7 +685,7 @@ test("an identical reconnect restarts without an instance and is quiet with one" // Retracting the stale twin is quiet, and a re-price of the winner is an update. old.close(); - fresh.updateRoute({ ...route, cost: 5n }); + wireOf(fresh).update({ ...route, cost: 5n }); expect(await announced.next()).toMatchObject({ prefix: path, kind: "update", route: { cost: 5n } }); fresh.close(); @@ -976,47 +979,56 @@ test("a seeded route still notifies when it retracts", async () => { origin.close(); }); -test("createBroadcast is invisible to everyone until announce", async () => { +test("a hidden route is invisible to everyone until announce", async () => { const origin = new Producer(); const consumer = origin.consume(); const path = Path.from("room"); - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = origin.route(path, { hidden: true, cost: 4n }); + const broadcast = broadcastRoute.broadcast; expect(wireOf(consumer).routes(path)).toBe(false); expect(wireOf(consumer).advertised.peek()?.has(path)).toBe(false); const request = consumer.request(path); expect(request.active.peek()).toBeUndefined(); const announced = consumer.announced(); - broadcastPublication.announce({ cost: 4n }); + expect(broadcastRoute.announced).toBe(false); + broadcastRoute.announce(); + expect(broadcastRoute.announced).toBe(true); expect(wireOf(consumer).routes(path)).toBe(true); expect(wireOf(consumer).advertised.peek()?.has(path)).toBe(true); expect(await announced.next()).toMatchObject({ prefix: path, kind: "start", - route: { hops: [], cost: 4n }, + route: { instance: broadcastRoute.instance, hops: [], cost: 4n }, }); const first = request.active.peek(); - expect(first).toBeDefined(); + expect(first?.instance).toBe(broadcastRoute.instance); // Off the air for local consumers and peers alike, which ends the request on it. - broadcastPublication.unannounce(); + broadcastRoute.withdraw(); expect(wireOf(consumer).routes(path)).toBe(false); expect(wireOf(consumer).advertised.peek()?.has(path)).toBe(false); expect(await announced.next()).toMatchObject({ prefix: path, kind: "end" }); expect(request.active.peek()).toBeUndefined(); expect(request.closed.peek()).toBeInstanceOf(Error); - // Back on the air for a fresh request, through a fresh handle. - broadcastPublication.announce(); - expect(await announced.next()).toMatchObject({ prefix: path, kind: "start" }); + // Back on the air for a fresh request, through a fresh handle, continuing the same instance. + const instance = broadcastRoute.instance; + broadcastRoute.announce(); + expect(await announced.next()).toMatchObject({ prefix: path, kind: "start", route: { instance } }); const fresh = consumer.request(path); const again = fresh.active.peek(); expect(again).toBeDefined(); expect(again).not.toBe(first); + expect(again?.instance).toBe(instance); + // Closing the broadcast retracts the route at once, for good. broadcast.close(); + expect(broadcastRoute.announced).toBe(false); + expect(wireOf(consumer).routes(path)).toBe(false); + expect(() => broadcastRoute.announce()).toThrow("broadcast is closed"); + expect(() => broadcastRoute.setCost(1n)).toThrow("broadcast is closed"); expect(await announced.next()).toMatchObject({ prefix: path, kind: "end" }); fresh.close(); request.close(); @@ -1024,6 +1036,67 @@ test("createBroadcast is invisible to everyone until announce", async () => { origin.close(); }); +test("a prefix route can start hidden, withdraw and come back while it keeps yielding requests", async () => { + const origin = new Producer(); + const consumer = origin.consume(); + const prefix = Path.from("jobs"); + const path = Path.from("jobs/a"); + const route = origin.routePrefix(prefix, { hidden: true, cost: 3n }); + expect(() => route.broadcast).toThrow("a prefix route owns no broadcast"); + expect(route.announced).toBe(false); + expect(wireOf(consumer).routes(path)).toBe(false); + const requests = route.requested(); + + route.announce(); + expect(route.announced).toBe(true); + expect(wireOf(consumer).advertised.peek()?.get(prefix)?.[0]?.route).toEqual( + RouteInfo.normalize({ instance: route.instance, cost: 3n }), + ); + const first = consumer.request(path); + const asked = (await requests.next()).value; + if (!asked) throw new Error("expected a request"); + + // Withdrawn, the route answers nothing: the handler's late answer is dropped, and the request + // waits for a route, as it would between reconnects. + route.withdraw(); + expect(route.announced).toBe(false); + expect(wireOf(consumer).routes(path)).toBe(false); + const dropped = new BroadcastProducer(); + asked.serve(dropped); + await settle(); + expect(first.active.peek()).toBeUndefined(); + + // Back under the same instance, the same iterator yields the request again. + const instance = route.instance; + route.announce(); + expect(route.instance).toBe(instance); + const second = consumer.request(path); + const next = (await requests.next()).value; + if (!next) throw new Error("expected another request"); + const source = new BroadcastProducer(); + next.serve(source); + await settle(); + for (const request of [first, second]) expect(request.active.peek()?.instance).toBe(instance); + + first.close(); + second.close(); + dropped.close(); + route.close(); + expect((await requests.next()).done).toBe(true); + expect(() => route.announce()).toThrow("route is closed"); + source.close(); + origin.close(); +}); + +test("an exact route yields no requests", async () => { + const origin = new Producer(); + const route = origin.route(Path.from("room")); + expect((await route.requested().next()).done).toBe(true); + route.close(); + expect(route.broadcast.closed.peek()).toBeNull(); + origin.close(); +}); + test("a request prefers a cheaper received route over an announced local broadcast", async () => { const origin = new Producer(); const consumer = origin.consume(); @@ -1033,11 +1106,10 @@ test("a request prefers a cheaper received route over an announced local broadca origin, path, provider(upstream), - Route.normalize({ instance: INSTANCE, hops: [PEER], cost: 1n }), + RouteInfo.normalize({ instance: INSTANCE, hops: [PEER], cost: 1n }), ); - const localPublication = origin.createBroadcast(path); - const local = localPublication.broadcast; - localPublication.announce({ instance: INSTANCE, cost: 3n }); + const localRoute = origin.route(path, { instance: INSTANCE, cost: 3n }); + const local = localRoute.broadcast; // The cheaper route is served on demand, so it resolves only once its handler answers. const request = consumer.request(path); @@ -1050,7 +1122,7 @@ test("a request prefers a cheaper received route over an announced local broadca // Re-priced below it, the local broadcast of the same instance wins at once: the request's // broadcast stays, and its tracks read the local one. - localPublication.announce({ instance: INSTANCE, cost: 0n }); + localRoute.setCost(0n); expect(await announced.next()).toMatchObject({ prefix: path, kind: "update", @@ -1077,16 +1149,25 @@ test("the cheapest received route competes with the local broadcast, not the new served.push(name); return upstream.consume(); }; - const cheap = serve(origin, path, via("cheap"), Route.normalize({ instance: INSTANCE, hops: [PEER], cost: 1n })); - const pricey = serve(origin, path, via("pricey"), Route.normalize({ instance: INSTANCE, hops: [PEER], cost: 10n })); - const localPublication = origin.createBroadcast(path); - const local = localPublication.broadcast; - localPublication.announce({ instance: INSTANCE, cost: 5n }); + const cheap = serve( + origin, + path, + via("cheap"), + RouteInfo.normalize({ instance: INSTANCE, hops: [PEER], cost: 1n }), + ); + const pricey = serve( + origin, + path, + via("pricey"), + RouteInfo.normalize({ instance: INSTANCE, hops: [PEER], cost: 10n }), + ); + const localRoute = origin.route(path, { instance: INSTANCE, cost: 5n }); + const local = localRoute.broadcast; await new Promise((resolve) => setImmediate(resolve)); expect((await announcedView(consumer)).peek().get(path)).toEqual( - Route.normalize({ instance: INSTANCE, hops: [PEER], cost: 1n }), + RouteInfo.normalize({ instance: INSTANCE, hops: [PEER], cost: 1n }), ); const request = consumer.request(path); await settle(); @@ -1106,7 +1187,7 @@ test("the cheapest received route competes with the local broadcast, not the new test("a handle serves a request under live", async () => { const origin = new Producer(); const consumer = origin.consume(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); expect(await consumer.announced().next()).toMatchObject({ prefix: Path.from("live"), kind: "start" }); @@ -1133,7 +1214,7 @@ test("a handle serves a request under live", async () => { test("an originated route serves held content a session delivered", async () => { const origin = new Producer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const it = handle.requested(); const pending = wireOf(origin.consume()).demand(Path.from("live/cam")); const { value: req } = await it.next(); @@ -1171,10 +1252,10 @@ test("a received route still serves a broadcast a session delivered", async () = test("a re-priced route is delivered as an update", async () => { const origin = new Producer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const announced = origin.consume().announced(); expect(await announced.next()).toMatchObject({ prefix: Path.from("live"), kind: "start" }); - handle.updateRoute({ cost: 5n }); + handle.setCost(5n); expect(await announced.next()).toMatchObject({ prefix: Path.from("live"), kind: "update" }); handle.close(); expect(await announced.next()).toMatchObject({ prefix: Path.from("live"), kind: "end" }); @@ -1184,7 +1265,7 @@ test("a re-priced route is delivered as an update", async () => { test("an accepted dynamic broadcast is retired when it closes, and its handle resumes", async () => { const origin = new Producer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const path = Path.from("live/cam"); const request = origin.request(path); const it = handle.requested(); @@ -1218,7 +1299,7 @@ test("an accepted dynamic broadcast is retired when it closes, and its handle re test("reject surfaces the error from demand", async () => { const origin = new Producer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const consumer = origin.consume(); const it = handle.requested(); const pending = wireOf(consumer).demand(Path.from("live/cam")); @@ -1235,11 +1316,11 @@ test("a peer is offered and served the cheapest originated route", async () => { const origin = new Producer(); const consumer = origin.consume(); const prefix = Path.from("live"); - const cheap = origin.requestsRoute(prefix, { instance: INSTANCE, cost: 1n }); - const pricey = origin.requestsRoute(prefix, { instance: INSTANCE, cost: 10n }); + const cheap = origin.routePrefix(prefix, { instance: INSTANCE, cost: 1n }); + const pricey = origin.routePrefix(prefix, { instance: INSTANCE, cost: 10n }); expect(wireOf(consumer).advertised.peek()?.get(prefix)?.[0]?.route).toEqual( - Route.normalize({ instance: INSTANCE, cost: 1n }), + RouteInfo.normalize({ instance: INSTANCE, cost: 1n }), ); const pending = wireOf(consumer).demand(Path.from("live/cam")); const { value: req } = await cheap.requested().next(); @@ -1248,15 +1329,14 @@ test("a peer is offered and served the cheapest originated route", async () => { expect(await pending).toBeDefined(); // An exact-path local broadcast competes with them on cost too. - const localPublication = origin.createBroadcast(prefix); - const local = localPublication.broadcast; - localPublication.announce({ instance: INSTANCE, cost: 5n }); + const localRoute = origin.route(prefix, { instance: INSTANCE, cost: 5n }); + const local = localRoute.broadcast; expect(wireOf(consumer).advertised.peek()?.get(prefix)?.[0]?.route).toEqual( - Route.normalize({ instance: INSTANCE, cost: 1n }), + RouteInfo.normalize({ instance: INSTANCE, cost: 1n }), ); - localPublication.announce({ instance: INSTANCE, cost: 0n }); + localRoute.setCost(0n); expect(wireOf(consumer).advertised.peek()?.get(prefix)?.[0]?.route).toEqual( - Route.normalize({ instance: INSTANCE, cost: 0n }), + RouteInfo.normalize({ instance: INSTANCE, cost: 0n }), ); local.close(); @@ -1268,7 +1348,7 @@ test("a peer is offered and served the cheapest originated route", async () => { test("a shared reject still surfaces from demand", async () => { const origin = new Producer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const consumer = origin.consume(); const it = handle.requested(); @@ -1290,7 +1370,7 @@ test("a shared reject still surfaces from demand", async () => { test("a request refusal does not keep demand from asking again", async () => { const origin = new Producer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const consumer = origin.consume(); const it = handle.requested(); @@ -1314,7 +1394,7 @@ test("a request refusal does not keep demand from asking again", async () => { test("advancing requested without settling rejects the previous request", async () => { const origin = new Producer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const consumer = origin.consume(); const it = handle.requested(); @@ -1338,7 +1418,7 @@ test("advancing requested without settling rejects the previous request", async test("a rejected request is not asked of the same route again", async () => { const origin = new Producer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const it = handle.requested(); const request = origin.request(Path.from("live/cam")); @@ -1373,7 +1453,7 @@ test("an outranked route keeps serving until its replacement answers", async () const older = new BroadcastProducer(); const keepOlder = older.consume(); - const disposeOlder = serve(origin, path, () => keepOlder.clone(), Route.normalize({ instance: INSTANCE })); + const disposeOlder = serve(origin, path, () => keepOlder.clone(), RouteInfo.normalize({ instance: INSTANCE })); const request = consumer.request(path); await settle(); @@ -1493,16 +1573,21 @@ test("a request on a replaced instance fails over to another route of it", async const primary = new BroadcastProducer(); const keepPrimary = primary.consume(); - const disposePrimary = serve(origin, path, () => keepPrimary.clone(), Route.normalize({ instance: INSTANCE })); + const disposePrimary = serve(origin, path, () => keepPrimary.clone(), RouteInfo.normalize({ instance: INSTANCE })); const replica = new BroadcastProducer(); - const disposeReplica = serve(origin, path, provider(replica), Route.normalize({ instance: INSTANCE, cost: 5n })); + const disposeReplica = serve( + origin, + path, + provider(replica), + RouteInfo.normalize({ instance: INSTANCE, cost: 5n }), + ); const request = consumer.request(path); await settle(); const first = request.active.peek(); expect(first).toBeDefined(); const restarted = new BroadcastProducer(); - const disposeRestarted = serve(origin, path, provider(restarted), Route.normalize({ instance: newer })); + const disposeRestarted = serve(origin, path, provider(restarted), RouteInfo.normalize({ instance: newer })); await settle(); expect(request.active.peek()).toBe(first); @@ -1541,17 +1626,16 @@ test("a request on a replaced instance fails over to a local replica of it", asy const primary = new BroadcastProducer(); const keepPrimary = primary.consume(); - const disposePrimary = serve(origin, path, () => keepPrimary.clone(), Route.normalize({ instance: INSTANCE })); - const localPublication = origin.createBroadcast(path); - const local = localPublication.broadcast; - localPublication.announce({ instance: INSTANCE, cost: 5n }); + const disposePrimary = serve(origin, path, () => keepPrimary.clone(), RouteInfo.normalize({ instance: INSTANCE })); + const localRoute = origin.route(path, { instance: INSTANCE, cost: 5n }); + const local = localRoute.broadcast; const request = consumer.request(path); await settle(); const first = request.active.peek(); expect(first).toBeDefined(); const restarted = new BroadcastProducer(); - const disposeRestarted = serve(origin, path, provider(restarted), Route.normalize({ instance: newer })); + const disposeRestarted = serve(origin, path, provider(restarted), RouteInfo.normalize({ instance: newer })); await settle(); expect(request.active.peek()).toBe(first); @@ -1584,10 +1668,9 @@ test("a stale takeover's refusal leaves a request whose source came back", async const path = Path.from("resumed"); const newer = Instance.parse("01900000-0000-7000-8000-000000000002"); - const localPublication = origin.createBroadcast(path); - const local = localPublication.broadcast; - localPublication.announce({ instance: INSTANCE, cost: 2n }); - const standby = wireOf(origin).receive(path, Route.normalize({ instance: INSTANCE, cost: 5n })); + const localRoute = origin.route(path, { instance: INSTANCE, cost: 2n }); + const local = localRoute.broadcast; + const standby = wireOf(origin).receive(path, RouteInfo.normalize({ instance: INSTANCE, cost: 5n })); const asked = standby.requested(); const request = consumer.request(path); await settle(); @@ -1596,14 +1679,19 @@ test("a stale takeover's refusal leaves a request whose source came back", async const restarted = new BroadcastProducer(); // Another instance, cheaper, wins new requests. - const disposeRestarted = serve(origin, path, provider(restarted), Route.normalize({ instance: newer, cost: 1n })); + const disposeRestarted = serve( + origin, + path, + provider(restarted), + RouteInfo.normalize({ instance: newer, cost: 1n }), + ); await settle(); expect(request.active.peek()).toBe(first); // The local broadcast steps away, so the standby is asked to take over; it comes back first. - localPublication.unannounce(); + localRoute.withdraw(); const takeover = await asked.next(); - localPublication.announce({ instance: INSTANCE, cost: 2n }); + localRoute.announce(); await settle(); takeover.value?.reject(new Error("too late")); await settle(); @@ -1624,7 +1712,7 @@ test("a request ends when its winning source goes, even with a standby", async ( const path = Path.from("standby"); const standby = new BroadcastProducer(); - const disposeStandby = serve(origin, path, provider(standby), Route.normalize({ cost: 5n })); + const disposeStandby = serve(origin, path, provider(standby), RouteInfo.normalize({ cost: 5n })); const winner = new BroadcastProducer(); const keepWinner = winner.consume(); const disposeWinner = serve(origin, path, () => keepWinner.clone()); @@ -1654,8 +1742,8 @@ test("a request ends when its winning source goes, even with a standby", async ( test("a refusal is terminal, never falling through to a broader route", async () => { const origin = new Producer(); const consumer = origin.consume(); - const narrow = origin.requestsRoute(Path.from("live")); - const wide = origin.requestsRoute(Path.from("")); + const narrow = origin.routePrefix(Path.from("live")); + const wide = origin.routePrefix(Path.from("")); const wideRequests = wide.requested(); const wideAsked = wideRequests.next(); @@ -1682,7 +1770,7 @@ test("a better route's refusal ends a served request", async () => { const consumer = origin.consume(); const served = new BroadcastProducer(); // One instance, so the narrower route serves the same instance and the request follows it. - const disposeWide = serve(origin, Path.from(""), provider(served), Route.normalize({ instance: INSTANCE })); + const disposeWide = serve(origin, Path.from(""), provider(served), RouteInfo.normalize({ instance: INSTANCE })); const request = consumer.request(Path.from("live/cam")); await settle(); @@ -1691,8 +1779,8 @@ test("a better route's refusal ends a served request", async () => { // The narrower route is asked while the broad one keeps serving, then says no. A // costlier sibling at the same prefix could serve, but is never asked. - const narrow = origin.requestsRoute(Path.from("live"), { instance: INSTANCE, cost: 1n }); - const sibling = origin.requestsRoute(Path.from("live"), { instance: INSTANCE, cost: 2n }); + const narrow = origin.routePrefix(Path.from("live"), { instance: INSTANCE, cost: 1n }); + const sibling = origin.routePrefix(Path.from("live"), { instance: INSTANCE, cost: 2n }); const siblingRequests = sibling.requested(); const siblingAsked = siblingRequests.next(); const { value: req } = await narrow.requested().next(); @@ -1717,14 +1805,14 @@ test("a better route's refusal ends a served request", async () => { test("a refusal from a superseded route does not end the request", async () => { const origin = new Producer(); const consumer = origin.consume(); - const wide = origin.requestsRoute(Path.from("")); + const wide = origin.routePrefix(Path.from("")); const wideRequests = wide.requested(); const request = consumer.request(Path.from("live/cam")); const { value: stale } = await wideRequests.next(); // A narrower route takes over the pending request before the broad one answers. - const narrow = origin.requestsRoute(Path.from("live")); + const narrow = origin.routePrefix(Path.from("live")); const { value: req } = await narrow.requested().next(); stale?.reject(new Error("unserved")); await settle(); @@ -1746,7 +1834,7 @@ test("a refusal from a superseded route does not end the request", async () => { test("a refusal from a route a local broadcast superseded does not end the request", async () => { const origin = new Producer(); const consumer = origin.consume(); - const wide = origin.requestsRoute(Path.from("live")); + const wide = origin.routePrefix(Path.from("live")); const wideRequests = wide.requested(); const request = consumer.request(Path.from("live/cam")); @@ -1772,7 +1860,7 @@ test("a refusal from a route a local broadcast superseded does not end the reque test("close rejects queued requests as unroutable", async () => { const origin = new Producer(); - const handle = origin.requestsRoute(Path.from("live")); + const handle = origin.routePrefix(Path.from("live")); const waiting = handle.requested().next(); const request = origin.request(Path.from("live/cam")); const { value: req } = await waiting; @@ -1810,9 +1898,9 @@ test("announced lists full names while covering views and session advertisements const origin = new Producer(); const patterns = new Path.Patterns([Path.Pattern.parse("*.hang"), Path.Pattern.parse("**/*.chat")]); const reader = origin.scope(Path.from("project"), patterns).consume(); - const cam = origin.requestsRoute(Path.from("project/cam.hang")); - const overlap = origin.requestsRoute(Path.from("project/room/mic.hang")); - const chat = origin.requestsRoute(Path.from("project/lobby.chat")); + const cam = origin.routePrefix(Path.from("project/cam.hang")); + const overlap = origin.routePrefix(Path.from("project/room/mic.hang")); + const chat = origin.routePrefix(Path.from("project/lobby.chat")); const selected = await announcedView(reader); const covering = await announcedView(reader, undefined, { covering: true }); const all = [Path.from("cam.hang"), Path.from("lobby.chat"), Path.from("room/mic.hang")]; @@ -1820,10 +1908,10 @@ test("announced lists full names while covering views and session advertisements expect([...covering.peek().keys()].sort()).toEqual(all); expect(Array.from(wireOf(reader).advertised.peek()?.keys() ?? []).sort()).toEqual(all); - const nested = origin.requestsRoute(Path.from("project/room/lobby.chat")); + const nested = origin.routePrefix(Path.from("project/room/lobby.chat")); await new Promise((resolve) => setImmediate(resolve)); expect(selected.peek().has(Path.from("room/lobby.chat"))).toBe(true); - overlap.updateRoute({ cost: 2n }); + overlap.setCost(2n); overlap.close(); nested.close(); await new Promise((resolve) => setImmediate(resolve)); @@ -1843,7 +1931,7 @@ test("announced filters before rooting and retains lifecycle, routing and watch const interests: string[] = []; const unlisten = wireOf(origin).interests((prefix, wanted) => interests.push(`${wanted ? "+" : "-"}${prefix}`)); const source = new BroadcastProducer(); - const broad = origin.requestsRoute(Path.from("room")); + const broad = origin.routePrefix(Path.from("room")); const stream = reader.announced(); const events = stream[Symbol.asyncIterator](); const covering = await announcedView(reader, undefined, { covering: true }); @@ -1858,13 +1946,13 @@ test("announced filters before rooting and retains lifecycle, routing and watch expect(request.active.peek()).toBeDefined(); request.close(); - const exact = origin.requestsRoute(root, { instance: INSTANCE }); + const exact = origin.routePrefix(root, { instance: INSTANCE }); expect(await events.next()).toMatchObject({ value: { kind: "start", prefix: Path.empty(), captures: expect.any(Array) }, }); - exact.updateRoute({ instance: INSTANCE, cost: 2n }); + wireOf(exact).update({ instance: INSTANCE, cost: 2n }); expect(await events.next()).toMatchObject({ value: { kind: "update", route: { cost: 2n } } }); - exact.updateRoute({ instance: Instance.random() }); + wireOf(exact).update({ instance: Instance.random() }); expect(await events.next()).toMatchObject({ value: { kind: "restart" } }); exact.close(); expect(await events.next()).toMatchObject({ value: { kind: "end" } }); @@ -2006,11 +2094,11 @@ test("a rooted producer shares the table and enforces its pattern union", async await new Promise((resolve) => setImmediate(resolve)); expect(request.active.peek()).toBeDefined(); await new Promise((resolve) => setImmediate(resolve)); - expect(() => scoped.createBroadcast(Path.from("other")).broadcast).toThrow("outside the origin scope"); + expect(() => scoped.route(Path.from("other"), { hidden: true }).broadcast).toThrow("outside the origin scope"); await new Promise((resolve) => setImmediate(resolve)); expect(() => scoped.request(Path.from("room/alice/deep"))).toThrow("outside the origin scope"); await new Promise((resolve) => setImmediate(resolve)); - expect(() => scoped.requestsRoute(Path.from("other"))).toThrow("outside the origin scope"); + expect(() => scoped.routePrefix(Path.from("other"))).toThrow("outside the origin scope"); await new Promise((resolve) => setImmediate(resolve)); expect(() => scoped.scope(Path.empty(), new Path.Patterns([Path.Pattern.parse("other/**")]))).toThrow( "do not overlap", @@ -2022,7 +2110,7 @@ test("a rooted producer shares the table and enforces its pattern union", async await new Promise((resolve) => setImmediate(resolve)); expect([...(await announcedView(nested)).peek().keys()]).toEqual([Path.from("alice")]); await new Promise((resolve) => setImmediate(resolve)); - expect(() => nested.createBroadcast(Path.from("alice/deep")).broadcast).toThrow("outside the origin scope"); + expect(() => nested.route(Path.from("alice/deep"), { hidden: true }).broadcast).toThrow("outside the origin scope"); const announced = nested.announced(); await new Promise((resolve) => setImmediate(resolve)); expect(await announced.next()).toMatchObject({ kind: "start", prefix: Path.from("alice") }); @@ -2038,8 +2126,8 @@ test("closing a derived handle releases only what it registered", async () => { const scoped = origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.subtree(Path.from("room"))])); const wide = origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.all()])); const inside = publish(scoped, Path.from("room/alice")); - const claim = scoped.requests(Path.from("room/claim")); - const ranked = wide.requests(Path.from("ranked")); + const claim = scoped.routePrefix(Path.from("room/claim")); + const ranked = wide.routePrefix(Path.from("ranked")); const peer = serve(scoped, Path.from("room/peer"), provider(new BroadcastProducer())); scoped.close(); @@ -2052,8 +2140,8 @@ test("closing a derived handle releases only what it registered", async () => { expect([...routes.keys()]).toEqual([Path.from("lobby")]); // A released handle refuses new work, so a borrower notices instead of publishing into nothing. - expect(() => scoped.createBroadcast(Path.from("room/late")).broadcast).toThrow("origin handle is closed"); - scoped.requests(Path.from("room/late")).close(); + expect(() => scoped.route(Path.from("room/late"), { hidden: true }).broadcast).toThrow("origin handle is closed"); + scoped.routePrefix(Path.from("room/late")).close(); expect((await announcedView(origin)).peek().has(Path.from("room/late"))).toBe(false); // The owner and fresh handles keep working. @@ -2075,9 +2163,8 @@ test("a broadcast a derived handle released cannot announce again", async () => const consumer = origin.consume(); const scoped = origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.all()])); const path = Path.from("room"); - const publication = scoped.createBroadcast(path); + const publication = scoped.route(path); const broadcast = publication.broadcast; - publication.announce(); const held = await routed(consumer, path); scoped.close(); @@ -2152,9 +2239,8 @@ test("closing a derived handle withdraws the sessions and answers attached throu test("a scoped dynamic only serves allowed paths and presents relative requests", async () => { const origin = new Producer(); const scoped = origin.scope(Path.from("tenant"), new Path.Patterns([Path.Pattern.parse("room/*/chat")])); - const dynamic = scoped.requestsRoute(Path.from("room")); + const dynamic = scoped.routePrefix(Path.from("room")); await new Promise((resolve) => setImmediate(resolve)); - expect(dynamic.prefix).toBe(Path.from("room")); const denied = origin.request(Path.from("tenant/room/alice/video")); await new Promise((resolve) => setImmediate(resolve)); expect(denied.active.peek()).toBeUndefined(); @@ -2167,7 +2253,7 @@ test("a scoped dynamic only serves allowed paths and presents relative requests" pending.value.serve(broadcast); await new Promise((resolve) => setImmediate(resolve)); expect(request.active.peek()).toBeDefined(); - dynamic.updateRoute({ cost: 2n }); + dynamic.setCost(2n); await new Promise((resolve) => setImmediate(resolve)); expect((await announcedView(origin)).peek().get(Path.from("tenant/room"))?.cost).toBe(2n); await requests.return?.(); @@ -2200,7 +2286,7 @@ test("a scoped dynamic is announced only to readers its scope can serve", async const origin = new Producer(); const dynamic = origin .scope(Path.empty(), new Path.Patterns([Path.Pattern.parse("*/chat")])) - .requestsRoute(Path.empty()); + .routePrefix(Path.empty()); const chat = origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.parse("room/chat")])); const video = origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.parse("room/video")])); await new Promise((resolve) => setImmediate(resolve)); @@ -2217,8 +2303,8 @@ test("a scoped dynamic is announced only to readers its scope can serve", async test("a rooted reader presents the most specific covering route", async () => { const origin = new Producer(); - const narrow = origin.requestsRoute(Path.from("room/alice"), { cost: 9n }); - const broad = origin.requestsRoute(Path.from("room"), { cost: 1n }); + const narrow = origin.routePrefix(Path.from("room/alice"), { cost: 9n }); + const broad = origin.routePrefix(Path.from("room"), { cost: 1n }); const rooted = origin.scope(Path.from("room/alice"), new Path.Patterns([Path.Pattern.all()])); await new Promise((resolve) => setImmediate(resolve)); expect((await announcedView(rooted)).peek().get(Path.empty())?.cost).toBe(9n); @@ -2232,8 +2318,8 @@ test("a rooted reader presents the most specific covering route", async () => { test("a scoped reader picks the best route its scope can see at a prefix", async () => { const origin = new Producer(); const scoped = (pattern: string) => origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.parse(pattern)])); - const chat = scoped("*/chat").requestsRoute(Path.empty(), { cost: 1n }); - const video = scoped("*/video").requestsRoute(Path.empty(), { cost: 5n }); + const chat = scoped("*/chat").routePrefix(Path.empty(), { cost: 1n }); + const video = scoped("*/video").routePrefix(Path.empty(), { cost: 5n }); const reader = scoped("room/video"); await new Promise((resolve) => setImmediate(resolve)); @@ -2263,10 +2349,9 @@ test("a scoped reader sees a local broadcast that only loses to a route outside const origin = new Producer(); const chat = origin .scope(Path.empty(), new Path.Patterns([Path.Pattern.parse("room/*/chat")])) - .requestsRoute(Path.from("room/alice"), { instance: INSTANCE, cost: 0n }); - const localPublication = origin.createBroadcast(Path.from("room/alice")); - const local = localPublication.broadcast; - localPublication.announce({ instance: INSTANCE, cost: 5n }); + .routePrefix(Path.from("room/alice"), { instance: INSTANCE, cost: 0n }); + const localRoute = origin.route(Path.from("room/alice"), { instance: INSTANCE, cost: 5n }); + const local = localRoute.broadcast; const reader = origin.scope(Path.empty(), new Path.Patterns([Path.Pattern.parse("room/*")])); await new Promise((resolve) => setImmediate(resolve)); @@ -2298,7 +2383,7 @@ test("broadcast handles carry the path they were created or requested at", async expect(clone?.path).toBe(Path.from("room/alice")); // A dynamic handler's standalone broadcast is named by the request, too. - const dynamic = origin.requestsRoute(Path.from("live")); + const dynamic = origin.routePrefix(Path.from("live")); const request = origin.request(Path.from("live/bob")); const pending = await dynamic.requested().next(); const served = new BroadcastProducer(); @@ -2319,9 +2404,8 @@ test("a higher epoch of a dynamic route supersedes a cheaper local broadcast of const origin = new Producer(); const path = Path.from("camera"); const instance = Instance.random(); - const localPublication = origin.createBroadcast(path); - localPublication.announce({ instance, epoch: 1n, cost: 0n }); - const dynamic = origin.requestsRoute(path, { instance, epoch: 2n, cost: 10n }); + const localRoute = origin.route(path, { instance, epoch: 1n, cost: 0n }); + const dynamic = origin.routePrefix(path, { instance, epoch: 2n, cost: 10n }); const served = new BroadcastProducer(); const requests = dynamic.requested(); const request = origin.consume().request(path); @@ -2333,7 +2417,7 @@ test("a higher epoch of a dynamic route supersedes a cheaper local broadcast of request.close(); await requests.return?.(); dynamic.close(); - localPublication.broadcast.close(); + localRoute.broadcast.close(); served.close(); origin.close(); }); @@ -2342,10 +2426,9 @@ test("a higher epoch that is not the best route still supersedes a local broadca const origin = new Producer(); const path = Path.from("camera"); const stale = Instance.random(); - const localPublication = origin.createBroadcast(path); - localPublication.announce({ instance: stale, epoch: 1n, cost: 0n }); - const newer = origin.requestsRoute(path, { instance: stale, epoch: 2n, cost: 10n }); - const other = origin.requestsRoute(path, { instance: Instance.random(), cost: 5n }); + const localRoute = origin.route(path, { instance: stale, epoch: 1n, cost: 0n }); + const newer = origin.routePrefix(path, { instance: stale, epoch: 2n, cost: 10n }); + const other = origin.routePrefix(path, { instance: Instance.random(), cost: 5n }); const served = new BroadcastProducer(); const requests = other.requested(); const request = origin.consume().request(path); @@ -2358,7 +2441,7 @@ test("a higher epoch that is not the best route still supersedes a local broadca await requests.return?.(); other.close(); newer.close(); - localPublication.broadcast.close(); + localRoute.broadcast.close(); served.close(); origin.close(); }); @@ -2367,23 +2450,22 @@ test("a publisher weighs a local broadcast against the routes it may forward onl const origin = new Producer(); const path = Path.from("camera"); const instance = Instance.random(); - const localPublication = origin.createBroadcast(path); - localPublication.announce({ instance, epoch: 1n, cost: 0n }); - const originated = origin.requestsRoute(path, { cost: 5n }); + const localRoute = origin.route(path, { instance, epoch: 1n, cost: 0n }); + const originated = origin.routePrefix(path, { cost: 5n }); // A session delivered the higher epoch, which a publisher never forwards back out. const received = wireOf(origin).receive(path, { instance, epoch: 2n, cost: 10n, hops: [PEER] }); expect(wireOf(origin.consume()).local(path, instance)).toBeDefined(); received.close(); originated.close(); - localPublication.broadcast.close(); + localRoute.broadcast.close(); origin.close(); }); test("a scope's merged covering prefixes never supersede across prefixes", async () => { const origin = new Producer(); const instance = Instance.random(); - const room = origin.requestsRoute(Path.from("room"), { instance, epoch: 2n }); - const video = origin.requestsRoute(Path.from("room/video"), { instance, epoch: 1n }); + const room = origin.routePrefix(Path.from("room"), { instance, epoch: 2n }); + const video = origin.routePrefix(Path.from("room/video"), { instance, epoch: 1n }); const reader = origin.scope(Path.from("room/video"), new Path.Patterns([Path.Pattern.all()])).consume(); await settle(); const table = wireOf(reader).advertised.peek(); @@ -2400,14 +2482,14 @@ test("supersession only counts routes the reader can see", async () => { const instance = Instance.random(); const video = origin .scope(Path.empty(), new Path.Patterns([Path.Pattern.parse("*/video")])) - .requestsRoute(Path.empty(), { instance, epoch: 1n }); + .routePrefix(Path.empty(), { instance, epoch: 1n }); const live = await announcedView(origin, Path.Pattern.parse("room/video"), { covering: true }); await settle(); expect(live.peek().size).toBe(1); // A higher epoch the reader cannot see never hides the route it can. const chat = origin .scope(Path.empty(), new Path.Patterns([Path.Pattern.parse("*/chat")])) - .requestsRoute(Path.empty(), { instance, epoch: 2n }); + .routePrefix(Path.empty(), { instance, epoch: 2n }); await settle(); expect([...live.peek().values()].map((route) => route.epoch)).toEqual([1n]); chat.close(); @@ -2422,9 +2504,8 @@ test("the newest epoch of an instance is announced in place over a cheaper one", const announced = consumer.announced(); const instance = Instance.random(); - const oldPublication = origin.createBroadcast(path); - const old = oldPublication.broadcast; - oldPublication.announce({ instance, epoch: 1n, cost: 1n }); + const oldRoute = origin.route(path, { instance, epoch: 1n, cost: 1n }); + const old = oldRoute.broadcast; expect(await announced.next()).toMatchObject({ prefix: path, kind: "start" }); // A higher epoch of the same instance supersedes it despite the cost: the same stream. @@ -2450,14 +2531,14 @@ test("demand held across an instance change asks again, unless it named the old const origin = new Producer(); const consumer = origin.consume(); const path = Path.from("live/cam"); - const handle = origin.requestsRoute(Path.from("live"), { instance: INSTANCE }); + const handle = origin.routePrefix(Path.from("live"), { instance: INSTANCE }); const it = handle.requested(); const pinned = wireOf(consumer).demand(path, INSTANCE); const unpinned = wireOf(consumer).demand(path); const { value: req } = await it.next(); // Another instance now serves the route: the old handler's answer is for the old one. - handle.updateRoute({ ...handle.route, instance: NEWER }); + wireOf(handle).update({ ...wireOf(handle).info, instance: NEWER }); req.serve(new BroadcastProducer().consume()); await expect(pinned).rejects.toThrow("unroutable"); @@ -2479,13 +2560,13 @@ test("a demand refused across an instance change does not lose the carried deman const origin = new Producer(); const consumer = origin.consume(); const path = Path.from("live/cam"); - const handle = origin.requestsRoute(Path.from("live"), { instance: INSTANCE }); + const handle = origin.routePrefix(Path.from("live"), { instance: INSTANCE }); const it = handle.requested(); const unpinned = wireOf(consumer).demand(path); const pinned = wireOf(consumer).demand(path, INSTANCE); await it.next(); - handle.updateRoute({ ...handle.route, instance: NEWER }); + wireOf(handle).update({ ...wireOf(handle).info, instance: NEWER }); await expect(pinned).rejects.toThrow("unroutable"); // The replacement's refusal reaches the demand that carried over. (await it.next()).value?.reject(new Error("gone")); @@ -2499,14 +2580,14 @@ test("a demand refused across an instance change does not lose the carried deman test("demand held across an instance round trip still asks again", async () => { const origin = new Producer(); const path = Path.from("live/cam"); - const handle = origin.requestsRoute(Path.from("live"), { instance: INSTANCE }); + const handle = origin.routePrefix(Path.from("live"), { instance: INSTANCE }); const it = handle.requested(); const demanded = wireOf(origin.consume()).demand(path); const { value: req } = await it.next(); // Released by the first change; the instance coming back does not undo that. - handle.updateRoute({ ...handle.route, instance: NEWER }); - handle.updateRoute({ ...handle.route, instance: INSTANCE }); + wireOf(handle).update({ ...wireOf(handle).info, instance: NEWER }); + wireOf(handle).update({ ...wireOf(handle).info, instance: INSTANCE }); req.serve(new BroadcastProducer().consume()); const next = new BroadcastProducer(); @@ -2525,18 +2606,18 @@ test("demand held across an instance round trip still asks again", async () => { test("re-pricing from the current route keeps the instance", () => { const origin = new Producer(); - const handle = origin.requestsRoute(Path.from("live"), { instance: INSTANCE, cost: 5n }); - handle.updateRoute({ ...handle.route, cost: 1n }); - expect(handle.route).toEqual(Route.normalize({ instance: INSTANCE, cost: 1n })); + const handle = origin.routePrefix(Path.from("live"), { instance: INSTANCE, cost: 5n }); + handle.setCost(1n); + expect(wireOf(handle).info).toEqual(RouteInfo.normalize({ instance: INSTANCE, cost: 1n })); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - expect(broadcastPublication.route).toBeUndefined(); - broadcastPublication.announce({ instance: INSTANCE, cost: 5n }); - broadcastPublication.announce({ ...broadcastPublication.route, cost: 1n }); - expect(broadcastPublication.route).toEqual(Route.normalize({ instance: INSTANCE, cost: 1n })); - broadcastPublication.unannounce(); - expect(broadcastPublication.route).toBeUndefined(); + const broadcastRoute = origin.route(Path.from("room"), { hidden: true, instance: INSTANCE, cost: 5n }); + const broadcast = broadcastRoute.broadcast; + expect(wireOf(broadcastRoute).info).toBeUndefined(); + broadcastRoute.announce(); + broadcastRoute.setCost(1n); + expect(wireOf(broadcastRoute).info).toEqual(RouteInfo.normalize({ instance: INSTANCE, cost: 1n })); + broadcastRoute.withdraw(); + expect(wireOf(broadcastRoute).info).toBeUndefined(); broadcast.close(); handle.close(); @@ -2547,9 +2628,8 @@ test("a peer naming another instance is refused rather than served a different i const origin = new Producer(); const consumer = origin.consume(); const path = Path.from("room"); - const localPublication = origin.createBroadcast(path); - const local = localPublication.broadcast; - localPublication.announce({ instance: INSTANCE }); + const localRoute = origin.route(path, { instance: INSTANCE }); + const local = localRoute.broadcast; expect(wireOf(consumer).local(path, INSTANCE)).toBeDefined(); const other = Instance.parse("01900000-0000-7000-8000-000000000002"); @@ -2563,18 +2643,16 @@ test("a peer naming another instance is refused rather than served a different i test("a newer instance ends pinned and unpinned requests on the replaced publisher alike", () => { const origin = new Producer(); const path = Path.from("room"); - const first = origin.createBroadcast(path); - first.announce({ instance: INSTANCE }); + const first = origin.route(path, { instance: INSTANCE }); const reader = origin.consume(); const pinned = reader.request(path, { instance: INSTANCE }); const unpinned = reader.request(path); expect(pinned.active.peek()?.instance).toBe(INSTANCE); expect(unpinned.active.peek()?.instance).toBe(INSTANCE); const replacement = Instance.parse("01900000-0000-7000-8000-000000000002"); - const second = origin.createBroadcast(path); - second.announce({ instance: replacement }); - expect(() => first.announce({ instance: INSTANCE })).toThrow("broadcast is closed"); - first.unannounce(); + origin.route(path, { instance: replacement }); + expect(() => first.announce()).toThrow("broadcast is closed"); + first.withdraw(); expect(pinned.active.peek()).toBeUndefined(); // The replaced publisher closed: the unpinned request ends rather than move to the newer one. expect(unpinned.active.peek()).toBeUndefined(); @@ -2594,12 +2672,12 @@ test("a request held across an instance change asks again and never takes the ol const origin = new Producer(); const prefix = Path.from("room"); const path = Path.from("room/cam"); - const dynamic = origin.requestsRoute(prefix, { instance: INSTANCE }); + const dynamic = origin.routePrefix(prefix, { instance: INSTANCE }); const unpinned = origin.consume().request(path); const pinned = origin.consume().request(path, { instance: INSTANCE }); const requests = dynamic.requested(); const old = (await requests.next()).value; - dynamic.updateRoute({ ...dynamic.route, instance: NEWER }); + wireOf(dynamic).update({ ...wireOf(dynamic).info, instance: NEWER }); const current = origin.consume().request(path, { instance: NEWER }); old.serve(new BroadcastProducer().consume()); await settle(); @@ -2627,9 +2705,9 @@ test.each([ const origin = new Producer(); const prefix = Path.from("live"); const path = Path.from("live/cam"); - const dynamic = origin.requestsRoute(prefix, { instance: named }); + const dynamic = origin.routePrefix(prefix, { instance: named }); // A claim naming no instance serves one of its own. - const from = dynamic.route.instance; + const from = dynamic.instance; expect(from).toBeDefined(); if (named !== undefined) expect(from).toBe(named); const to = NEWER; @@ -2650,7 +2728,7 @@ test.each([ expect((await sticky?.recvGroup())?.sequence).toBe(0n); // A re-price at the same instance keeps every handle, and the handler is not asked again. - dynamic.updateRoute({ ...dynamic.route, cost: 5n }); + dynamic.setCost(5n); expect(await announced.next()).toMatchObject({ prefix, kind: "update" }); expect(held.active.peek()).toBe(resolved); const same = origin.consume().request(path); @@ -2659,7 +2737,7 @@ test.each([ const pinned = origin.consume().request(path, { instance: from }); // Another instance is another stream: resolved requests keep the old one. - dynamic.updateRoute({ ...dynamic.route, instance: to }); + wireOf(dynamic).update({ ...wireOf(dynamic).info, instance: to }); expect(await announced.next()).toMatchObject({ prefix, kind: "restart" }); await settle(); expect(held.active.peek()).toBe(resolved); @@ -2714,14 +2792,14 @@ test.each([ test("an instance update does not retain an answer that already closed", async () => { const origin = new Producer(); const path = Path.from("live/cam"); - const dynamic = origin.requestsRoute(Path.from("live"), { instance: INSTANCE }); + const dynamic = origin.routePrefix(Path.from("live"), { instance: INSTANCE }); const requests = dynamic.requested(); const held = origin.consume().request(path); const old = new BroadcastProducer(); (await requests.next()).value.serve(old); old.close(); // The server's closure callback has not removed the answer yet. - dynamic.updateRoute({ instance: NEWER }); + wireOf(dynamic).update({ instance: NEWER }); try { expect(held.closed.peek()).toBeInstanceOf(Error); expect(held.active.peek()).toBeUndefined(); @@ -2742,13 +2820,13 @@ test("an instance update does not retain an answer that already closed", async ( test("an unread resolved request retains its broadcast until its last handle closes", async () => { const origin = new Producer(); const path = Path.from("live/cam"); - const dynamic = origin.requestsRoute(Path.from("live"), { instance: INSTANCE }); + const dynamic = origin.routePrefix(Path.from("live"), { instance: INSTANCE }); const requests = dynamic.requested(); const held = origin.consume().request(path); const old = new SessionBroadcast(); (await requests.next()).value.serve(old); // Change instances before the active getter or its subscription can clone the answer. - dynamic.updateRoute({ instance: NEWER }); + wireOf(dynamic).update({ instance: NEWER }); expect(old.closed.peek()).toBeUndefined(); expect(held.active.peek()?.instance).toBe(INSTANCE); held.close(); @@ -2762,7 +2840,7 @@ test("an unread resolved request retains its broadcast until its last handle clo test("a session's re-request after an instance update asks the handler again", async () => { const origin = new Producer(); const path = Path.from("live/cam"); - const dynamic = origin.requestsRoute(Path.from("live"), { instance: INSTANCE }); + const dynamic = origin.routePrefix(Path.from("live"), { instance: INSTANCE }); const requests = dynamic.requested(); const wire = wireOf(origin.consume()); @@ -2771,7 +2849,7 @@ test("a session's re-request after an instance update asks the handler again", a (await requests.next()).value.serve(old); expect(await before).toBeDefined(); - dynamic.updateRoute({ ...dynamic.route, instance: NEWER }); + wireOf(dynamic).update({ ...wireOf(dynamic).info, instance: NEWER }); const after = wire.demand(path); const next = new BroadcastProducer(); const track = next.createTrack("video"); @@ -2792,8 +2870,8 @@ test("an update does not override route selection: another claim at the instance const origin = new Producer(); const prefix = Path.from("live"); const path = Path.from("live/cam"); - const first = origin.requestsRoute(prefix, { instance: INSTANCE, cost: 1n }); - const second = origin.requestsRoute(prefix, { instance: INSTANCE, cost: 5n }); + const first = origin.routePrefix(prefix, { instance: INSTANCE, cost: 1n }); + const second = origin.routePrefix(prefix, { instance: INSTANCE, cost: 5n }); const firstRequests = first.requested(); const secondRequests = second.requested(); @@ -2806,7 +2884,7 @@ test("an update does not override route selection: another claim at the instance // The first claim moves to another instance priced above the second, which still serves // the old one: the resolved request keeps its answer, and new requests go through the // second claim. - first.updateRoute({ ...first.route, instance: NEWER, cost: 9n }); + wireOf(first).update({ ...wireOf(first).info, instance: NEWER, cost: 9n }); const fresh = origin.consume().request(path); const replacement = new BroadcastProducer(); const track = replacement.createTrack("video"); @@ -2830,14 +2908,13 @@ test("an update does not override route selection: another claim at the instance origin.close(); }); -test("a route naming no instance resolves a handle under the one its publication minted", () => { +test("a route naming no instance resolves a handle under the one it minted", () => { const origin = new Producer(); const path = Path.from("room"); - const broadcast = origin.createBroadcast(path); - broadcast.announce(); + const broadcast = origin.route(path); const request = origin.consume().request(path); - expect(broadcast.route?.instance).toBeDefined(); - expect(request.active.peek()?.instance).toBe(broadcast.route?.instance); + expect(broadcast.instance).toBeDefined(); + expect(request.active.peek()?.instance).toBe(broadcast.instance); request.close(); origin.close(); }); @@ -2845,19 +2922,18 @@ test("a route naming no instance resolves a handle under the one its publication test("public announcements saturate static costs and refuse invalid cost shapes", async () => { const origin = new Producer(); const path = Path.from("priced"); - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = origin.route(path, { hidden: true }); + const broadcast = broadcastRoute.broadcast; const view = await announcedView(origin); - broadcastPublication.announce({ cost: 2n ** 64n - 1n }); + broadcastRoute.setCost(2n ** 64n - 1n); + broadcastRoute.announce(); await settle(); await new Promise((resolve) => setImmediate(resolve)); expect(view.peek().get(path)?.cost).toBe(2n ** 62n - 1n); await new Promise((resolve) => setImmediate(resolve)); - expect(() => broadcastPublication.announce({ cost: -1n })).toThrow(RangeError); + expect(() => broadcastRoute.setCost(-1n)).toThrow(RangeError); await new Promise((resolve) => setImmediate(resolve)); - expect(() => broadcastPublication.announce({ cost: { warm: 1n, cold: 2n } } as unknown as Route)).toThrow( - RangeError, - ); + expect(() => broadcastRoute.setCost({ warm: 1n, cold: 2n } as unknown as Cost)).toThrow(RangeError); broadcast.close(); origin.close(); }); @@ -2867,14 +2943,14 @@ test("published names refuse navigation segments", () => { try { for (const name of ["room/./cam", "room/../cam", ".", ".."]) { const path = Path.from(name); - expect(() => origin.createBroadcast(path).broadcast).toThrow(); - expect(() => origin.requests(path)).toThrow(); - expect(() => wireOf(origin).receive(path, Route.default)).toThrow(); + expect(() => origin.route(path, { hidden: true }).broadcast).toThrow(); + expect(() => origin.routePrefix(path)).toThrow(); + expect(() => wireOf(origin).receive(path, RouteInfo.default)).toThrow(); } const scoped = origin.scope(Path.from("room/.."), new Path.Patterns([Path.Pattern.all()])); - expect(() => scoped.createBroadcast(Path.from("cam")).broadcast).toThrow(); + expect(() => scoped.route(Path.from("cam"), { hidden: true }).broadcast).toThrow(); for (const path of ["room/.pro/cam", "room/a..b", "room/cam"]) { - origin.createBroadcast(Path.from(path)).broadcast.close(); + origin.route(Path.from(path), { hidden: true }).broadcast.close(); } } finally { origin.close(); diff --git a/js/net/src/origin.ts b/js/net/src/origin.ts index 6b6f1b5eb9c..9e202e0a43a 100644 --- a/js/net/src/origin.ts +++ b/js/net/src/origin.ts @@ -13,9 +13,10 @@ import { Derived, type Dispose, type GetPromise, type Getter, Once, race, Signal } from "@moq/signals"; import type * as Announce from "./announce.ts"; import * as announce from "./announced.ts"; +import type { Credential } from "./auth.ts"; import * as broadcast from "./broadcast.ts"; import { StreamCode, StreamError } from "./error.ts"; -import { Route, routesEqual } from "./hop.ts"; +import { type Cost, RouteInfo, routesEqual } from "./hop.ts"; import * as Instance from "./instance.ts"; import { compareRouteCandidates, @@ -43,7 +44,7 @@ import { wireOf, } from "./wire.ts"; -export type { Cost, Hop, Route } from "./hop.ts"; +export type { Cost, Hop, RouteInfo } from "./hop.ts"; export { HopSchema, isAnonymous } from "./hop.ts"; /** The rooted permissions shared by a handle and every route it inserts. */ @@ -243,10 +244,8 @@ class CoveringRoot { * A refusal is terminal, even while another source still serves: the slot ends, every handle * closes with the handler's error, and the slot leaves the table, so the next request asks * afresh. A refusal never falls through to a broader prefix or another advertiser. - * - * @internal */ -export interface RequestSlot { +interface RequestSlot { /** Open plain handles that can use a peer without discovery. */ blind: number; answer?: broadcast.Consumer; @@ -281,15 +280,13 @@ interface Resolution { * The preferred entry per prefix is the one requests resolve through. An originated * entry is forwarded by sessions; a received one is not, so a shared origin * cannot echo a peer's announcements back to it. - * - * @internal */ -export interface RouteEntry { +interface RouteEntry { readonly identity: object; readonly scope: Scope; /** The paths the entry may serve beneath its prefix, when its producer is scoped. */ readonly claim?: Path.Patterns; - readonly route: Signal; + readonly route: Signal; readonly originated: boolean; readonly server?: ServeState; } @@ -321,7 +318,7 @@ function preferredEntry( prefix: Path.Valid, entries: readonly RouteEntry[], skip?: (entry: RouteEntry) => boolean, - others: readonly Route[] = [], + others: readonly RouteInfo[] = [], ): RouteEntry | undefined { const eligible = entries.filter((entry) => !skip?.(entry)); // `others` compete at the prefix too, such as a broadcast announced here at the path. @@ -359,7 +356,7 @@ function unroutable(): StreamError { // A selected handler refused these requests; a coalesced route gap can have the same error. const refusedRequests = new WeakSet>(); -/** A served route from {@link Producer.requests}: the queue a handler drains. */ +/** A prefix route's queue of requests, from {@link Producer.routePrefix}: what a handler drains. */ class ServeState { readonly root: Path.Valid; /** The prefix the route claims; every served path is at or beneath it. */ @@ -531,7 +528,7 @@ class OriginState { // directions echo-free. created: Map | undefined = new Map(); local = new VersionedSignal | undefined>(new Map()); - advertisedLocal = new VersionedSignal | undefined>(new Map()); + advertisedLocal = new VersionedSignal | undefined>(new Map()); routes = new VersionedSignal | undefined>(new Map()); #snapshotVersion = ""; @@ -572,7 +569,7 @@ class OriginState { for (const [path, front] of this.local.peek() ?? []) { const local = { identity: front, - route: advertised?.get(path) ?? Route.default, + route: advertised?.get(path) ?? RouteInfo.default, exact: true, }; const list = out.get(path); @@ -1234,25 +1231,54 @@ export interface Reader { * @public */ export interface Table extends Reader { - /** Create an unannounced broadcast at `path`; see {@link Producer.createBroadcast}. */ - createBroadcast(path: Path.Valid): Publication; - - /** Advertise a prefix and serve requests under it; see {@link Producer.requests}. */ - requests(prefix: Path.Valid): Requests; - - /** Insert a route with protocol metadata. @internal */ - requestsRoute( - prefix: Path.Valid, - route?: - | Route - | { - instance?: Route["instance"]; - epoch?: Route["epoch"]; - hops?: Route["hops"]; - cost?: Route["cost"]; - auth?: Route["auth"]; - }, - ): Requests; + /** Create a route at exactly `path`, owning a new broadcast; see {@link Producer.route}. */ + route(path: Path.Valid, options?: RouteOptions): Route; + + /** Create a route over `prefix` that yields requests; see {@link Producer.routePrefix}. */ + routePrefix(prefix: Path.Valid, options?: RouteOptions): Route; +} + +/** + * How an application advertises a {@link Route}: its visibility at creation, its price, its + * credential, and, rarely, a stable instance. + * + * The default announces at once, at cost 0, under the session's scope, serving a fresh random + * instance minted when the route is created. + */ +export interface RouteOptions { + /** + * Create the route hidden: it exists for nobody until {@link Route.announce}. For a + * publisher that fills its catalog first, or answers a negotiation, before readers may find it. + */ + hidden?: boolean; + /** + * What pulling content via this route costs: lower wins among routes covering the same + * prefix and anonymity. A publisher prices content it already produces at zero, and content + * it would have to start producing on demand higher. + */ + cost?: Cost; + /** + * The credential the advertising request carries, from `auth.add()`. Only a session built + * on the handle that issued it presents it, as the token on its moq-transport + * PUBLISH_NAMESPACE; every other session advertises the route under its own scope. + */ + auth?: Credential; + /** + * Serve this stable instance in place of a freshly minted one. + * + * Only for a publisher that continues the instance's sequence space across restarts, + * announcing a higher {@link epoch} each time, such as a counter persisted on disk. Readers + * stitch every route of one instance together, so a publisher that restarts its group + * sequences under an old instance splices unrelated groups into their tracks. The highest + * epoch wins over every older one of the instance, cheaper or not. Naming an instance grants + * nothing: publishing still needs the path's grant. + * + * Do not start a named instance with `~`: that marks one a relay minted (see + * {@link Instance.isMinted}), which signing refuses to bind and a catalog's instance check skips. + */ + instance?: Instance.Valid; + /** Which incarnation of {@link instance} this is; raise it on each restart. Ignored without an instance. */ + epoch?: bigint; } /** Options for resolving one publisher instance with {@link Consumer.request}. */ @@ -1267,8 +1293,12 @@ export interface FollowOptions { instance?: Instance.Valid; } +// Route constructors, assigned in the classes' static blocks so neither class exposes one. +let makeRoute: (control: RouteControl) => Route; +let exactRoute: (producer: Producer, path: Path.Valid, options: RouteOptions, request: Request) => Route; + /** - * The write side of an origin: create broadcasts by path and advertise them. + * The write side of an origin: route broadcasts into it by path and advertise them. * * Independent of any connection. A connection given this origin (via its `publish` option) * announces and serves the table's originated advertisements for as long as the session @@ -1276,10 +1306,10 @@ export interface FollowOptions { * the origin down. A reconnecting session re-announces the table on each attach, so * advertisements made while offline surface on the next connection. * - * Create a broadcast, populate its tracks, then {@link Publication.announce}: an - * exact-path subscribe before the tracks exist is refused, and nobody can see or reach a - * broadcast until it announces. To publish broadcasts on demand instead, claim a prefix with - * {@link requests} and answer the requests beneath it. + * Create a {@link route} at a path and fill its broadcast; create it hidden and + * {@link Route.announce} it once its first tracks exist, since nobody can see or reach a hidden + * route. To publish broadcasts on demand instead, claim a prefix with {@link routePrefix} and + * answer the requests beneath it. * * @public */ @@ -1297,6 +1327,10 @@ export class Producer implements Table { // identity across reads. #reader = makeConsumer(this.#state, this.#scope); + static { + exactRoute = (producer, path, options, request) => producer.#exact(path, options, request); + } + constructor() { const thisProducer = this; registerWire(this, { @@ -1331,7 +1365,7 @@ export class Producer implements Table { return thisProducer.#requests; }, changed: () => this.#changed(), - blind: (slot) => this.#state.blind(slot), + blind: (slot) => this.#state.blind(slot as RequestSlot), answer: (path, front) => this.#answer(this.#scope.path(path), front), routes: (path) => wireOf(this.#reader).routes(path), }); @@ -1361,52 +1395,48 @@ export class Producer implements Table { } /** - * Create a broadcast at `path`, returning its publication handle. + * Create a route at exactly `path`, owning a new broadcast to fill. * - * The broadcast exists for nobody until {@link Publication.announce}: announce - * streams skip it and requests for its path find nothing, on this origin exactly as at - * a peer. Announce once its tracks exist; {@link Publication.unannounce} - * withdraws it from everyone again. + * This is how local content enters an origin. Fill the broadcast through + * {@link Route.broadcast}. The route serves a fresh random instance, minted here and kept + * for its lifetime, across {@link Route.withdraw} and {@link Route.announce}, since its + * sequences continue: a new route is a new stream that never splices into an old one. A + * publisher that continues one sequence space across restarts may name a stable instance + * instead ({@link RouteOptions.instance}). * - * Close the producer to drop it. Creating a path again supersedes the previous - * broadcast: the origin retracts and closes the old one, and tracks already subscribed - * keep serving until they end. The broadcast serves a fresh random {@link Route.instance}, - * kept across announce, unannounce and re-announce, so a restart is a new stream rather - * than a splice into the old one; at the same instance, a local broadcast competes on cost - * and wins ties. A publisher that continues one sequence space across restarts may name a - * stable instance instead. + * Announced at once unless created {@link RouteOptions.hidden | hidden}. A hidden route + * exists for nobody until {@link Route.announce}: announce streams skip it and a request + * for its path finds nothing, on this origin exactly as at a peer. Create it hidden when + * the tracks a subscriber needs first, such as a catalog, are not there yet. To serve paths + * on demand without publishing each one, use {@link routePrefix}. + * + * Closing the route retracts it and closes its broadcast, and so does closing the + * broadcast. Creating a path again supersedes the previous route: the origin retracts it + * and closes its broadcast, and tracks already subscribed keep serving until they end. At + * the same instance, a local broadcast competes on cost and wins ties. */ - createBroadcast(path: Path.Valid): Publication { + route(path: Path.Valid, options: RouteOptions = {}): Route { + return this.#exact(path, options); + } + + /** An exact route at `path`, answering `request` on its first announce when it is a job's. */ + #exact(path: Path.Valid, options: RouteOptions, request?: Request): Route { path = this.#scope.path(path); if (this.#borrowed?.closed) throw new Error("origin handle is closed"); publishPath(path); const created = this.#state.created; if (!created) throw new Error("origin is closed"); + // Normalized first, so a bad cost throws before anything is created. + let info = RouteInfo.normalize({ + instance: options.instance ?? Instance.random(), + epoch: options.instance === undefined ? 0n : options.epoch, + cost: options.cost, + auth: options.auth, + }); const producer = new broadcast.Producer(); hooks.stampPath(producer, path); const front = producer.consume(); - // The publication's own stream, kept across announce, unannounce and re-announce since - // its sequences continue. A route naming another instance replaces it. - let instance = Instance.random(); - let epoch = 0n; - - const announcer: broadcast.Announcer = { - announce: (route) => { - if (route.instance !== undefined) { - instance = route.instance; - epoch = route.epoch ?? 0n; - } - this.#advertiseExact(path, front, { ...route, instance, epoch }); - }, - unannounce: () => this.#retractExact(path, front), - route: () => - this.#state.local.peek()?.get(path) === front - ? this.#state.advertisedLocal.peek()?.get(path) - : undefined, - }; - hooks.attachAnnouncer(producer, announcer); - const entry = { producer, front }; const previous = created.get(path); created.set(path, entry); @@ -1415,20 +1445,71 @@ export class Producer implements Table { retire(previous); } - // Drop it when the broadcast closes, unless a recreate already replaced it: a stale - // broadcast closing must not unpublish the live one. Clearing `created` also stops a - // later announce. + // The request a job's route answers when it first announces. + let pending = request; + // Drop the route when its broadcast closes, unless a recreate already replaced it: a + // stale broadcast closing must not unpublish the live one. Clearing `created` also stops + // a later announce. A job's unanswered request can never be answered now. const release = this.#hold(() => { + stop(); this.#retractExact(path, front); - if (this.#state.created?.get(path) === entry) this.#state.created.delete(path); + if (created.get(path) === entry) created.delete(path); retire(entry); + const job = pending; + pending = undefined; + if (job) rejectJob(job, unroutable()); }); - void front.closed.then(release); + // Synchronous, so a request made right after the broadcast closes finds it gone. + const stop = hooks.onClosed(producer, release); + + const announced = () => this.#state.local.peek()?.get(path) === front; + const announce = () => { + if (producer.closed.peek() !== undefined) throw new Error("broadcast is closed"); + const job = pending; + if (!job) { + this.#advertiseExact(path, front, info); + return; + } + pending = undefined; + try { + // A request released meanwhile can never be answered, so this route never announces. + if (!jobPending(job)) throw unroutable(); + this.#advertiseExact(path, front, info); + } catch (err) { + release(); + rejectJob(job, err instanceof Error ? err : new Error(String(err))); + throw err; + } + answerJob(job); + }; + const change = (next: RouteInfo) => { + if (producer.closed.peek() !== undefined) throw new Error("broadcast is closed"); + if (!this.#state.created) throw new Error("origin is closed"); + info = next; + if (announced()) this.#advertiseExact(path, front, info); + }; - return makePublication(producer, announcer); + const route = makeRoute({ + broadcast: producer, + instance: () => info.instance as Instance.Valid, + announce, + withdraw: () => this.#retractExact(path, front), + announced, + change: (update) => change(RouteInfo.normalize({ ...info, ...update })), + requested: async function* () {}, + close: release, + info: () => (announced() ? this.#state.advertisedLocal.peek()?.get(path) : undefined), + update: (next) => { + const named = RouteInfo.normalize(next); + info = named.instance === undefined ? { ...named, instance: info.instance, epoch: info.epoch } : named; + announce(); + }, + }); + if (!options.hidden) announce(); + return route; } - #advertiseExact(path: Path.Valid, front: broadcast.Consumer, route: Route): void { + #advertiseExact(path: Path.Valid, front: broadcast.Consumer, route: RouteInfo): void { if (!this.#state.local.peek()) throw new Error("origin is closed"); if (this.#state.created?.get(path)?.front !== front) throw new Error("broadcast is closed"); // Both maps move together, so every reader sees the broadcast and its route at once. @@ -1455,60 +1536,39 @@ export class Producer implements Table { } /** - * Advertise `prefix` and serve the requests beneath it. + * Create a route over `prefix` that yields the requests beneath it. + * + * A route is always a prefix: it claims `prefix` and every path beneath it (the empty + * prefix claims every path). A service that only serves some of them advertises the + * covering prefix and rejects the rest as they are requested; consumers narrow with a + * {@link Path.Pattern} locally. The route is priced, credentialed and shown like an exact + * one, and forwarded by sessions while it is visible. * - * A route is always a prefix: it claims `prefix` and every path beneath it (the - * empty prefix claims every path). A service that only serves some of them - * advertises the covering prefix and rejects the rest as they are requested; - * consumers narrow with a {@link Path.Pattern} locally. The advertisement is - * visible to {@link Consumer.announced} and forwarded by sessions for as long as - * the returned {@link Requests} lives. A consumer resolving a path under it that - * no announced local broadcast wins is handed to the handle as a {@link Request}. + * A consumer resolving a path under it that no announced local broadcast wins is handed to + * {@link Route.requested} as a {@link Request}: answer it by serving a broadcast already held + * ({@link Request.serve}), under this route's instance, or by creating the path's own exact + * route ({@link Request.route}), under a fresh instance, so restarting one job never splices + * into a copy of the last. A publisher that knows its broadcasts creates each one's exact + * {@link route} instead, so subscribers can enumerate them. */ - requests(prefix: Path.Valid): Requests { - return this.#insertRoute(prefix, Route.default, true, true); - } - - /** Insert an originated claim with route metadata that answers through `Request.serve`, for tests and benches. @internal */ - requestsRoute( - prefix: Path.Valid, - route: - | Route - | { - instance?: Route["instance"]; - epoch?: Route["epoch"]; - hops?: Route["hops"]; - cost?: Route["cost"]; - auth?: Route["auth"]; - } = Route.default, - ): Requests { - return this.#insertRoute(prefix, Route.normalize(route), true, false); + routePrefix(prefix: Path.Valid, options: RouteOptions = {}): Route { + const info = RouteInfo.normalize({ + instance: options.instance, + epoch: options.epoch, + cost: options.cost, + auth: options.auth, + }); + return this.#serving(prefix, info, true, true, !options.hidden); } - /** - * Land a route a peer announced, served through the returned handle. Same as - * {@link requests} but not originated, so a session never announces it back. - * - * @internal - */ - #receive( - prefix: Path.Valid, - route: - | Route - | { - instance?: Route["instance"]; - epoch?: Route["epoch"]; - hops?: Route["hops"]; - cost?: Route["cost"]; - auth?: Route["auth"]; - } = Route.default, - ): Requests { - return this.#insertRoute(prefix, Route.normalize(route), false, false); - } - - #insertRoute(prefix: Path.Valid, route: Route, originated: boolean, publishes: boolean): Requests { + /** Land a route a peer announced, taken as given. Not originated, so a session never announces it back. */ + #receive(prefix: Path.Valid, route?: Partial): Route { + return this.#serving(prefix, RouteInfo.normalize(route), false, false, true); + } + + #serving(prefix: Path.Valid, route: RouteInfo, originated: boolean, publishes: boolean, visible: boolean): Route { prefix = this.#scope.prefix(prefix); - // A handle that names no instance serves one of its own. + // A route that names no instance serves one of its own. if (route.instance === undefined) route = { ...route, instance: Instance.random(), epoch: 0n }; publishPath(prefix); const server = new ServeState(this.#scope.root, prefix); @@ -1523,8 +1583,12 @@ export class Producer implements Table { }; server.onReject = (path, err) => this.#state.refuse(path, entry, err); - let closed = this.#borrowed?.closed ?? false; - if (!closed) { + let inserted = false; + let ended = false; + const insert = () => { + if (ended) throw new Error("route is closed"); + if (inserted) return; + let closed = false; this.#state.routes.mutate((routes) => { if (!routes) { closed = true; @@ -1534,29 +1598,79 @@ export class Producer implements Table { if (entries) entries.unshift(entry); else routes.set(prefix, [entry]); }); - } - if (closed) { + if (closed) throw new Error("origin is closed"); + inserted = true; + this.#state.rebuildOriginated(); + this.#state.refreshPrefix(prefix); + }; + // Take the entry out of the table, then end (or renew) the server before the requests + // beneath it reroute, so none of them resolves through an answer it already gave. + const remove = (server: () => void) => { + if (inserted) { + inserted = false; + this.#state.routes.mutate((routes) => { + const entries = routes?.get(prefix); + if (!entries) return; + const index = entries.indexOf(entry); + if (index < 0) return; + entries.splice(index, 1); + if (entries.length === 0) routes?.delete(prefix); + }); + } + server(); + this.#state.rebuildOriginated(); + this.#state.refreshPrefix(prefix); + }; + const release = this.#hold(() => { + ended = true; + remove(() => server.close()); + }); + // A route made after its origin (or this handle) closed is born retracted. + if (this.#borrowed?.closed || !this.#state.routes.peek()) { + ended = true; server.close(); - return makeDynamic(prefix, entry, this.#state, () => {}, publishes ? this : undefined); + } else if (visible) { + insert(); } - this.#state.rebuildOriginated(); - this.#state.refreshPrefix(prefix); - const retract = this.#hold(() => { - this.#state.routes.mutate((routes) => { - const entries = routes?.get(prefix); - if (!entries) return; - const index = entries.indexOf(entry); - if (index < 0) return; - entries.splice(index, 1); - if (entries.length === 0) routes?.delete(prefix); - }); - server.close(); + const update = (next: RouteInfo) => { + if (ended) throw new Error("route is closed"); + const previous = entry.route.peek().instance; + const restart = inserted && previous !== next.instance; + if (restart) this.#state.restart(entry); + entry.route.set(next); + if (previous !== next.instance) server.reset(); + if (!inserted) return; this.#state.rebuildOriginated(); this.#state.refreshPrefix(prefix); - }); + this.#state.routes.mutate(() => {}); + }; - return makeDynamic(prefix, entry, this.#state, retract, publishes ? this : undefined); + const publisher = publishes ? this : undefined; + return makeRoute({ + instance: () => entry.route.peek().instance as Instance.Valid, + announce: insert, + withdraw: () => { + if (ended || !inserted) return; + remove(() => server.reset()); + }, + announced: () => inserted && this.#state.routes.peek() !== undefined, + change: (changed) => update(RouteInfo.normalize({ ...entry.route.peek(), ...changed })), + requested: () => serveRequests(server, publisher), + close: release, + info: () => (inserted ? entry.route.peek() : undefined), + update: (next) => { + // A route naming no instance keeps the one it serves. + const named = RouteInfo.normalize(next); + const current = entry.route.peek(); + update( + named.instance === undefined + ? { ...named, instance: current.instance, epoch: current.epoch } + : named, + ); + insert(); + }, + }); } /** @@ -1693,10 +1807,13 @@ export class Producer implements Table { if (this.#state.closed.peek() !== undefined) return; this.#state.closed.set(abort ?? null); for (const watch of this.#state.watchers.values()) watch.version.update((n) => n + 1); - for (const created of this.#state.created?.values() ?? []) retire(created); + // Cleared before the broadcasts close, so each route's synchronous retraction finds + // nothing left to rebuild rather than rebuilding the table once per route. + const created = this.#state.created; this.#state.created = undefined; this.#state.local.update(() => undefined); this.#state.advertisedLocal.update(() => undefined); + for (const entry of created?.values() ?? []) retire(entry); this.#state.routes.update((routes) => { for (const entries of routes?.values() ?? []) { for (const entry of entries) entry.server?.close(abort); @@ -1747,20 +1864,12 @@ let makeFollowing: ( dispose: Dispose, ) => Following; -let makeDynamic: ( - prefix: Path.Valid, - entry: RouteEntry, - state: OriginState, - retract: Dispose, - publisher?: Producer, -) => Requests; - let makeRequest: (path: Path.Valid, server: ServeState) => Request; let finishRequest: (request: Request, err: Error) => void; let setRequestPublisher: (request: Request, publisher: Producer | undefined) => void; -let makePrepared: (request: Request, publication: Publication) => Prepared; -let publishPrepared: (request: Request, publication: Publication) => Publication; -let rejectPrepared: (request: Request, err: Error) => void; +let jobPending: (request: Request) => boolean; +let answerJob: (request: Request) => void; +let rejectJob: (request: Request, err: Error) => void; /** * An owned request for one publisher instance at a broadcast path; see {@link Consumer.request}. @@ -2376,21 +2485,6 @@ export class Consumer implements Reader { producer.close(); } - /** - * The local table, borrowed by the wire publishers to answer subscribes. - * - * Deliberately excludes received routes: a session never re-announces what a peer - * told it, so an origin wired to both directions of a connection cannot echo. - * Borrowed, not owned: do not close the fronts. Undefined once the origin closes. - * - * @internal - */ - /** - * Originated advertisements a session should forward: exact-path announces plus - * originated dynamics. Undefined once the origin closes. - * - * @internal - */ /** * The announced local broadcast at `path`, when it beats the originated routes there. * Resolves through what rebuildOriginated advertised: a peer never sees received routes. @@ -2493,140 +2587,172 @@ export class Consumer implements Reader { } } +/** What one {@link Route} does, exact or prefix. */ +interface RouteControl { + readonly broadcast?: broadcast.Producer; + instance(): Instance.Valid; + announce(): void; + withdraw(): void; + announced(): boolean; + change(update: Partial>): void; + requested(): AsyncIterableIterator; + close(): void; + info(): RouteInfo | undefined; + update(info: Partial): void; +} + +/** The requests arriving on a prefix route's `server`, each answerable with a route of `publisher`'s when it has one. */ +async function* serveRequests(server: ServeState, publisher: Producer | undefined): AsyncIterableIterator { + let current: Request | undefined; + const drop = () => { + current?.reject(unroutable()); + current = undefined; + }; + // Keep the cursor while draining: restarting it would rescan deleted entries. + let queued = server.queue.peek().values(); + try { + for (;;) { + const next = queued.next(); + if (!next.done) { + drop(); + server.queue.mutate((queue) => { + queue.delete(next.value); + }); + current = next.value; + setRequestPublisher(current, publisher); + yield next.value; + continue; + } + if (server.closed.peek() !== undefined) return; + await Signal.race(server.queue, server.closed); + queued = server.queue.peek().values(); + } + } finally { + drop(); + } +} + /** - * A served route from {@link Producer.requests}: advertises a prefix and answers the + * A route in an origin: an exact one owning its broadcast, or a prefix one answering the * requests beneath it. * - * Drop it (or {@link close}) to retract the route and reject anything still waiting - * with {@link StreamCode | StreamCode.Unroutable}. Close it and claim again to change it. + * Create an exact route with {@link Producer.route}, a prefix route with + * {@link Producer.routePrefix}, or a job's exact route with {@link Request.route}. + * + * ```ts + * // Fill the catalog before readers can find it. + * const route = origin.route(Path.from("live/alice"), { hidden: true }); + * route.broadcast.createTrack("catalog.json"); + * route.announce(); // visible now, same instance + * route.setCost(5n); // re-prices in place + * route.withdraw(); // hidden; announce() again continues the same stream + * ``` + * + * {@link close} retracts it and closes its broadcast, and so does closing the broadcast. * * @public */ -export class Requests { - /** The prefix this handle advertises. */ - readonly prefix: Path.Valid; - - #entry: RouteEntry; - #state: OriginState; - #retract: Dispose; - #publisher?: Producer; - #closed = false; +export class Route { + readonly #control: RouteControl; - private constructor( - prefix: Path.Valid, - entry: RouteEntry, - state: OriginState, - retract: Dispose, - publisher?: Producer, - ) { - this.prefix = Path.stripPrefix(entry.scope.root, prefix) ?? Path.empty(); - this.#entry = entry; - this.#state = state; - this.#retract = retract; - this.#publisher = publisher; + private constructor(control: RouteControl) { + this.#control = control; + registerWire(this, { + get info() { + return control.info(); + }, + update: (info) => control.update(info), + }); } static { - makeDynamic = (prefix, entry, state, retract, publisher) => - new Requests(prefix, entry, state, retract, publisher); + makeRoute = (control) => new Route(control); } - /** The route this handle advertises. */ - get route(): Route { - return this.#entry.route.peek(); + /** The broadcast this exact route owns, to fill with tracks. Throws on a prefix route, which owns none. */ + get broadcast(): broadcast.Producer { + const producer = this.#control.broadcast; + if (!producer) throw new Error("a prefix route owns no broadcast; answer its requests"); + return producer; + } + + /** The stream this route serves, minted when it was created unless {@link RouteOptions.instance} named one. */ + get instance(): Instance.Valid { + return this.#control.instance(); } /** - * Replace the route in place. The prefix is fixed at announce time. - * - * A route naming no instance keeps the one this handle serves. At the same instance this - * re-prices (or, at a higher epoch, continues the stream): consumers see an update and every - * handle survives. Another instance names another stream: - * consumers see a restart, resolved requests keep their old broadcast until closed, and a - * re-request never joins it. Requests still waiting on this handle carry over: the handler - * is asked again under the new instance, and its answer to a request asked before the change - * is dropped, never served under the new instance. A new or unresolved request pinned to the - * old instance is refused as unroutable. The answers already served are forgotten, so the next - * request for one of those paths asks the handler again too. The broadcasts it served keep - * running for the subscriptions already on them; close them to end those too. - * Route selection still applies across instances. To re-price, start from the current route, `updateRoute({ ...dynamic.route, cost })`. + * Make the route visible, or keep it so. Idempotent. * - * @internal + * Visible to local consumers before it returns. A job's route ({@link Request.route}) also + * answers the requesters waiting on its path. Throws once the route or its broadcast closed, + * and, announcing nothing, with {@link StreamCode | StreamCode.Unroutable} when a job's request + * was released or its prefix route retracted meanwhile: that route can never announce. */ - updateRoute( - route: - | Route - | { - instance?: Route["instance"]; - epoch?: Route["epoch"]; - hops?: Route["hops"]; - cost?: Route["cost"]; - auth?: Route["auth"]; - }, - ): void { - if (this.#closed) throw new Error("dynamic is closed"); - const current = this.#entry.route.peek(); - const named = Route.normalize(route); - // A route naming no instance keeps the one this handle serves. - const next = - named.instance === undefined ? { ...named, instance: current.instance, epoch: current.epoch } : named; - const previous = current.instance; - if (previous !== next.instance) this.#state.restart(this.#entry); - this.#entry.route.set(next); - if (previous !== next.instance) this.#entry.server?.reset(); - this.#state.rebuildOriginated(); - this.#state.refreshPrefix(Path.join(this.#entry.scope.root, this.prefix)); - this.#state.routes.mutate(() => {}); + announce(): void { + this.#control.announce(); } - /** Retract the route and reject anything still waiting. Idempotent. */ + /** + * Hide the route from everyone, local and remote alike, keeping its broadcast and instance: + * {@link announce} brings the same stream back. Requests for the path fail with + * {@link StreamCode | StreamCode.Unroutable} meanwhile, while tracks already in flight carry + * on to their own end. Idempotent. + */ + withdraw(): void { + this.#control.withdraw(); + } + + /** Whether the route is visible. */ + get announced(): boolean { + return this.#control.announced(); + } + + /** + * Re-price the route: lower wins among routes covering the same prefix and anonymity. A + * visible route changes in place, as an update to its readers; a hidden one announces at + * this price. Throws once the route or its broadcast closed. + */ + setCost(cost: Cost): void { + this.#control.change({ cost }); + } + + /** + * Swap the credential the advertising request carries; see {@link RouteOptions.auth}. + * Undefined advertises under the session's scope. Throws once the route or its broadcast closed. + */ + setAuth(auth?: Credential): void { + this.#control.change({ auth }); + } + + /** + * The requests beneath this prefix route, as they arrive, each to answer with + * {@link Request.serve}, {@link Request.route} or {@link Request.reject}. Advancing the + * iterator or closing it without answering rejects the request. Ends once the route is + * closed or the origin closes, and at once on an exact route, which yields no requests. + */ + requested(): AsyncIterableIterator { + return this.#control.requested(); + } + + /** Retract the route for good, closing its broadcast and rejecting anything still waiting. Idempotent. */ close(): void { - if (this.#closed) return; - this.#closed = true; - this.#retract(); - } - - /** Requests under this prefix, as they arrive, each to {@link Request.prepare} or reject. */ - async *requested(): AsyncIterableIterator { - const server = this.#entry.server; - if (!server) return; - let current: Request | undefined; - const drop = () => { - current?.reject(unroutable()); - current = undefined; - }; - // Keep the cursor while draining: restarting it would rescan deleted entries. - let queued = server.queue.peek().values(); - try { - for (;;) { - const next = queued.next(); - if (!next.done) { - drop(); - server.queue.mutate((queue) => { - queue.delete(next.value); - }); - current = next.value; - setRequestPublisher(current, this.#publisher); - yield next.value; - continue; - } - if (server.closed.peek() !== undefined) return; - await Signal.race(server.queue, server.closed); - queued = server.queue.peek().values(); - } - } finally { - drop(); - } + this.#control.close(); + } + + /** Calls {@link close}, so `using` retracts the route. */ + [Symbol.dispose](): void { + this.close(); } } /** * A pending request for a broadcast to be served on demand. * - * Yielded by {@link Requests.requested}. {@link prepare} then {@link Prepared.publish} - * resolves it with a new exact-path broadcast; {@link serve} answers with a held broadcast; - * {@link reject} resolves it with an error. - * Advancing the iterator or closing it without answering rejects the request. + * Yielded by {@link Route.requested}. Answer it one of three ways: {@link serve} a broadcast + * already held, under the prefix route's instance; create the path's own exact route with + * {@link route}, under a fresh instance; or {@link reject} it with an error. Advancing the + * iterator or closing it without answering rejects the request. * * @public */ @@ -2649,16 +2775,14 @@ export class Request { setRequestPublisher = (request, publisher) => { request.#publisher = publisher; }; - publishPrepared = (request, publication) => { - if (!request.#server.has(request)) throw new Error("request is closed"); - publication.announce(); + jobPending = (request) => request.#server.has(request); + answerJob = (request) => { // Its exact route owns availability: never cache a published job under the // prefix, which would keep serving it after that exact route is withdrawn. request.#server.forget(Path.join(request.#server.root, request.path), request); request.#server.settled.update((n) => n + 1); - return publication; }; - rejectPrepared = (request, err) => request.#server.reject(request, err); + rejectJob = (request, err) => request.#server.reject(request, err); finishRequest = (request, err) => { request.#done = true; request.#withdrawn = true; @@ -2666,15 +2790,26 @@ export class Request { }; } - /** Start answering as a new stream under a fresh instance, hidden until published. */ - prepare(): Prepared { + /** + * Answer with the path's own exact route, owning a new broadcast. + * + * The route serves a fresh instance unless `options` names one, so a job that ends and + * restarts beneath the same prefix is a new stream for its restarted sequences. Closing the + * route withdraws only this path: the prefix route keeps answering later requests. Created + * visible, the route announces now and answers the requesters waiting on its path. Created + * {@link RouteOptions.hidden | hidden}, they wait until {@link Route.announce}, so the job can + * fill its catalog first; closing the route or its broadcast before then refuses them. + * + * Throws {@link StreamCode | StreamCode.Unroutable} on a request a session forwarded, which can + * only {@link serve} its peer's broadcast, and, announcing nothing, once the request was + * released or its prefix route retracted. Otherwise it throws as {@link Producer.route} does. + */ + route(options: RouteOptions = {}): Route { if (this.#done) throw new Error("request is closed"); - if (!this.#publisher) throw new Error("forwarded requests cannot be prepared"); - const publication = this.#publisher.createBroadcast(this.path); - // Only the fill handle escapes until publish, so the answer cannot announce itself - // under another instance or skip the request's admission. + if (!this.#publisher) throw unroutable(); + const route = exactRoute(this.#publisher, this.path, options, this); this.#done = true; - return makePrepared(this, publication); + return route; } /** @@ -2682,8 +2817,8 @@ export class Request { * * Takes ownership of a consumer; a producer stays the caller's. Every answer at this * path belongs to the prefix route's instance and must continue the same sequences and - * bytes. Start a new prefix route for different content, or use {@link prepare} and - * {@link Prepared.publish} for a job that can restart independently. + * bytes. Start a new prefix route for different content, or use {@link route} for a job + * that can restart independently. */ serve(source: broadcast.Producer | broadcast.Consumer): void { if (this.#done) { @@ -2704,107 +2839,3 @@ export class Request { this.#server.reject(this, err); } } - -let makePublication: (producer: broadcast.Producer, announcer: broadcast.Announcer) => Publication; - -/** An origin-owned broadcast and the capability to announce its route. */ -export class Publication { - /** The broadcast to fill with tracks before announcing it. */ - readonly broadcast: broadcast.Producer; - readonly #announcer: broadcast.Announcer; - - private constructor(producer: broadcast.Producer, announcer: broadcast.Announcer) { - this.broadcast = producer; - this.#announcer = announcer; - } - - static { - makePublication = (producer, announcer) => new Publication(producer, announcer); - } - - /** The route this broadcast is announced with, if any. */ - get route(): Route | undefined { - return this.#announcer.route(); - } - - /** - * Announce this broadcast, or replace its route; retain its instance when changing only cost. - * Announce once its initial tracks exist. Throws after the broadcast closes or is replaced. - */ - announce( - route: - | Route - | { - instance?: Route["instance"]; - epoch?: Route["epoch"]; - hops?: Route["hops"]; - cost?: Route["cost"]; - auth?: Route["auth"]; - } = Route.default, - ): void { - if (this.broadcast.closed.peek() !== undefined) throw new Error("broadcast is closed"); - this.#announcer.announce(Route.normalize(route)); - } - - /** Retract this broadcast's route until announced again, without closing its fill handle. */ - unannounce(): void { - this.#announcer.unannounce(); - } -} - -/** - * A claim answer being filled before its exact route is announced. - * - * Use `using` or {@link close} to refuse it unless {@link publish} transfers its broadcast. - * Closing the unpublished broadcast also refuses the request. A retained, unclosed answer - * keeps the request pending; garbage collection provides no prompt cleanup guarantee. - */ -export class Prepared { - /** The unannounced broadcast to fill before publishing; only {@link publish} announces it. */ - readonly broadcast: broadcast.Producer; - readonly #request: Request; - readonly #publication: Publication; - readonly #stop: Dispose; - #done = false; - - private constructor(request: Request, publication: Publication) { - this.#request = request; - this.broadcast = publication.broadcast; - this.#publication = publication; - // Synchronous, so a request made right after the broadcast closes reaches the claim again. - this.#stop = hooks.onClosed(this.broadcast, () => this.close()); - } - - static { - makePrepared = (request, publication) => new Prepared(request, publication); - } - - /** Announce the filled broadcast and resolve every waiting requester, refusing them if it cannot be announced. */ - publish(): Publication { - // Closing the broadcast closes this answer at once, so `#done` covers it too. - if (this.#done) throw new Error("prepared answer is closed"); - this.#done = true; - this.#stop(); - try { - return publishPrepared(this.#request, this.#publication); - } catch (err) { - this.broadcast.close(); - rejectPrepared(this.#request, err instanceof Error ? err : new Error(String(err))); - throw err; - } - } - - /** Refuse an unpublished answer as unroutable and close its broadcast. Idempotent. */ - close(): void { - if (this.#done) return; - this.#done = true; - this.#stop(); - this.broadcast.close(); - rejectPrepared(this.#request, unroutable()); - } - - /** Calls {@link close}, so `using` refuses an unpublished answer. */ - [Symbol.dispose](): void { - this.close(); - } -} diff --git a/js/net/src/parked-expiry.test.ts b/js/net/src/parked-expiry.test.ts index 448dce3f1ad..d6fe5258420 100644 --- a/js/net/src/parked-expiry.test.ts +++ b/js/net/src/parked-expiry.test.ts @@ -30,9 +30,8 @@ for (const protocol of protocols) { const installed = clock.install(); const pair = createMockTransportPair(protocol.alpn); const origin = new Origin(); - const broadcastPublication = origin.createBroadcast(Path.from("parked")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("parked")); + const broadcast = broadcastRoute.broadcast; const track = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const write = (sequence: bigint) => { const group = track.createGroup(sequence); @@ -153,9 +152,8 @@ for (const protocol of protocols) { const installed = clock.install(); const pair = createMockTransportPair(protocol.alpn); const origin = new Origin(); - const broadcastPublication = origin.createBroadcast(Path.from("parked")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("parked")); + const broadcast = broadcastRoute.broadcast; const track = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const write = (sequence: bigint, frames: number) => { const group = track.createGroup(sequence); diff --git a/js/net/src/resume.model.test.ts b/js/net/src/resume.model.test.ts index f4e56b67cd4..2a566bb222a 100644 --- a/js/net/src/resume.model.test.ts +++ b/js/net/src/resume.model.test.ts @@ -17,7 +17,7 @@ import fc from "fast-check"; import { Consumer as BroadcastConsumer, Producer as BroadcastProducer } from "./broadcast.ts"; import { NotFound, StreamCode, StreamError, TooFarBehind } from "./error.ts"; import type { Frame, Consumer as GroupConsumer, Producer as GroupProducer } from "./group.ts"; -import { HopSchema, Route } from "./hop.ts"; +import { HopSchema, RouteInfo } from "./hop.ts"; import * as Instance from "./instance.ts"; import { hooks } from "./internal.ts"; import { type Consumer as OriginConsumer, Producer as OriginProducer, type Requesting } from "./origin.ts"; @@ -447,7 +447,7 @@ class Model { up(instance: number, slot: number): void { const publisher = this.instances[instance]; if (publisher.routes[slot]) return; - const route = Route.normalize({ + const route = RouteInfo.normalize({ instance: INSTANCES[instance], hops: [HopSchema.parse(BigInt(10 * (instance + 1) + slot))], // The second instance's routes all undercut the first's. diff --git a/js/net/src/resume.test.ts b/js/net/src/resume.test.ts index 6b23ae0951e..691946cb06e 100644 --- a/js/net/src/resume.test.ts +++ b/js/net/src/resume.test.ts @@ -3,7 +3,7 @@ import { Manual, Milli, Nano, yieldNow } from "@moq/clock"; import { Consumer as BroadcastConsumer, Producer as BroadcastProducer } from "./broadcast.ts"; import { NotFound, SessionCode, SessionError, StreamCode, StreamError } from "./error.ts"; import { type Consumer as GroupConsumer, Producer as GroupProducer } from "./group.ts"; -import { Route } from "./hop.ts"; +import { RouteInfo } from "./hop.ts"; import type { Session as IetfSession } from "./ietf/session.ts"; import { Subscriber as IetfSubscriber } from "./ietf/subscriber.ts"; import { Version as IetfVersion } from "./ietf/version.ts"; @@ -39,7 +39,7 @@ async function isPending(promise: Promise): Promise { /** A stand-in session announcing `path` under the shared instance at `cost`, serving `source`. */ function serve(origin: Producer, source: BroadcastProducer, cost: bigint) { - const handle = wireOf(origin).receive(path, Route.normalize({ instance: INSTANCE, cost })); + const handle = wireOf(origin).receive(path, RouteInfo.normalize({ instance: INSTANCE, cost })); void (async () => { for await (const request of handle.requested()) request.serve(source.consume()); })(); @@ -482,9 +482,8 @@ test("a resumed fork shares an on-demand track request", async () => { test("a lagging same-instance replica resumes from one publisher's bytes exactly once", async () => { const { clock, installed } = manual(); const publisher = new Producer(); - const originalPublication = publisher.createBroadcast(path); - const original = originalPublication.broadcast; - originalPublication.announce({ instance: INSTANCE }); + const originalRoute = publisher.route(path, { instance: INSTANCE }); + const original = originalRoute.broadcast; const source = original.createTrack("seq"); const origin = new Producer(); @@ -988,7 +987,7 @@ test("between routes a reader keeps reading the copy it has", async () => { expect(drain(sub)).toEqual([0n]); // The next route has not answered when the old one is retracted. - const next = wireOf(origin).receive(path, Route.normalize({ instance: INSTANCE, cost: 1n })); + const next = wireOf(origin).receive(path, RouteInfo.normalize({ instance: INSTANCE, cost: 1n })); const asked = next.requested(); disposeA(); await settle(); @@ -1913,7 +1912,7 @@ test("a fetched group that fails on the route still serving waits for the next r const b = new BroadcastProducer(); const ta = copy(a); const tb = copy(b); - // Route a's request handler holds the refetch of its failed group open, as Rust's tests do + // RouteInfo a's request handler holds the refetch of its failed group open, as Rust's tests do // with `requests()`: without one, a miss there is NotFound at once. const pending = ta.producer.requests(); const failing = ta.write(5n, 1, false); @@ -1945,7 +1944,7 @@ test("a group handed out already failed with its route still continues on the ne const b = new BroadcastProducer(); const ta = copy(a); const tb = copy(b); - // Route a's request handler holds the refetch of its failed group open until the next route. + // RouteInfo a's request handler holds the refetch of its failed group open until the next route. const pending = ta.producer.requests(); front.serve(a.consume()); const sub = front.consumer.track("seq").subscribe(); diff --git a/js/net/src/retention.test.ts b/js/net/src/retention.test.ts index 029176110d3..81d5d6d4f4b 100644 --- a/js/net/src/retention.test.ts +++ b/js/net/src/retention.test.ts @@ -81,9 +81,8 @@ async function session(alpn: string) { accept({ transport: pair.server, url, publish: origin.consume() }), ]); - const broadcastPublication = origin.createBroadcast(Path.from("test")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("test")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const remote = wireOf(client).consume(Path.from("test")); diff --git a/js/net/src/subscribe_priority.test.ts b/js/net/src/subscribe_priority.test.ts index 1ccae6bdb62..caa93dff11f 100644 --- a/js/net/src/subscribe_priority.test.ts +++ b/js/net/src/subscribe_priority.test.ts @@ -60,9 +60,8 @@ test.each([Lite.ALPN_07_WIP, ...Object.values(Ietf.ALPN)])( "%s follows the aggregate priority upstream", async (protocol) => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(path); + const broadcast = broadcastRoute.broadcast; const video = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const [client, server] = await session(protocol, origin); @@ -100,9 +99,8 @@ test.each(Object.values(Ietf.ALPN))("%s ends a subscription mid-update without a await yieldNow(); }); const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(path); + const broadcast = broadcastRoute.broadcast; const video = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const [client, server] = await session(protocol, origin); let closed: Error | null | undefined; @@ -137,9 +135,8 @@ test.each(Object.values(Ietf.ALPN))("%s ends a subscription mid-update without a // update of defaults first, as on lite and in Rust. test.each(Object.values(Ietf.ALPN))("%s sends no update when the last subscriber leaves", async (protocol) => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(path); + const broadcast = broadcastRoute.broadcast; const video = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const [client, server] = await session(protocol, origin); try { @@ -164,9 +161,8 @@ test.each(Object.values(Ietf.ALPN))("%s sends no update when the last subscriber // track with the error rather than leaving it at a stale priority. Nothing reaches the wire. test.each(Object.values(Ietf.ALPN))("%s ends the track when an update fails to encode", async (protocol) => { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(path); + const broadcast = broadcastRoute.broadcast; const video = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const [client, server] = await session(protocol, origin); let closed: Error | null | undefined; diff --git a/js/net/src/tail.test.ts b/js/net/src/tail.test.ts index 5b7fa87b252..a58b99ebb26 100644 --- a/js/net/src/tail.test.ts +++ b/js/net/src/tail.test.ts @@ -26,9 +26,8 @@ async function session(protocol: string) { connect({ url, transport: pair.client }), accept({ transport: pair.server, url, publish: origin.consume() }), ]); - const broadcastPublication = origin.createBroadcast(Path.from("test")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("test")); + const broadcast = broadcastRoute.broadcast; const video = broadcast.createTrack("video", { timescale: Timescale.MILLI }); const remote = wireOf(client).consume(Path.from("test")); const reader = remote diff --git a/js/net/src/terminal.test.ts b/js/net/src/terminal.test.ts index 796ae45243d..009cfc2a9b6 100644 --- a/js/net/src/terminal.test.ts +++ b/js/net/src/terminal.test.ts @@ -57,8 +57,7 @@ test("an unanswered track request is refused with the dropped producer's error", test("a lite protocol violation reaches the subscribed track and its open group", async () => { const pair = createMockTransportPair(ALPN_06); const origin = new OriginProducer(); - const publication = origin.createBroadcast(Path.from("room")); - publication.announce(); + const publication = origin.route(Path.from("room")); const producer = publication.broadcast.createTrack("video", { timescale: Timescale.MILLI }); producer.appendGroup().writeFrame(textFrame("prefix")); const url = new URL("https://example.com"); diff --git a/js/net/src/untimed.test.ts b/js/net/src/untimed.test.ts index 2ec52a88be1..e1fc726e206 100644 --- a/js/net/src/untimed.test.ts +++ b/js/net/src/untimed.test.ts @@ -44,9 +44,8 @@ async function roundTrip(wire: Wire, timescale: Timescale | undefined, timestamp accept({ transport: pair.server, url, version: wire.version, publish: origin.consume() }), ]); - const broadcastPublication = origin.createBroadcast(Path.from("test")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("test")); + const broadcast = broadcastRoute.broadcast; // Every request is answered, including the TRACK lookup lite-05+ makes before subscribing. const serving = (async () => { for (;;) { @@ -115,9 +114,8 @@ test("a forwarded untimed track stays untimed", async () => { connect({ url, transport: downstream.client }), ]); - const broadcastPublication = source.createBroadcast(Path.from("test")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = source.route(Path.from("test")); + const broadcast = broadcastRoute.broadcast; const serving = (async () => { for (;;) { const request = await wireOf(broadcast).requested(); @@ -130,7 +128,7 @@ test("a forwarded untimed track stays untimed", async () => { // Serve the downstream session from the upstream one through a copy the forwarding // node produces. - const dynamic = relay.requestsRoute(Path.from("test")); + const dynamic = relay.routePrefix(Path.from("test")); const inputs: BroadcastConsumer[] = []; const forwarding = (async () => { for await (const request of dynamic.requested()) { @@ -191,9 +189,8 @@ for (const wire of WIRES.filter((wire) => wire.name === "lite-06" || wire.name = accept({ transport: pair.server, url, publish: origin.consume() }), ]); - const broadcastPublication = origin.createBroadcast(Path.from("test")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("test")); + const broadcast = broadcastRoute.broadcast; const producer = broadcast.createTrack("video", {}); const subscriber = wireOf(client).consume(Path.from("test")).track("video").subscribe(); diff --git a/js/net/src/wire.ts b/js/net/src/wire.ts index f56f2c2adca..de53e569b1d 100644 --- a/js/net/src/wire.ts +++ b/js/net/src/wire.ts @@ -10,7 +10,7 @@ import type { Dispose, GetPromise, Getter } from "@moq/signals"; import type * as broadcast from "./broadcast.ts"; import type { Consumer as GroupConsumer } from "./group.ts"; -import type { Route } from "./hop.ts"; +import type { RouteInfo } from "./hop.ts"; import type * as Instance from "./instance.ts"; import type { Lister, Tracks } from "./listing.ts"; import type * as origin from "./origin.ts"; @@ -37,6 +37,12 @@ export interface Broadcast { /** Receives one change to the watched prefixes: `prefix` is now (or no longer) wanted. */ export type InterestListener = (prefix: Path.Valid, wanted: boolean) => void; +/** An origin's open request for a path, as a serving session sees it. */ +export interface RequestSlot { + /** The blind answer a session already gave it, if any. */ + readonly answer?: broadcast.Consumer; +} + /** The protocol-facing operations behind an origin producer. */ export interface OriginProducer { /** @@ -48,32 +54,34 @@ export interface OriginProducer { interests(listener: InterestListener): Dispose; /** Whether an advertised prefix overlaps the handle's allowed paths. */ accepts(prefix: Path.Valid): boolean; - receive( - prefix: Path.Valid, - route?: - | Route - | { - instance?: Route["instance"]; - epoch?: Route["epoch"]; - hops?: Route["hops"]; - cost?: Route["cost"]; - auth?: Route["auth"]; - }, - ): origin.Requests; + /** Land a route a peer announced, taken as given and never forwarded back to a peer. */ + receive(prefix: Path.Valid, route?: Partial): origin.Route; attach(discovery: boolean): Dispose; /** * Hold the origin's announcement streams overlapping `prefix` unsynced until * the returned dispose: a session holds one while its peer's initial set is in flight. */ snapshot(prefix: Path.Valid): Dispose; - readonly requests: Getter | undefined>; + readonly requests: Getter | undefined>; changed(): GetPromise; /** Whether sessions should answer the request with a blind subscription right now. */ - blind(slot: origin.RequestSlot): boolean; + blind(slot: RequestSlot): boolean; answer(path: Path.Valid, front: broadcast.Consumer): Dispose | undefined; routes(path: Path.Valid): boolean; } +/** The protocol-facing operations behind an origin route. */ +export interface Route { + /** The metadata the route is advertised with, or undefined while hidden. */ + readonly info: RouteInfo | undefined; + /** + * Advertise the route with `info` as given, as a session's update does: a named instance + * replaces the route's, which restarts its readers; otherwise it keeps the route's own. + * Announces a hidden route. + */ + update(info: Partial): void; +} + /** The protocol-facing operations behind an origin consumer. */ export interface OriginConsumer { routes(path: Path.Valid): boolean; @@ -88,7 +96,7 @@ export interface OriginConsumer { /** One originated advertisement exposed to the publishing wire. */ export interface Advertised { readonly identity: object; - readonly route: Route; + readonly route: RouteInfo; /** The paths a scoped route may serve beneath its prefix, relative like its key; unset for the whole subtree. */ readonly claim?: Path.Patterns; /** @@ -102,7 +110,7 @@ export interface Advertised { /** What names a stream: an advertisement, and the instance its route serves. */ export interface Served { readonly identity: object; - readonly route: Pick; + readonly route: Pick; } /** @@ -140,7 +148,7 @@ export interface Established { /** A produced broadcast's view, which always fetches from its own cache. */ export type Produced = Broadcast & Required>; -type View = Broadcast | OriginProducer | OriginConsumer | Established; +type View = Broadcast | OriginProducer | OriginConsumer | Route | Established; const views = new WeakMap(); /** Register the package-private view for a handle. */ @@ -162,6 +170,7 @@ export function wireOf(handle: broadcast.Producer): Produced; export function wireOf(handle: broadcast.Producer | broadcast.Consumer): Broadcast; export function wireOf(handle: origin.Producer): OriginProducer; export function wireOf(handle: origin.Consumer): OriginConsumer; +export function wireOf(handle: origin.Route): Route; export function wireOf(handle: import("./connection/established.ts").Established): Established; /** Return the package-private view for a handle. */ export function wireOf(handle: object): View { diff --git a/js/publish/src/broadcast.test.ts b/js/publish/src/broadcast.test.ts index 76a47471b93..283509cb2b3 100644 --- a/js/publish/src/broadcast.test.ts +++ b/js/publish/src/broadcast.test.ts @@ -261,7 +261,7 @@ test("serves no catalog until announced, so the first snapshot is the one at ann // Regression: a re-announce re-created the catalog track, restarting its group sequence under the // same instance, so a resumed viewer mistook the new catalog for the old one. Turning the announce off -// unannounces at once and keeps the broadcast for the next announce. +// withdraws the route at once and keeps it, broadcast and instance, for the next announce. test("a re-announce continues the catalog's group sequence", async () => { const announce = new Signal(true); const broadcast = new Broadcast({ @@ -278,6 +278,8 @@ test("a re-announce continues the catalog's group sequence", async () => { const announced = broadcast.in.origin.peek()?.follow(broadcast.in.name.peek()); const first = net.track(Broadcast.CATALOG_TRACK).subscribe().ordered(); expect((await first.nextGroup())?.sequence).toBe(0n); + const instance = announced?.active.peek()?.instance; + expect(instance).toBeDefined(); announce.set(false); await settle(); @@ -287,7 +289,9 @@ test("a re-announce continues the catalog's group sequence", async () => { announce.set(true); await settle(); - // The same track keeps serving, and its newest group is past the first. + // The follower continues the same instance, the same track keeps serving, and its newest group + // is past the first. + expect(announced?.active.peek()?.instance).toBe(instance); expect(broadcast.net.peek()).toBe(net); const group = await first.nextGroup(); expect(group?.sequence).toBeGreaterThan(0); diff --git a/js/publish/src/broadcast.ts b/js/publish/src/broadcast.ts index f43787edbe8..f51927e9f82 100644 --- a/js/publish/src/broadcast.ts +++ b/js/publish/src/broadcast.ts @@ -33,7 +33,7 @@ export type BroadcastInput = { // see or subscribe to it. The flip rather than a gate on creating it: tracks can be // populated while this is false, then announced once ready. The catalog is served from the // first announce, so its first snapshot is the one current at announce time. - // Turning it off unannounces the broadcast. + // Turning it off withdraws the route, and turning it back on continues the same stream. announce: Getter; // The broadcast name. @@ -441,13 +441,13 @@ export class Broadcast { ); } - // Creating into the origin outlives any single session: a reconnect re-announces the - // broadcast and new subscriptions land on the same producer. - const broadcastPublication = origin.createBroadcast(name); - const broadcast = broadcastPublication.broadcast; - // The publication mints one instance, kept across unannounce and announce, so a restart - // is a new stream rather than a resume into the old one. - effect.cleanup(() => broadcast.close()); + // Routing into the origin outlives any single session: a reconnect re-announces the + // broadcast and new subscriptions land on the same producer. Hidden until the catalog is + // served. The route mints one instance, kept across withdraw and announce, so toggling + // `announce` continues the same stream for viewers; a new route is a new stream. + const route = origin.route(name, { hidden: true }); + const broadcast = route.broadcast; + effect.cleanup(() => route.close()); // Expose it before serving so an application reacting to `net` can insert its own tracks. this.#net.set(broadcast); @@ -480,7 +480,7 @@ export class Broadcast { let serving = false; effect.run((inner) => { if (!inner.get(this.in.announce)) { - broadcastPublication.unannounce(); + route.withdraw(); return; } @@ -507,7 +507,7 @@ export class Broadcast { this.catalog.serve(track, effect); } - broadcastPublication.announce(); + route.announce(); }); // Static tracks fan out to every subscriber. The encoder-facing handle stays set while the diff --git a/js/watch/src/audio/decoder.test.ts b/js/watch/src/audio/decoder.test.ts index 43d10f911ad..91f1e7887fa 100644 --- a/js/watch/src/audio/decoder.test.ts +++ b/js/watch/src/audio/decoder.test.ts @@ -1118,7 +1118,7 @@ async function livePlayback(burst: number) { // Serve the same rendition from another path, as a `broadcast` override does. move(path: string) { media.peek().close(); - producer = new Moq.Origin.Producer().createBroadcast(Moq.Path.from(path)).broadcast; + producer = new Moq.Origin.Producer().route(Moq.Path.from(path), { hidden: true }).broadcast; track = producer.createTrack("audio", { timescale: Moq.Time.Timescale.MILLI }); sequence = 0n; media.set(producer.consume()); diff --git a/js/watch/src/broadcast.test.ts b/js/watch/src/broadcast.test.ts index 5f98ceeaa61..32e8ea4676a 100644 --- a/js/watch/src/broadcast.test.ts +++ b/js/watch/src/broadcast.test.ts @@ -9,10 +9,7 @@ import { Effect, Signal } from "@moq/signals"; import { Broadcast } from "./broadcast"; function publish(origin: Origin.Producer, path: Path.Valid) { - const broadcastPublication = origin.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); - return broadcast; + return origin.route(path).broadcast; } // A real origin with local broadcasts at the given paths. Resolution is proven by @@ -37,10 +34,10 @@ function broadcast(name: string, paths: string[] = [name]): { source: Broadcast; } // Answer every request `claim` receives with a new exact broadcast, returning the answers. -function serve(claim: Origin.Requests): Moq.Broadcast.Producer[] { +function serve(claim: Origin.Route): Moq.Broadcast.Producer[] { const answers: Moq.Broadcast.Producer[] = []; void (async () => { - for await (const request of claim.requested()) answers.push(request.prepare().publish().broadcast); + for await (const request of claim.requested()) answers.push(request.route().broadcast); })(); return answers; } @@ -340,16 +337,13 @@ describe("relativeBroadcast", () => { Moq.Instance.random(), Moq.Instance.random(), ]; - const catalogPublication = owner.createBroadcast(Path.from("a/b")); - const catalog = catalogPublication.broadcast; - catalogPublication.announce({ instance: catalogInstance }); - const siblingPublication = owner.createBroadcast(Path.from("a/source")); - const sibling = siblingPublication.broadcast; - siblingPublication.announce({ instance: siblingInstance }); + const catalogRoute = owner.route(Path.from("a/b"), { instance: catalogInstance }); + const catalog = catalogRoute.broadcast; + const siblingRoute = owner.route(Path.from("a/source"), { instance: siblingInstance }); + const sibling = siblingRoute.broadcast; // A route over a wire that carries no instance has one its session minted. - const plainPublication = owner.createBroadcast(Path.from("a/plain")); - const plain = plainPublication.broadcast; - plainPublication.announce({ instance: Moq.Instance.minted() }); + const plainRoute = owner.route(Path.from("a/plain"), { instance: Moq.Instance.minted() }); + const plain = plainRoute.broadcast; const source = new Broadcast({ origin: owner, name: Path.from("a/b"), @@ -387,9 +381,8 @@ describe("relativeBroadcast", () => { const owner = new Origin.Producer(); const main = publish(owner, Path.from("a/b")); const [oldInstance, newInstance] = [Moq.Instance.random(), Moq.Instance.random()]; - const oldPublication = owner.createBroadcast(Path.from("a/source")); - const old = oldPublication.broadcast; - oldPublication.announce({ instance: oldInstance }); + const oldRoute = owner.route(Path.from("a/source"), { instance: oldInstance }); + const old = oldRoute.broadcast; const source = new Broadcast({ origin: owner, name: Path.from("a/b"), @@ -413,9 +406,8 @@ describe("relativeBroadcast", () => { // The announcement is the online signal: the plain reference follows the restart, // while one naming the old instance never reads the new one. - const replacementPublication = owner.createBroadcast(Path.from("a/source")); - const replacement = replacementPublication.broadcast; - replacementPublication.announce({ instance: newInstance }); + const replacementRoute = owner.route(Path.from("a/source"), { instance: newInstance }); + const replacement = replacementRoute.broadcast; await settle(); expect(following?.instance).toBe(newInstance); expect(pinned).toBeUndefined(); @@ -433,9 +425,8 @@ describe("relativeBroadcast", () => { const owner = new Origin.Producer(); const main = publish(owner, Path.from("a/b")); const [oldInstance, newInstance] = [Moq.Instance.random(), Moq.Instance.random()]; - const oldPublication = owner.createBroadcast(Path.from("a/source")); - const old = oldPublication.broadcast; - oldPublication.announce({ instance: oldInstance }); + const oldRoute = owner.route(Path.from("a/source"), { instance: oldInstance }); + const old = oldRoute.broadcast; const named = { ...video("avc1.64001f", "./source"), instance: oldInstance } as Catalog.VideoConfig; const source = new Broadcast({ origin: owner, @@ -448,9 +439,8 @@ describe("relativeBroadcast", () => { await settle(); expect(videoRenditions(source)).toEqual(["named", "plain"]); - const replacementPublication = owner.createBroadcast(Path.from("a/source")); - const replacement = replacementPublication.broadcast; - replacementPublication.announce({ instance: newInstance }); + const replacementRoute = owner.route(Path.from("a/source"), { instance: newInstance }); + const replacement = replacementRoute.broadcast; await withoutWarnings(settle); expect(videoRenditions(source)).toEqual(["plain"]); replacement.close(); @@ -498,11 +488,11 @@ describe("blind resolution", () => { await settle(); // Stand in for a claim answering the request. - const route = owner.requests(Path.from("blind.hang")); + const route = owner.routePrefix(Path.from("blind.hang")); const requests = route.requested(); const next = await requests.next(); if (!next.value) throw new Error("expected a request"); - const upstream = next.value.prepare(Moq.Instance.random()).publish().broadcast; + const upstream = next.value.route().broadcast; await settle(); const active = source.out.active.peek(); @@ -610,7 +600,7 @@ describe("restart", () => { it("moves to a more specific announcement of another instance", async () => { const owner = new Origin.Producer(); const name = Path.from("pool/job.hang"); - const pool = owner.requests(Path.from("pool")); + const pool = owner.routePrefix(Path.from("pool")); const answers = serve(pool); const source = new Broadcast({ origin: owner, name, enabled: true, follow: true, catalogFormat: "manual" }); await settle(); @@ -618,9 +608,8 @@ describe("restart", () => { expect(old).toBeDefined(); // A newer publisher announces the path, which now serves the name: a restart. - const exactPublication = owner.createBroadcast(name); - const exact = exactPublication.broadcast; - exactPublication.announce(); + const exactRoute = owner.route(name); + const exact = exactRoute.broadcast; await settle(); const moved = source.out.active.peek(); expect(moved).toBeDefined(); @@ -642,9 +631,8 @@ describe("restart", () => { it("resumes on a covering prefix after a gap", async () => { const owner = new Origin.Producer(); const name = Path.from("pool/job.hang"); - const exactPublication = owner.createBroadcast(name); - const exact = exactPublication.broadcast; - exactPublication.announce(); + const exactRoute = owner.route(name); + const exact = exactRoute.broadcast; const source = new Broadcast({ origin: owner, name, enabled: true, follow: true, catalogFormat: "manual" }); await settle(); const old = source.out.active.peek(); @@ -653,7 +641,7 @@ describe("restart", () => { // The exact route goes, which ends the request on it, and a prefix answers before the table // is read again. The player still has to ask again. exact.close(); - const pool = owner.requests(Path.from("pool")); + const pool = owner.routePrefix(Path.from("pool")); const answers = serve(pool); await settle(); const resumed = source.out.active.peek(); @@ -671,7 +659,7 @@ describe("restart", () => { it("falls back to a covering prefix when the exact route ends", async () => { const owner = new Origin.Producer(); const name = Path.from("pool/job.hang"); - const pool = owner.requests(Path.from("pool")); + const pool = owner.routePrefix(Path.from("pool")); const answers = serve(pool); const exact = publish(owner, name); const source = new Broadcast({ origin: owner, name, enabled: true, follow: true, catalogFormat: "manual" }); @@ -704,7 +692,7 @@ describe("refusal", () => { it("reports an unroutable refusal of a restarted publisher", async () => { const owner = new Origin.Producer(); const name = Path.from("room/live.hang"); - const first = owner.requests(Path.from("room")); + const first = owner.routePrefix(Path.from("room")); const answers = serve(first); const source = new Broadcast({ origin: owner, name, enabled: true, follow: true, catalogFormat: "manual" }); await settle(); @@ -713,7 +701,7 @@ describe("refusal", () => { // The publisher restarts, and refuses with the same code an ended instance reports. first.close(); for (const answer of answers) answer.close(); - const second = owner.requests(Path.from("room")); + const second = owner.routePrefix(Path.from("room")); const refused = await second.requested().next(); refused.value?.reject(new Moq.Error.Stream(Moq.StreamCode.Unroutable, { message: "refused" })); await settle(); @@ -749,7 +737,7 @@ describe("refusal", () => { for (const follow of [true, false]) { it(`reports a refusal until a fresh request (follow: ${follow})`, async () => { const owner = new Origin.Producer(); - const route = owner.requests(Path.from("room")); + const route = owner.routePrefix(Path.from("room")); const requests = route.requested(); const name = new Signal(Path.from("room/refused.hang")); const enabled = new Signal(true); @@ -1031,7 +1019,7 @@ describe("wildcard renditions", () => { await settle(); expect(videoRenditions(source)).toEqual(["source"]); - const worker = owner.requests(Path.from(".pro/transcode")); + const worker = owner.routePrefix(Path.from(".pro/transcode")); const requests = worker.requested(); await settle(); expect(videoRenditions(source)).toEqual(["source", "transcode"]); @@ -1046,11 +1034,12 @@ describe("wildcard renditions", () => { expect(active).toBeUndefined(); if (!request) throw new Error("expected a request"); - const prepared = request.prepare(Moq.Instance.random()); - prepared.broadcast + const job = request.route({ hidden: true }); + job.broadcast .createTrack("video", { timescale: Moq.Time.Timescale.MILLI }) .writeFrame({ payload: new TextEncoder().encode("frame"), timestamp: Moq.Time.Timestamp.now() }); - const produced = prepared.publish().broadcast; + job.announce(); + const produced = job.broadcast; await settle(); expect(active).toBeDefined(); const track = active?.track("video").subscribe().ordered(); @@ -1077,8 +1066,8 @@ describe("wildcard renditions", () => { try { // A catch-all (an archive) and a narrower pool both cover the derived path. - const archive = owner.requests(Path.empty()); - const worker = owner.requests(Path.from(".pro/transcode")); + const archive = owner.routePrefix(Path.empty()); + const worker = owner.routePrefix(Path.from(".pro/transcode")); await settle(); expect(videoRenditions(source)).toEqual(["source", "transcode"]); diff --git a/js/watch/src/contribution.test.ts b/js/watch/src/contribution.test.ts index b87ead8372d..31384ab7885 100644 --- a/js/watch/src/contribution.test.ts +++ b/js/watch/src/contribution.test.ts @@ -8,8 +8,7 @@ import { Broadcast } from "./broadcast"; import { Source } from "./video/source"; function publish(origin: Origin.Producer, path: string, instance?: Instance.Valid) { - const publication = origin.createBroadcast(Path.from(path)); - publication.announce({ instance }); + const publication = origin.route(Path.from(path), { instance }); return publication.broadcast; } @@ -104,7 +103,7 @@ it("opens a listed contribution only on selection, keeping its rendition IDs its it("reads an unavailable contribution as offline without touching the parent", async () => { const origin = new Origin.Producer(); publish(origin, "room/main.hang"); - const claim = origin.requests(Path.from("room/absent.hang")); + const claim = origin.routePrefix(Path.from("room/absent.hang")); const requests = claim.requested(); const source = new Broadcast({ origin, diff --git a/js/watch/src/echo.ts b/js/watch/src/echo.ts index 32f2deaf016..e8104791003 100644 --- a/js/watch/src/echo.ts +++ b/js/watch/src/echo.ts @@ -125,11 +125,11 @@ export class Echo { let broadcast: Moq.Broadcast.Producer | undefined; let writer: Report.Writer; try { - const publication = origin.createBroadcast(path); - broadcast = publication.broadcast; - writer = new Report.Writer(broadcast, Schema.TRACK, Schema.SnapshotSchema); // A fresh instance, so a reader sees a replaced feedback broadcast as a restart. - publication.announce(); + const route = origin.route(path, { hidden: true }); + broadcast = route.broadcast; + writer = new Report.Writer(broadcast, Schema.TRACK, Schema.SnapshotSchema); + route.announce(); } catch (err) { broadcast?.close(); console.warn("failed to publish feedback", path, err); diff --git a/js/watch/src/player.test.ts b/js/watch/src/player.test.ts index d4f131d6a78..4921d4b81e6 100644 --- a/js/watch/src/player.test.ts +++ b/js/watch/src/player.test.ts @@ -35,8 +35,7 @@ test.each(["table", "consumer", "structural"] as const)("Player borrows a %s ori const player = new Player({ origin: origins[role], name, catalogFormat: "manual", catalog: {} }); try { const active = player.broadcast.out.active.changed(); - const publication = producer.createBroadcast(name); - publication.announce(); + const publication = producer.route(name); expect((await active)?.path).toBe(name); expect(player.in.origin.peek()).toBe(origins[role]); expect(player.broadcast.in.origin.peek()).toBe(origins[role]); diff --git a/js/watch/src/video/decoder.test.ts b/js/watch/src/video/decoder.test.ts index 67a4857dc24..9796330b246 100644 --- a/js/watch/src/video/decoder.test.ts +++ b/js/watch/src/video/decoder.test.ts @@ -432,7 +432,7 @@ async function guardedPlayback( republishMedia(path?: string): Moq.Track.Producer | undefined { media.peek().close(); mediaProducer = path - ? new Moq.Origin.Producer().createBroadcast(Moq.Path.from(path)).broadcast + ? new Moq.Origin.Producer().route(Moq.Path.from(path), { hidden: true }).broadcast : new Moq.Broadcast.Producer(); const track = live ? mediaProducer.createTrack("video", { timescale: Moq.Time.Timescale.MILLI }) diff --git a/rs/moq-net-tests/tests/announce_allocs.rs b/rs/moq-net-tests/tests/announce_allocs.rs index 77c0e0a80cb..019ab5864be 100644 --- a/rs/moq-net-tests/tests/announce_allocs.rs +++ b/rs/moq-net-tests/tests/announce_allocs.rs @@ -76,18 +76,23 @@ unsafe impl GlobalAlloc for Counting { #[global_allocator] static ALLOCATOR: Counting = Counting; -/// A route as `peer` would have announced it: one hop, at `cost`. -fn peer_route(peer: u64, cost: u64) -> origin::Route { +/// Land `peer`'s route at `path`, as a session does: one hop, at `cost`. +fn peer_route(producer: &origin::Producer, path: &'static str, peer: u64, cost: u64) -> origin::Route { let mut hops = Hops::new(); hops.push(Hop::new(peer).unwrap()).unwrap(); - origin::Route::default().with_hops(hops).with_cost(cost) + moq_net::fuzz::requests_route( + producer, + Path::from_static(path), + moq_net::fuzz::route_info(hops, cost, None), + ) + .unwrap() } /// Allocations made by a worse route arriving at a watched prefix and leaving /// again, with `cursors` cursors rooted at `root` watching it. fn churn_allocs(root: &str, cursors: usize) -> usize { let (producer, _driver) = origin::Producer::new(origin::Config::default()); - let _winner = producer.publish("room/a", peer_route(1, 1)).unwrap(); + let _winner = peer_route(&producer, "room/a", 1, 1); let all = Patterns::from(Pattern::all()); let mut cursors: Vec<_> = (0..cursors) .map(|_| producer.consume().scope(root, &all).unwrap().announced()) @@ -96,7 +101,7 @@ fn churn_allocs(root: &str, cursors: usize) -> usize { while cursor.try_next().is_some() {} } - let cycle = || drop(producer.publish("room/a", peer_route(2, 5)).unwrap()); + let cycle = || drop(peer_route(&producer, "room/a", 2, 5)); // Reach the steady state first, with every table grown to what it settles at. for _ in 0..4 { cycle(); @@ -247,8 +252,11 @@ async fn a_lite_request_keeps_one_copy_of_its_track_name() { let version: Version = version.parse().unwrap(); let (publisher, driver) = origin::Producer::new(origin::Config::new(Hop::new(1).unwrap())); spawn(driver); - let broadcast = publisher.publish("room", Default::default()).unwrap(); - let track = broadcast.create_track(TRACK, track::Info::default()).unwrap(); + let broadcast = publisher.route("room", origin::RouteOptions::default()).unwrap(); + let track = broadcast + .broadcast() + .create_track(TRACK, track::Info::default()) + .unwrap(); let (viewer, driver) = origin::Producer::new(origin::Config::new(Hop::new(2).unwrap())); spawn(driver); diff --git a/rs/moq-net-tests/tests/integration/hop_limit.rs b/rs/moq-net-tests/tests/integration/hop_limit.rs new file mode 100644 index 00000000000..965bb6569e6 --- /dev/null +++ b/rs/moq-net-tests/tests/integration/hop_limit.rs @@ -0,0 +1,154 @@ +//! The relay's hop limit refuses a route whose chain is already too long and never +//! forwards one it has no room to stamp. +//! +//! Only a peer's route arrives with hops, so the routes under test land through the +//! hidden `fuzz` module as a session lands them. + +use crate::support::{ + Kind, drain, + harness::{peer, spawn}, + watch, +}; + +use moq_net::{Hop, cache, origin}; + +fn produce_origin(hop: u64) -> origin::Producer { + let mut config = origin::Config::new(Hop::new(hop).unwrap()); + config.pool = cache::Pool::unbounded(); + let (producer, driver) = origin::Producer::new(config); + spawn(driver); + producer +} + +/// Land a peer's route at `path` on `origin`, as its session does. +fn forward(origin: &origin::Producer, path: &str, route: origin::RouteInfo) -> origin::Route { + moq_net::fuzz::requests_route(origin, moq_net::Path::new(path).unwrap(), route).unwrap() +} + +/// A permissive source sends an over-limit path to prove ingress refusal; an +/// accepted boundary path then proves egress counts the relay's own stamp. +#[kio::test] +async fn hop_limit_bounds_receive_and_send() { + for name in [ + "moq-lite-03", + "moq-lite-04", + "moq-lite-05", + "moq-lite-06", + "moq-lite-07-wip", + "moq-transport-18", + "moq-transport-22", + ] { + let version = name.parse().unwrap(); + let source = produce_origin(1); + let mut config = origin::Config::new(Hop::new(2).unwrap()); + config.max_hops = origin::HopLimit::new(2).unwrap(); + config.pool = cache::Pool::unbounded(); + let (relay, driver) = origin::Producer::new(config); + spawn(driver); + let sink = produce_origin(3); + let _upstream = peer(version, &source, &relay).await; + let _downstream = peer(version, &relay, &sink).await; + let mut received = watch(relay.consume().announced()); + let mut sent = watch(sink.consume().announced()); + kio::clock::sim::idle().await; + let route = |count: u64| { + moq_net::fuzz::route_info( + moq_net::Hops::try_from((100..100 + count).map(|id| Hop::new(id).unwrap()).collect::>()) + .unwrap(), + 0, + None, + ) + }; + let _long = forward(&source, "long", route(2)); + let _boundary = forward(&source, "boundary", route(1)); + let short = forward(&source, "short", route(0)); + kio::clock::sim::idle().await; + let received = drain(&mut received); + assert!(!received.contains_key("long"), "{name}: accepted over-limit path"); + assert!(received.contains_key("boundary"), "{name}: refused boundary path"); + assert!(received.contains_key("short"), "{name}: refused short path"); + let sent_initial = drain(&mut sent); + assert_eq!(sent_initial.len(), 1, "{name}: {sent_initial:?}"); + assert!(sent_initial.contains_key("short"), "{name}: forwarded over-limit path"); + + if matches!(name, "moq-lite-03" | "moq-lite-04") { + // These wires have no route metadata update: withdraw, then replace it. + drop(short); + kio::clock::sim::idle().await; + assert_eq!( + drain(&mut sent).get("short").and_then(|kinds| kinds.last()), + Some(&Kind::End), + "{name}" + ); + let _replacement = forward(&source, "short", route(1)); + kio::clock::sim::idle().await; + assert!(drain(&mut sent).is_empty(), "{name}: forwarded over-limit replacement"); + continue; + } + moq_net::fuzz::update_route(&short, route(1)).unwrap(); + kio::clock::sim::idle().await; + let ended = drain(&mut sent); + assert_eq!( + ended.get("short").and_then(|kinds| kinds.last()), + Some(&Kind::End), + "{name}: {ended:?}" + ); + } +} + +/// A cheaper route at the cap wins locally but cannot be forwarded, so the relay +/// advertises the pricier in-cap route instead of withdrawing the prefix, and +/// withdraws only once no in-cap route is left. +#[kio::test] +async fn hop_limit_falls_back_to_a_forwardable_route() { + // Only wires carrying a route cost can rank a longer route first. + for name in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { + let version = name.parse().unwrap(); + let near = produce_origin(1); + let far = produce_origin(4); + let mut config = origin::Config::new(Hop::new(2).unwrap()); + config.max_hops = origin::HopLimit::new(3).unwrap(); + config.pool = cache::Pool::unbounded(); + let (relay, driver) = origin::Producer::new(config); + spawn(driver); + let sink = produce_origin(3); + let _near = peer(version, &near, &relay).await; + let _far = peer(version, &far, &relay).await; + let _downstream = peer(version, &relay, &sink).await; + let mut sent = watch(sink.consume().announced()); + kio::clock::sim::idle().await; + + let route = |first: u64, count: u64, cost: u64| { + moq_net::fuzz::route_info( + moq_net::Hops::try_from( + (first..first + count) + .map(|id| Hop::new(id).unwrap()) + .collect::>(), + ) + .unwrap(), + cost, + None, + ) + }; + // Three hops at the relay once the sender is appended: in the cap, but full. + let _cheap = forward(&far, "room", route(100, 2, 1)); + // Two hops at the relay, so it has room for the relay's own. + let pricey = forward(&near, "room", route(200, 1, 50)); + kio::clock::sim::idle().await; + let started = drain(&mut sent); + assert_eq!( + started.get("room").and_then(|kinds| kinds.last()), + Some(&Kind::Start), + "{name}: withdrew a prefix an in-cap route reaches: {started:?}" + ); + + drop(pricey); + kio::clock::sim::idle().await; + let ended = drain(&mut sent); + assert_eq!( + ended.get("room").and_then(|kinds| kinds.last()), + Some(&Kind::End), + "{name}: forwarded a route at the cap: {ended:?}" + ); + } +} diff --git a/rs/moq-net-tests/tests/integration/ietf_conformance.rs b/rs/moq-net-tests/tests/integration/ietf_conformance.rs index c0ad21768a5..a3501f37cf3 100644 --- a/rs/moq-net-tests/tests/integration/ietf_conformance.rs +++ b/rs/moq-net-tests/tests/integration/ietf_conformance.rs @@ -30,7 +30,7 @@ async fn routing(version: &str, cluster: bool) { let serving = prefix.clone(); let answer = broadcast.consume(); kio::clock::sim::spawn(async move { - let request = serving.requested_broadcast().await.unwrap(); + let request = serving.requested().await.unwrap(); assert_eq!(request.path().as_str(), NAMESPACE); request.serve(answer); }); diff --git a/rs/moq-net-tests/tests/integration/main.rs b/rs/moq-net-tests/tests/integration/main.rs index ea8f634857e..32049acd41a 100644 --- a/rs/moq-net-tests/tests/integration/main.rs +++ b/rs/moq-net-tests/tests/integration/main.rs @@ -1,5 +1,6 @@ //! Session tests that need JSON consumers or the hidden peer-claim hooks. +mod hop_limit; mod ietf_conformance; mod refresh; mod restart; diff --git a/rs/moq-net-tests/tests/integration/refresh.rs b/rs/moq-net-tests/tests/integration/refresh.rs index 5b5df917977..d3bdab8acba 100644 --- a/rs/moq-net-tests/tests/integration/refresh.rs +++ b/rs/moq-net-tests/tests/integration/refresh.rs @@ -24,8 +24,9 @@ async fn json_snapshot_refresh_crosses_a_two_relay_cluster() { let a = origin(2); let b = origin(3); let reader = origin(4); - let broadcast = source.create_broadcast("room").unwrap(); + let broadcast = source.route("room", origin::RouteOptions::hidden()).unwrap(); let track = broadcast + .broadcast() .create_track( "state", track::Info::default() @@ -34,7 +35,7 @@ async fn json_snapshot_refresh_crosses_a_two_relay_cluster() { ) .unwrap(); let mut producer = snapshot::Producer::::new(track.clone(), Default::default()); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut links = vec![peer(version, &a, &b).await]; for (upstream, downstream) in [(&source, &a), (&b, &reader)] { let mut options = MockConnectOptions::new(version); @@ -154,11 +155,12 @@ async fn ratio_joins_cross_two_relays() { let source = origin(1); let a = origin(2); let b = origin(3); - let broadcast = source.create_broadcast("room").unwrap(); + let broadcast = source.route("room", origin::RouteOptions::hidden()).unwrap(); let producer = broadcast + .broadcast() .create_track("data", track::Info::default().with_refresh(1)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut links = Vec::new(); for (upstream, downstream) in [(&source, &a), (&a, &b)] { let mut options = MockConnectOptions::new(version); diff --git a/rs/moq-net-tests/tests/integration/restart.rs b/rs/moq-net-tests/tests/integration/restart.rs index e28531445b0..aceb592e6f9 100644 --- a/rs/moq-net-tests/tests/integration/restart.rs +++ b/rs/moq-net-tests/tests/integration/restart.rs @@ -119,8 +119,8 @@ async fn relay_chain(version: &str) { let _upstream = link(version, &publisher, &relay).await; let _downstream = link(version, &relay, &viewer).await; - let old = publisher.publish("live", origin::Route::default()).unwrap(); - let old_track = old.create_track("video", timed()).unwrap(); + let old = publisher.route("live", origin::RouteOptions::default()).unwrap(); + let old_track = old.broadcast().create_track("video", timed()).unwrap(); let mut announced = viewer.consume().announced(); match next_event(&mut announced).await { announce::Event::Start(announce) => assert_eq!(announce.prefix.as_str(), "live"), @@ -134,8 +134,8 @@ async fn relay_chain(version: &str) { } // The publisher restarts under another instance, its old session still open. - let new = publisher.publish("live", origin::Route::default()).unwrap(); - let new_track = new.create_track("video", timed()).unwrap(); + let new = publisher.route("live", origin::RouteOptions::default()).unwrap(); + let new_track = new.broadcast().create_track("video", timed()).unwrap(); expect_restart(version, &mut announced, "live").await; // The old subscription stays on the old instance. @@ -174,7 +174,7 @@ relay_chain_tests! { /// the hidden `fuzz` module as a session lands it, so its answers carry no exact route. struct Worker { origin: origin::Producer, - _claim: Rc, + _claim: Rc, _outputs: Rc>>, } @@ -185,14 +185,18 @@ impl Worker { moq_net::fuzz::requests_route( &origin, moq_net::Path::from_static("pool"), - origin::Route::default().with_instance(format!("worker-{hop}").parse().unwrap(), 0), + moq_net::fuzz::route_info( + moq_net::Hops::new(), + 0, + Some((format!("worker-{hop}").parse().unwrap(), 0)), + ), ) .unwrap(), ); let outputs = Rc::new(RefCell::new(Vec::new())); let (handler, served) = (claim.clone(), outputs.clone()); drop(kio::clock::sim::spawn(async move { - while let Ok(request) = handler.requested_broadcast().await { + while let Some(request) = handler.requested().await { let output = broadcast::Info::new().produce(); let track = output.create_track("video", timed()).unwrap(); write(&track, &format!("{hop}")); @@ -242,7 +246,7 @@ async fn prefix_pool(version: &str) { // The worker whose instance `D`'s route for `pool` names. let advertised = |announce: announce::Announce| { assert_eq!(announce.prefix.as_str(), "pool"); - let instance = announce.route.instance.expect("a delivered route has an instance"); + let instance = announce.route.instance().clone(); instance.as_str().strip_prefix("worker-").expect("a worker").to_string() }; let mut announced = downstream.consume().announced(); @@ -302,27 +306,32 @@ async fn prefix_pool_lite07() { /// claim moves to another instance or re-prices in place, so it lands through the hidden /// `fuzz` module as a session lands it. struct Claim { - dynamic: Rc, + dynamic: Rc, outputs: Rc>>, + /// The price the claim advertises, kept across an instance move. + cost: std::cell::Cell, } impl Claim { fn new(origin: &origin::Producer, instance: Option) -> Self { - let mut route = origin::Route::default(); - route.instance = instance; + let route = moq_net::fuzz::route_info(moq_net::Hops::new(), 0, instance.map(|instance| (instance, 0))); let dynamic = Rc::new(moq_net::fuzz::requests_route(origin, moq_net::Path::from_static("live"), route).unwrap()); let outputs = Rc::new(RefCell::new(Vec::new())); let (handler, served) = (dynamic.clone(), outputs.clone()); drop(kio::clock::sim::spawn(async move { - while let Ok(request) = handler.requested_broadcast().await { + while let Some(request) = handler.requested().await { let output = broadcast::Info::new().produce(); let track = output.create_track("video", timed()).unwrap(); request.serve(&output); served.borrow_mut().push((output, track)); } })); - Self { dynamic, outputs } + Self { + dynamic, + outputs, + cost: Default::default(), + } } /// Write `tag` into the output that answered the `n`th request. @@ -336,11 +345,14 @@ impl Claim { /// Move the claim to `instance` in place, keeping the rest of its route. fn update_instance(&self, instance: Instance) { - let route = self.dynamic.route().with_instance(instance, 0); - self.update_route(route); + let route = moq_net::fuzz::route_info(moq_net::Hops::new(), self.cost.get(), Some((instance, 0))); + moq_net::fuzz::update_route(&self.dynamic, route).unwrap(); } - fn update_route(&self, route: origin::Route) { + /// Re-price the claim in place, keeping its instance. + fn update_cost(&self, cost: u64) { + self.cost.set(cost); + let route = moq_net::fuzz::route_info(moq_net::Hops::new(), cost, None); moq_net::fuzz::update_route(&self.dynamic, route).unwrap(); } } @@ -369,7 +381,7 @@ async fn dynamic_instance(version: &str, from: Option, to: Instance) { assert_eq!(read(&mut sticky).await, "old:0", "{version}"); // A re-price is an update at most: every handle survives. - claim.update_route(claim.dynamic.route().with_cost(5)); + claim.update_cost(5); while let Ok(event) = kio::clock::timeout(Duration::from_secs(1), announced.next()).await { assert!( matches!(event, Some(announce::Event::Update(_))), @@ -451,17 +463,17 @@ async fn retired_fetch(version: &str, explicit: bool) { let _session = link(version, &publisher, &viewer).await; let (a, b) = instances(); let old_route = if explicit { - origin::Route::default().with_instance(a, 0) + origin::RouteOptions::default().with_instance(a, 0) } else { - origin::Route::default() + origin::RouteOptions::default() }; let new_route = if explicit { - origin::Route::default().with_instance(b, 0) + origin::RouteOptions::default().with_instance(b, 0) } else { - origin::Route::default() + origin::RouteOptions::default() }; - let old = publisher.publish("live", old_route).unwrap(); - let old_track = old.create_track("video", timed()).unwrap(); + let old = publisher.route("live", old_route).unwrap(); + let old_track = old.broadcast().create_track("video", timed()).unwrap(); let mut announced = viewer.consume().announced(); assert!(matches!(next_event(&mut announced).await, announce::Event::Start(_))); let (held, mut subscription) = subscribe(&viewer, "live").await; @@ -469,9 +481,10 @@ async fn retired_fetch(version: &str, explicit: bool) { write(&old_track, "old:0"); assert_eq!(read(&mut subscription).await, "old:0"); - let replacement = publisher.publish("live", new_route).unwrap(); - let replacement_track = replacement.create_track("video", timed()).unwrap(); + let replacement = publisher.route("live", new_route).unwrap(); + let replacement_track = replacement.broadcast().create_track("video", timed()).unwrap(); let _late = replacement + .broadcast() .create_track("late", Some(track::Info::default().with_priority(17))) .unwrap(); write(&replacement_track, "new:0"); @@ -537,9 +550,9 @@ async fn unanswered_takeover(version: &str) { let publisher = produce_origin(1); let viewer = produce_origin(2); let _session = link(version, &publisher, &viewer).await; - let old = publisher.publish("live", origin::Route::default()).unwrap(); + let old = publisher.route("live", origin::RouteOptions::default()).unwrap(); // Quiet, so the publisher has nothing to answer the SUBSCRIBE with yet. - let old_track = old.create_track("video", timed()).unwrap(); + let old_track = old.broadcast().create_track("video", timed()).unwrap(); let mut announced = viewer.consume().announced(); assert!(matches!(next_event(&mut announced).await, announce::Event::Start(_))); let (_held, mut subscription) = subscribe(&viewer, "live").await; @@ -549,8 +562,8 @@ async fn unanswered_takeover(version: &str) { "{version}: the SUBSCRIBE reached the old instance" ); - let replacement = publisher.publish("live", origin::Route::default()).unwrap(); - let replacement_track = replacement.create_track("video", timed()).unwrap(); + let replacement = publisher.route("live", origin::RouteOptions::default()).unwrap(); + let replacement_track = replacement.broadcast().create_track("video", timed()).unwrap(); write(&replacement_track, "new:0"); expect_restart(version, &mut announced, "live").await; write(&old_track, "old:0"); @@ -597,15 +610,15 @@ async fn withdrawal_refuses_new_fetches_but_keeps_open_reads() { let publisher = produce_origin(1); let viewer = produce_origin(2); let _session = link(version, &publisher, &viewer).await; - let source = publisher.publish("live", origin::Route::default()).unwrap(); - let produced = source.create_track("video", timed()).unwrap(); + let source = publisher.route("live", origin::RouteOptions::default()).unwrap(); + let produced = source.broadcast().create_track("video", timed()).unwrap(); let mut announced = viewer.consume().announced(); assert!(matches!(next_event(&mut announced).await, announce::Event::Start(_))); let (held, mut subscription) = subscribe(&viewer, "live").await; let track = held.track("video").unwrap(); write(&produced, "old:0"); assert_eq!(read(&mut subscription).await, "old:0"); - source.unannounce(); + source.withdraw(); assert!(matches!(next_event(&mut announced).await, announce::Event::End(_))); assert!(track.fetch_group(1, None).await.is_err(), "{version}"); write(&produced, "old:1"); @@ -627,8 +640,8 @@ async fn a_more_specific_source_cannot_fill_a_held_covering_track() { let track = held.track("video").unwrap(); old.write(0, "old:0"); assert_eq!(read(&mut subscription).await, "old:0"); - let replacement = publisher.publish("live/job", origin::Route::default()).unwrap(); - let replacement_track = replacement.create_track("video", timed()).unwrap(); + let replacement = publisher.route("live/job", origin::RouteOptions::default()).unwrap(); + let replacement_track = replacement.broadcast().create_track("video", timed()).unwrap(); write(&replacement_track, "new:0"); write(&replacement_track, "new:1"); assert!(matches!(next_event(&mut announced).await, announce::Event::Start(_))); @@ -641,26 +654,26 @@ async fn a_more_specific_source_cannot_fill_a_held_covering_track() { } } -/// A worker claiming `pool` through the public API: each request is prepared under a -/// fresh instance and published at its exact path, and `outputs[path]` holds the latest. +/// A worker claiming `pool` through the public API: each request is answered with its own +/// exact route under a fresh instance, and `outputs[path]` holds the latest. struct Pool { - _claim: Rc, - outputs: Rc>>, + _claim: Rc, + outputs: Rc>>, answered: Rc>, } impl Pool { fn new(origin: &origin::Producer) -> Self { - let claim = Rc::new(origin.requests("pool").unwrap()); + let claim = Rc::new(origin.route_prefix("pool", origin::RouteOptions::default()).unwrap()); let outputs = Rc::new(RefCell::new(std::collections::HashMap::new())); let answered = Rc::new(RefCell::new(0)); let (handler, served, count) = (claim.clone(), outputs.clone(), answered.clone()); drop(kio::clock::sim::spawn(async move { - while let Ok(request) = handler.requested_broadcast().await { + while let Some(request) = handler.requested().await { let path = request.path().to_string(); - let prepared = request.prepare().unwrap(); - let track = prepared.broadcast().create_track("video", timed()).unwrap(); - let output = prepared.publish().unwrap(); + let output = request.route(origin::RouteOptions::hidden()).unwrap(); + let track = output.broadcast().create_track("video", timed()).unwrap(); + output.announce().unwrap(); served.borrow_mut().insert(path, (output, track)); *count.borrow_mut() += 1; } @@ -678,7 +691,7 @@ impl Pool { /// End the output at `path`, as a worker does when it restarts that job. fn close(&self, path: &str) { - self.outputs.borrow()[path].0.close(); + self.outputs.borrow()[path].0.broadcast().close(); } } @@ -775,9 +788,9 @@ async fn priority_update(version: &str, relayed: bool, switch: bool) { let (a, b) = instances(); let old = publisher - .publish("live", origin::Route::default().with_instance(a, 0)) + .route("live", origin::RouteOptions::default().with_instance(a, 0)) .unwrap(); - let old_track = old.create_track("video", timed()).unwrap(); + let old_track = old.broadcast().create_track("video", timed()).unwrap(); let mut announced = viewer.consume().announced(); assert!( matches!(next_event(&mut announced).await, announce::Event::Start(_)), @@ -790,7 +803,7 @@ async fn priority_update(version: &str, relayed: bool, switch: bool) { let _new = switch.then(|| { publisher - .publish("live", origin::Route::default().with_instance(b, 0)) + .route("live", origin::RouteOptions::default().with_instance(b, 0)) .unwrap() }); if switch { diff --git a/rs/moq-net-tests/tests/integration/serve.rs b/rs/moq-net-tests/tests/integration/serve.rs index 3783678f6ff..6e8c32996f5 100644 --- a/rs/moq-net-tests/tests/integration/serve.rs +++ b/rs/moq-net-tests/tests/integration/serve.rs @@ -16,7 +16,7 @@ async fn first_subscribe(version: &str, publish: bool) { let version: Version = version.parse().unwrap(); let server = origin(1); let client = origin(2); - let requests = server.requests("").unwrap(); + let requests = server.route_prefix("", origin::RouteOptions::default()).unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(server.consume()); options.client_subscribe = Some(client.clone()); @@ -42,7 +42,12 @@ async fn first_subscribe(version: &str, publish: bool) { group.finish().unwrap(); let handler = async { if publish { - let prepared = requests.requested_broadcast().await.unwrap().prepare().unwrap(); + let prepared = requests + .requested() + .await + .unwrap() + .route(origin::RouteOptions::hidden()) + .unwrap(); let track = prepared .broadcast() .create_track( @@ -53,13 +58,14 @@ async fn first_subscribe(version: &str, publish: bool) { let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"held".as_slice()).unwrap(); group.finish().unwrap(); - Some((prepared.publish().unwrap(), track)) + prepared.announce().unwrap(); + Some((prepared, track)) } else { - requests.requested_broadcast().await.unwrap().serve(&held); + requests.requested().await.unwrap().serve(&held); None } }; - let (result, _publication) = futures::join!(read, handler); + let (result, _route) = futures::join!(read, handler); if publish && version != "moq-lite-07-wip".parse().unwrap() { assert!( result.is_err(), diff --git a/rs/moq-net/benches/announce.rs b/rs/moq-net/benches/announce.rs index f494c5ec8f7..829b3a8e237 100644 --- a/rs/moq-net/benches/announce.rs +++ b/rs/moq-net/benches/announce.rs @@ -55,7 +55,7 @@ fn initial(c: &mut Criterion) { announce::Event::Update(announce::Announce { prefix: moq_net::Path::new(&format!("route/{route}")).unwrap(), captures: None, - route: moq_net::origin::RouteInfo::default().with_cost(cost), + route: moq_net::fuzz::route_info(moq_net::Hops::new(), cost, None), }) }) }) diff --git a/rs/moq-net/benches/auth.rs b/rs/moq-net/benches/auth.rs index d49a4a46f1c..5b2efc87fcf 100644 --- a/rs/moq-net/benches/auth.rs +++ b/rs/moq-net/benches/auth.rs @@ -193,29 +193,34 @@ fn renewal(c: &mut Criterion) { } auths }); - let broadcasts: Vec<_> = (0..routes) - .map(|route| origin.route(format!("room/{route}").as_str(), moq_net::origin::RouteOptions::hidden()).unwrap()) - .collect(); - let mut swap = |next: usize, touched: usize| { - for (index, broadcast) in broadcasts.iter().take(touched).enumerate() { - broadcast - .announce(origin::RouteInfo::default().with_auth(auths[index][next].clone())) - .unwrap(); - } + let mut accept = |count: usize| { runtime.block_on(async { - let mut issued = Vec::with_capacity(touched); - for _ in 0..touched { + let mut issued = Vec::with_capacity(count); + for _ in 0..count { issued.push(requests.next().await.unwrap().accept(auth::Grant::all())); } issued }) }; + let broadcasts: Vec<_> = (0..routes) + .map(|route| { + origin + .route( + format!("room/{route}").as_str(), + origin::RouteOptions::default().with_auth(auths[route][0].clone()), + ) + .unwrap() + }) + .collect(); // Each round's grants replace the last round's, which drop once their // renewals are accepted. - let mut held = swap(0, routes); + let mut held = accept(routes); let mut next = 1; b.iter(|| { - let replacements = swap(next, touched); + for (index, broadcast) in broadcasts.iter().take(touched).enumerate() { + broadcast.set_auth(Some(auths[index][next].clone())).unwrap(); + } + let replacements = accept(touched); drop(held.splice(..touched, replacements)); next ^= 1; }); @@ -274,8 +279,12 @@ fn waiting(c: &mut Criterion) { generation += 1; let broadcasts: Vec<_> = (0..paths) .map(|path| { - let broadcast = - publish.route(format!("{prefix}{path}").as_str(), moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publish + .route( + format!("{prefix}{path}").as_str(), + moq_net::origin::RouteOptions::hidden(), + ) + .unwrap(); broadcast.announce().unwrap(); broadcast }) @@ -360,7 +369,10 @@ fn shared_requests(c: &mut Criterion) { for request in 0..requests { broadcasts.push( origin - .route(format!("{prefix}/{token}/{request}").as_str(), moq_net::origin::RouteOptions::default().with_auth(auth.clone())) + .route( + format!("{prefix}/{token}/{request}").as_str(), + moq_net::origin::RouteOptions::default().with_auth(auth.clone()), + ) .unwrap(), ); } diff --git a/rs/moq-net/benches/memory.rs b/rs/moq-net/benches/memory.rs index 59ab2b41c08..ff801ab5dc1 100644 --- a/rs/moq-net/benches/memory.rs +++ b/rs/moq-net/benches/memory.rs @@ -147,10 +147,17 @@ impl Link { } ); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); let tracks: Vec<_> = (0..streams) - .map(|index| broadcast.broadcast().create_track(format!("{index}"), info.clone()).unwrap()) + .map(|index| { + broadcast + .broadcast() + .create_track(format!("{index}"), info.clone()) + .unwrap() + }) .collect(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index d23c6bc0ebe..1dfc22df55f 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -82,7 +82,11 @@ fn fanout(publishers: usize, subscribers: usize) -> Fanout { let (producer, driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); let publishers = (0..publishers) - .map(|i| producer.route(format!("room/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) + .map(|i| { + producer + .route(format!("room/{i}"), moq_net::origin::RouteOptions::default()) + .unwrap() + }) .collect(); let mut subscribers: Vec = (0..subscribers).map(|_| consumer.announced()).collect(); // Drain the replay so each iteration measures only what it adds. @@ -134,7 +138,11 @@ fn bench_announce_covering(c: &mut Criterion) { group.bench_function(format!("{routes}routes_{readers}readers_covering{covering}"), |b| { let (producer, _driver) = origin::Producer::new(origin::Config::default()); let _routes: Vec<_> = (0..routes) - .map(|i| producer.route_prefix(format!("room/{i}/mic.hang"), moq_net::origin::RouteOptions::default()).unwrap()) + .map(|i| { + producer + .route_prefix(format!("room/{i}/mic.hang"), moq_net::origin::RouteOptions::default()) + .unwrap() + }) .collect(); let consumer = producer .consume() @@ -147,7 +155,9 @@ fn bench_announce_covering(c: &mut Criterion) { } b.iter(|| { for (name, delivered) in [("room/live.chat", true), ("room/mic.hang", covering)] { - let route = producer.route_prefix(name, moq_net::origin::RouteOptions::default()).unwrap(); + let route = producer + .route_prefix(name, moq_net::origin::RouteOptions::default()) + .unwrap(); for cursor in &mut cursors { assert_eq!(cursor.next().now_or_never().flatten().is_some(), delivered); } @@ -172,7 +182,11 @@ fn bench_pending_churn(c: &mut Criterion) { group.bench_function(format!("{routes}routes_{readers}readers"), |b| { let (producer, _driver) = origin::Producer::new(origin::Config::default()); let _routes: Vec<_> = (0..routes) - .map(|i| producer.route(format!("z/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) + .map(|i| { + producer + .route(format!("z/{i}"), moq_net::origin::RouteOptions::default()) + .unwrap() + }) .collect(); let mut cursors: Vec<_> = (0..readers).map(|_| producer.consume().announced()).collect(); let mut sequence = 0u64; @@ -256,9 +270,7 @@ fn bench_withdraw_wave(c: &mut Criterion) { for &hop in chain { hops.push(Hop::new(hop).unwrap()).unwrap(); } - origin::RouteInfo::default() - .with_instance(instance.clone(), 0) - .with_hops(hops) + moq_net::fuzz::route_info(hops, 0, Some((instance.clone(), 0))) }; for broadcasts in [1_000, 10_000] { for subscribers in [1, 20, 100] { @@ -401,7 +413,9 @@ fn bench_announce_mounted(c: &mut Criterion) { } b.iter(|| { - let handle = producer.route(".svc/p0/incoming", moq_net::origin::RouteOptions::default()).unwrap(); + let handle = producer + .route(".svc/p0/incoming", moq_net::origin::RouteOptions::default()) + .unwrap(); for cursor in &mut cursors { cursor.next().now_or_never().flatten().expect("announce delivered"); } @@ -431,7 +445,10 @@ fn bench_announce_fleet(c: &mut Criterion) { .flat_map(|project| (0..nodes).map(move |node| (project, node))) .map(|(project, node)| { producer - .route(format!(".stats/p{project}/node/edge{node}"), moq_net::origin::RouteOptions::default()) + .route( + format!(".stats/p{project}/node/edge{node}"), + moq_net::origin::RouteOptions::default(), + ) .unwrap() }) .collect(); @@ -577,7 +594,10 @@ fn bench_reprice_duplicate(c: &mut Criterion) { let moq_net::announce::Event::Restart(update) = event else { panic!("expected a restart: got {event:?}"); }; - assert_eq!(update.route.cost, moq_net::origin::Cost::new(cost.min(incumbent_cost))); + assert_eq!( + update.route.cost(), + moq_net::origin::Cost::new(cost.min(incumbent_cost)) + ); } } }); @@ -596,9 +616,14 @@ const INCUMBENT_COST: u64 = 2; /// A route as `peer` would have announced it: one hop, at `cost`. fn peer_route(peer: u64, cost: u64) -> origin::RouteInfo { + peer_instance(peer, cost, None) +} + +/// [`peer_route`], serving `instance` when it names one. +fn peer_instance(peer: u64, cost: u64, instance: Option) -> origin::RouteInfo { let mut hops = Hops::new(); hops.push(Hop::new(peer).expect("peer id")).expect("hop chain"); - origin::RouteInfo::default().with_hops(hops).with_cost(cost) + moq_net::fuzz::route_info(hops, cost, instance.map(|instance| (instance, 0))) } /// An announcement of an unrelated prefix with `fronts` remote fronts parked on @@ -612,7 +637,9 @@ fn bench_announce_fronts(c: &mut Criterion) { let (producer, mut driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); // Served but never answered: every request under it parks a front. - let _served = producer.route_prefix("room", moq_net::origin::RouteOptions::default()).unwrap(); + let _served = producer + .route_prefix("room", moq_net::origin::RouteOptions::default()) + .unwrap(); let _requests: Vec<_> = (0..fronts) .map(|i| consumer.request(format!("room/{i}"), None)) .collect(); @@ -620,7 +647,9 @@ fn bench_announce_fronts(c: &mut Criterion) { // Run each front once so it parks on its upstream request. driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); b.iter(|| { - let handle = producer.route("other/incoming", moq_net::origin::RouteOptions::default()).unwrap(); + let handle = producer + .route("other/incoming", moq_net::origin::RouteOptions::default()) + .unwrap(); driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); drop(handle); driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); @@ -639,7 +668,7 @@ fn answer(claim: &origin::Route, path: &str) -> origin::Route { .expect("the request reached the claim") .unwrap(); if request.path().as_str() == path { - return request.route(moq_net::origin::RouteOptions::hidden()).unwrap().announce().unwrap(); + return request.route(moq_net::origin::RouteOptions::default()).unwrap(); } } } @@ -656,7 +685,9 @@ fn bench_takeover(c: &mut Criterion) { |b| { let (producer, mut driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); - let claim = producer.route_prefix("room", moq_net::origin::RouteOptions::default()).unwrap(); + let claim = producer + .route_prefix("room", moq_net::origin::RouteOptions::default()) + .unwrap(); let waiter = kio::Waiter::noop(); let mut ask = |path: &str| { let request = consumer.request(path, None); @@ -710,7 +741,14 @@ fn bench_serve_idle(c: &mut Criterion) { let (producer, _driver) = origin::Producer::new(origin::Config::default()); // One route per announced path, exactly as a session lands a peer's. let dynamics: Vec<_> = (0..routes) - .map(|i| producer.route_prefix(format!(".stats/p{}/node/edge{i}", i % 8), moq_net::origin::RouteOptions::default()).unwrap()) + .map(|i| { + producer + .route_prefix( + format!(".stats/p{}/node/edge{i}", i % 8), + moq_net::origin::RouteOptions::default(), + ) + .unwrap() + }) .collect(); b.iter(|| { // A fresh waiter per sweep, so every poll pays a real registration: a @@ -718,7 +756,7 @@ fn bench_serve_idle(c: &mut Criterion) { let waiter = kio::Waiter::noop(); // Nothing is queued, so every poll parks again: the idle sweep. for dynamic in &dynamics { - assert!(dynamic.poll_requested_broadcast(&waiter).is_pending()); + assert!(dynamic.poll_requested(&waiter).is_pending()); } }); }); @@ -756,7 +794,10 @@ fn bench_request(c: &mut Criterion) { for publishers in [100, 1_000] { for requesters in [1, 8, 32] { let mut fleet = fanout(publishers, 0); - let _covering = fleet.producer.route("room", moq_net::origin::RouteOptions::default()).unwrap(); + let _covering = fleet + .producer + .route("room", moq_net::origin::RouteOptions::default()) + .unwrap(); let waiter = kio::Waiter::noop(); let shape = format!("{publishers}p_{requesters}r"); group.throughput(Throughput::Elements(requesters)); @@ -876,9 +917,9 @@ fn pool(members: usize, paths: usize, cursors: usize) -> Pool { driver.poll(moq_net::time::Instant::now(), &waiter).unwrap(); let mut producers = Vec::with_capacity(paths); for member in &members { - while let Poll::Ready(request) = member.poll_requested_broadcast(&waiter) { + while let Poll::Ready(Some(request)) = member.poll_requested(&waiter) { let broadcast = broadcast::Info::new().produce(); - request.unwrap().serve(&broadcast); + request.serve(&broadcast); producers.push(broadcast); } } @@ -919,7 +960,7 @@ fn bench_restart_fronts(c: &mut Criterion) { let pool = pool(1, fronts, 0); moq_net::fuzz::update_route( &pool._members[0], - pool_route(POOL_HOP).with_instance(Instance::random(), 0), + peer_instance(POOL_HOP, 3, Some(Instance::random())), ) .unwrap(); let paths: Vec<_> = (0..restarting).map(|i| format!("pool/job-{i}")).collect(); @@ -1066,15 +1107,21 @@ fn bench_handoff(c: &mut Criterion) { runtime.spawn(moq_net::time::run(driver)); let consumer = producer.consume(); let _others: Vec<_> = (0..publishers) - .map(|i| producer.route(format!("room/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) + .map(|i| { + producer + .route(format!("room/{i}"), moq_net::origin::RouteOptions::default()) + .unwrap() + }) .collect(); b.iter_custom(|iterations| { runtime.block_on(async { let mut total = Duration::ZERO; for _ in 0..iterations { - let incumbent = producer.route("room/live", moq_net::origin::RouteOptions::default()).unwrap(); - let track = incumbent.create_track("video", timed()).unwrap(); + let incumbent = producer + .route("room/live", moq_net::origin::RouteOptions::default()) + .unwrap(); + let track = incumbent.broadcast().create_track("video", timed()).unwrap(); let mut first = track.append_group().unwrap(); first.write_frame(Timestamp::ZERO, b"one".as_ref()).unwrap(); first.finish().unwrap(); @@ -1084,8 +1131,10 @@ fn bench_handoff(c: &mut Criterion) { subscription.recv_group().await.unwrap().expect("first group"); let started = std::time::Instant::now(); - let standby = producer.route("room/live", moq_net::origin::RouteOptions::hidden()).unwrap(); - let track = standby.create_track("video", timed()).unwrap(); + let standby = producer + .route("room/live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); + let track = standby.broadcast().create_track("video", timed()).unwrap(); let mut second = track.create_group(moq_net::group::Info { sequence: 1 }).unwrap(); second.write_frame(Timestamp::ZERO, b"two".as_ref()).unwrap(); second.finish().unwrap(); @@ -1100,8 +1149,8 @@ fn bench_handoff(c: &mut Criterion) { drop(subscription); drop(replacement); - incumbent.close(); - standby.close(); + incumbent.broadcast().close(); + standby.broadcast().close(); // Wait for the fronts to close so the next iteration starts fresh ones. resolved.closed().await; replaced.closed().await; @@ -1148,8 +1197,10 @@ async fn watching(routes: usize, subscribers: usize) -> Watching { let mut broadcasts = Vec::new(); let mut tracks = Vec::new(); for index in 0..routes { - let broadcast = relay.route(watched_path(index), moq_net::origin::RouteOptions::default()).unwrap(); - tracks.push(broadcast.create_track("video", timed()).unwrap()); + let broadcast = relay + .route(watched_path(index), moq_net::origin::RouteOptions::default()) + .unwrap(); + tracks.push(broadcast.broadcast().create_track("video", timed()).unwrap()); broadcasts.push(broadcast); } @@ -1287,9 +1338,11 @@ fn bench_relay(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.route("room/live", moq_net::origin::RouteOptions::default()).unwrap(); + let broadcast = producer + .route("room/live", moq_net::origin::RouteOptions::default()) + .unwrap(); let sources: Vec<_> = (0..tracks) - .map(|i| broadcast.create_track(format!("{i}"), timed()).unwrap()) + .map(|i| broadcast.broadcast().create_track(format!("{i}"), timed()).unwrap()) .collect(); let mut subscriptions = runtime.block_on(async { let resolved = producer.consume().request("room/live", None).await.unwrap(); @@ -1347,8 +1400,10 @@ fn bench_passthrough(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.route("room/live", moq_net::origin::RouteOptions::default()).unwrap(); - let source = broadcast.create_track("0", timed()).unwrap(); + let broadcast = producer + .route("room/live", moq_net::origin::RouteOptions::default()) + .unwrap(); + let source = broadcast.broadcast().create_track("0", timed()).unwrap(); let mut subscriptions = runtime.block_on(async { let resolved = producer.consume().request("room/live", None).await.unwrap(); let track = resolved.track("0").unwrap(); @@ -1402,9 +1457,11 @@ fn bench_parked(c: &mut Criterion) { .unwrap(); let (producer, driver) = origin::Producer::new(origin::Config::default()); runtime.spawn(moq_net::time::run(driver)); - let broadcast = producer.route("room/live", moq_net::origin::RouteOptions::default()).unwrap(); + let broadcast = producer + .route("room/live", moq_net::origin::RouteOptions::default()) + .unwrap(); let sources: Vec<_> = (0..tracks) - .map(|i| broadcast.create_track(format!("{i}"), None).unwrap()) + .map(|i| broadcast.broadcast().create_track(format!("{i}"), None).unwrap()) .collect(); let _writers: Vec<_> = sources.iter().map(|source| source.append_group().unwrap()).collect(); let (subscriptions, mut groups) = runtime.block_on(async { @@ -1452,13 +1509,18 @@ struct Generation { } impl Generation { - /// Create a hidden generation and leave a finished group on every track, so a - /// reader that does look has something to resume. - fn build(producer: &origin::Producer, tracks: usize) -> Self { - let broadcast = producer.route(COPY_PATH, moq_net::origin::RouteOptions::hidden()).unwrap(); + /// Create a hidden generation of `instance` and leave a finished group on every + /// track, so a reader that does look has something to resume. + fn build(producer: &origin::Producer, tracks: usize, instance: &Instance) -> Self { + let broadcast = producer + .route( + COPY_PATH, + moq_net::origin::RouteOptions::hidden().with_instance(instance.clone(), 0), + ) + .unwrap(); let mut held = Vec::with_capacity(tracks); for i in 0..tracks { - let track = broadcast.create_track(format!("{i}"), timed()).unwrap(); + let track = broadcast.broadcast().create_track(format!("{i}"), timed()).unwrap(); let mut written = track.append_group().unwrap(); written.write_frame(Timestamp::ZERO, b"f".as_ref()).unwrap(); written.finish().unwrap(); @@ -1471,10 +1533,8 @@ impl Generation { } /// Route the front to this generation without waiting. - fn route(&self, instance: &Instance) { - self.broadcast - .announce(origin::RouteInfo::default().with_instance(instance.clone(), 0)) - .unwrap(); + fn route(&self) { + self.broadcast.announce().unwrap(); } /// Route the front to this generation and wait until every track is spliced. @@ -1483,8 +1543,8 @@ impl Generation { /// copy, before its splice. That bounds the splice only on a current-thread /// runtime, where every local query is ready within the front poll that /// splices it. - async fn announce(&self, instance: &Instance) { - self.route(instance); + async fn announce(&self) { + self.route(); for track in &self.tracks { kio::clock::timeout(COPY_WAIT, support::wanted(track.demand())) .await @@ -1496,7 +1556,6 @@ impl Generation { /// A front serving [`COPY_PATH`], with `copies` route copies on each of its tracks. struct CopyWalk { - instance: Instance, _producer: origin::Producer, _subscribers: Vec, generations: Vec, @@ -1514,8 +1573,8 @@ async fn copy_walk(tracks: usize, copies: usize) -> CopyWalk { let (producer, driver) = origin::Producer::new(origin::Config::default()); tokio::spawn(moq_net::time::run(driver)); let instance = Instance::random(); - let first = Generation::build(&producer, tracks); - first.route(&instance); + let first = Generation::build(&producer, tracks, &instance); + first.route(); let resolved = kio::clock::timeout(COPY_WAIT, producer.consume().request(COPY_PATH, None)) .await .expect("front did not resolve") @@ -1532,13 +1591,12 @@ async fn copy_walk(tracks: usize, copies: usize) -> CopyWalk { let mut generations = Vec::with_capacity(copies + 1); generations.push(first); for _ in 1..copies { - let generation = Generation::build(&producer, tracks); - generation.announce(&instance).await; + let generation = Generation::build(&producer, tracks, &instance); + generation.announce().await; generations.push(generation); } CopyWalk { - next: Some(Generation::build(&producer, tracks)), - instance, + next: Some(Generation::build(&producer, tracks, &instance)), _producer: producer, _subscribers: subscribers, generations, @@ -1552,7 +1610,7 @@ impl CopyWalk { /// every track, and each reader walks its copies in one driver turn. async fn swap(&mut self) { let generation = self.next.take().expect("one swap per setup"); - generation.announce(&self.instance).await; + generation.announce().await; self.generations.push(generation); } } @@ -1660,8 +1718,13 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { tokio::spawn(moq_net::time::run(driver)); let instance = Instance::random(); let generation = |order: &mut dyn Iterator| { - let broadcast = producer.route(COPY_PATH, moq_net::origin::RouteOptions::hidden()).unwrap(); - let track = broadcast.create_track("0", timed()).unwrap(); + let broadcast = producer + .route( + COPY_PATH, + moq_net::origin::RouteOptions::hidden().with_instance(instance.clone(), 0), + ) + .unwrap(); + let track = broadcast.broadcast().create_track("0", timed()).unwrap(); for sequence in order { let mut group = track .create_group(moq_net::group::Info { @@ -1671,9 +1734,7 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { group.write_frame(Timestamp::ZERO, b"f".as_ref()).unwrap(); group.finish().unwrap(); } - broadcast - .announce(origin::RouteInfo::default().with_instance(instance.clone(), 0)) - .unwrap(); + broadcast.announce().unwrap(); (broadcast, track) }; let mut generations = vec![generation(&mut (0..retained))]; diff --git a/rs/moq-net/benches/path.rs b/rs/moq-net/benches/path.rs index 5dc23d29279..28bf1757f3e 100644 --- a/rs/moq-net/benches/path.rs +++ b/rs/moq-net/benches/path.rs @@ -130,7 +130,11 @@ fn requests() { let (producer, mut driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); let _pubs: Vec<_> = (0..1000) - .map(|i| producer.route(format!("{s}/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) + .map(|i| { + producer + .route(format!("{s}/{i}"), moq_net::origin::RouteOptions::default()) + .unwrap() + }) .collect(); let _covering = producer.route(s, moq_net::origin::RouteOptions::default()).unwrap(); let waiter = kio::Waiter::noop(); @@ -171,7 +175,11 @@ fn fanout() { let (producer, _driver) = origin::Producer::new(origin::Config::default()); let consumer = producer.consume(); let _pubs: Vec<_> = (0..100) - .map(|i| producer.route(format!("room/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) + .map(|i| { + producer + .route(format!("room/{i}"), moq_net::origin::RouteOptions::default()) + .unwrap() + }) .collect(); let mut cursors: Vec = (0..100).map(|_| consumer.announced()).collect(); for cursor in &mut cursors { diff --git a/rs/moq-net/benches/retirement.rs b/rs/moq-net/benches/retirement.rs index 1ffdcff1e7b..7fe34dfcde7 100644 --- a/rs/moq-net/benches/retirement.rs +++ b/rs/moq-net/benches/retirement.rs @@ -22,7 +22,14 @@ fn retirement(c: &mut Criterion) { || { let (origin, driver) = origin::Producer::new(origin::Config::default()); let routes: Vec<_> = (0..routes) - .map(|i| origin.route_prefix(format!("route/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) + .map(|i| { + origin + .route_prefix( + format!("route/{i}"), + moq_net::origin::RouteOptions::default(), + ) + .unwrap() + }) .collect(); let mut watches = Vec::new(); let mut controls = Vec::new(); @@ -46,7 +53,10 @@ fn retirement(c: &mut Criterion) { (origin, driver, routes, watches, controls, pending) }, |fixture| { - let replacement = fixture.0.route_prefix("route/0/jobs", moq_net::origin::RouteOptions::default()).unwrap(); + let replacement = fixture + .0 + .route_prefix("route/0/jobs", moq_net::origin::RouteOptions::default()) + .unwrap(); let refused = fixture .5 .iter() diff --git a/rs/moq-net/benches/session/mod.rs b/rs/moq-net/benches/session/mod.rs index 4746c48f195..c1f3991ec03 100644 --- a/rs/moq-net/benches/session/mod.rs +++ b/rs/moq-net/benches/session/mod.rs @@ -633,10 +633,14 @@ impl Cluster { this.pools.push(pool); for index in 0..shape.broadcasts { let broadcast = origin - .publish(path(publisher * shape.broadcasts + index), Default::default()) + .route( + path(publisher * shape.broadcasts + index), + origin::RouteOptions::default(), + ) .unwrap(); this.tracks.push( broadcast + .broadcast() .create_track(TRACK, timed().with_compress(shape.compress)) .unwrap(), ); @@ -1421,10 +1425,10 @@ impl DashRoom { for project in 0..shape.projects { let path = format!(".stats/{project}/node/{node}"); let broadcast = B::origin(&cluster.relays[node]) - .publish(path.as_str(), Default::default()) + .route(path.as_str(), origin::RouteOptions::default()) .unwrap(); for name in &names { - tracks.push(broadcast.create_track(name.as_str(), timed()).unwrap()); + tracks.push(broadcast.broadcast().create_track(name.as_str(), timed()).unwrap()); } broadcasts.push(broadcast); paths.push(path); @@ -1573,7 +1577,7 @@ impl ChurnRoom { }, ) .await; - let published = &cluster._broadcasts[0]; + let published = cluster._broadcasts[0].broadcast(); let held: Vec<_> = (0..shape.held).map(|i| format!("held{i}")).collect(); let tracks: Vec<_> = held .iter() @@ -1782,7 +1786,7 @@ pub(crate) fn withdrawal(c: &mut Criterion) { let live: Vec<_> = (0..broadcasts) .map(|i| { B::origin(&cluster.relays[i % (relays - 1)]) - .publish(path(i), Default::default()) + .route(path(i), origin::RouteOptions::default()) .unwrap() }) .collect(); diff --git a/rs/moq-net/benches/stats.rs b/rs/moq-net/benches/stats.rs index d0719d2fddf..09505b396eb 100644 --- a/rs/moq-net/benches/stats.rs +++ b/rs/moq-net/benches/stats.rs @@ -24,7 +24,11 @@ fn registry(broadcasts: usize, tiers: usize) -> Registry { let registry = stats::Registry::new(stats::Config::new()); let (producer, driver) = origin::Producer::new(origin::Config::default()); let publishers = (0..broadcasts) - .map(|i| producer.route(format!("room/{i}"), moq_net::origin::RouteOptions::default()).unwrap()) + .map(|i| { + producer + .route(format!("room/{i}"), moq_net::origin::RouteOptions::default()) + .unwrap() + }) .collect(); let cursors = (0..tiers) .map(|t| { diff --git a/rs/moq-net/benches/viewers.rs b/rs/moq-net/benches/viewers.rs index 922a03483cd..88855a2dd28 100644 --- a/rs/moq-net/benches/viewers.rs +++ b/rs/moq-net/benches/viewers.rs @@ -75,8 +75,10 @@ impl Room { let (producer, driver) = origin::Producer::new(origin::Config::default()); let _sources = (0..broadcasts) .map(|i| { - let broadcast = producer.route(format!("room/{i}"), moq_net::origin::RouteOptions::default()).unwrap(); - let track = broadcast.create_track("video", timed()).unwrap(); + let broadcast = producer + .route(format!("room/{i}"), moq_net::origin::RouteOptions::default()) + .unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"frame".as_ref()).unwrap(); group.finish().unwrap(); @@ -181,7 +183,10 @@ fn bench_churn(c: &mut Criterion) { room.leave(subscription); } b.iter(|| { - let covering = room.producer.route_prefix("room", moq_net::origin::RouteOptions::default()).unwrap(); + let covering = room + .producer + .route_prefix("room", moq_net::origin::RouteOptions::default()) + .unwrap(); room.poll(); drop(covering); room.poll(); diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 3b1836d48b6..4b6126f1a79 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -7491,24 +7491,14 @@ mod serve_tests { /// The same, with the track described by `info`. fn serve_track(version: Version, info: crate::track::Info) -> Serve { - serve_route(version, info, crate::origin::RouteInfo::default()) - } - - /// The same, with the broadcast announced on `route`. - fn serve_route(version: Version, info: crate::track::Info, route: crate::origin::RouteInfo) -> Serve { - serve_session(version, info, route, ScriptedSession::per_stream(vec![Vec::new()])) + serve_session(version, info, ScriptedSession::per_stream(vec![Vec::new()])) } /// The same, over `session`. - fn serve_session( - version: Version, - info: crate::track::Info, - route: crate::origin::RouteInfo, - session: ScriptedSession, - ) -> Serve { + fn serve_session(version: Version, info: crate::track::Info, session: ScriptedSession) -> Serve { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let broadcast = origin.publish("room", route).unwrap(); - let track = broadcast.create_track("video", info).unwrap(); + let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); + let track = broadcast.broadcast().create_track("video", info).unwrap(); let log = session.log.clone(); @@ -8012,12 +8002,7 @@ mod serve_tests { async fn publish_done_waits_on_an_unacknowledged_fin_until_the_group_is_stale() { let version = Version::Draft22; let session = ScriptedSession::per_stream(vec![Vec::new()]).with_unacked_uni_fins(1); - let h = serve_session( - version, - crate::track::Info::timed(), - crate::origin::RouteInfo::default(), - session, - ); + let h = serve_session(version, crate::track::Info::timed(), session); // Well past the cache window, which only dates idleness once a sweep passes. let budget = crate::cache::DEFAULT_EXPIRY * 4; let mut msg = subscribe(Filter::NextObject, None); @@ -9096,7 +9081,10 @@ mod serve_tests { session.push(&update_with_tokens(&[TOKEN])); let request = taken_token(&mut running, &mut requests).await; - let other = h._origin.announce("other", crate::origin::RouteInfo::default()).unwrap(); + let other = h + ._origin + .announce("other", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; assert!(futures::poll!(running.as_mut()).is_pending()); drop(other); @@ -9268,7 +9256,10 @@ mod serve_tests { let request = taken_token(&mut running, &mut requests).await; session.log.fail_writes(); - let _other = h._origin.announce("other", crate::origin::RouteInfo::default()).unwrap(); + let _other = h + ._origin + .announce("other", crate::origin::RouteInfo::default()) + .unwrap(); for _ in 0..10 { assert!( futures::poll!(running.as_mut()).is_pending(), @@ -9511,7 +9502,6 @@ mod serve_tests { let h = serve_session( version, track::Info::timed(), - crate::origin::RouteInfo::default(), ScriptedSession::per_stream_eof(vec![Vec::new()]), ); let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) @@ -11326,12 +11316,7 @@ mod serve_tests { async fn an_update_after_publish_done_keeps_the_join() { for version in JOINING_DRAFTS { // One script shared by every stream, so the update can arrive after PUBLISH_DONE. - let mut h = serve_session( - version, - crate::track::Info::timed(), - crate::origin::RouteInfo::default(), - ScriptedSession::new(Vec::new()), - ); + let mut h = serve_session(version, crate::track::Info::timed(), ScriptedSession::new(Vec::new())); publish_groups(&mut h, 5); settle().await; let stream = Stream::open(&mut crate::driver::Transport::new(h.session.clone()), version) @@ -11370,7 +11355,10 @@ mod serve_tests { for version in JOINING_DRAFTS { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), b"frame".to_vec()).unwrap(); group.finish().unwrap(); @@ -13000,7 +12988,10 @@ mod serve_tests { for version in FETCH_DRAFTS { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), b"0-0".to_vec()).unwrap(); group.finish().unwrap(); @@ -13096,7 +13087,10 @@ mod serve_tests { ] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), PAYLOAD.to_vec()).unwrap(); settle().await; @@ -13227,7 +13221,10 @@ mod serve_tests { let token = end != JoinEnd::Ended; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(timestamp(), PAYLOAD.to_vec()).unwrap(); settle().await; @@ -13568,7 +13565,10 @@ mod serve_tests { ), Parked::Acking | Parked::Ending => { let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); match parked { // One published group, so the subscription parks at the live edge. Parked::Acking => { @@ -13823,7 +13823,10 @@ mod serve_tests { } Setup::Live => { let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); - let mut track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let mut track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); track.set_idle(); serve_until(serving.as_mut(), "the upstream subscription", || { track.subscription().is_some() @@ -14280,7 +14283,10 @@ mod serve_tests { fn serve_on(version: Version, auth: crate::auth::Link, session: ScriptedSession) -> Serve { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let log = session.log.clone(); @@ -16184,7 +16190,10 @@ mod tests { let mut clean_hops = crate::Hops::new(); clean_hops.push(clean_publisher).unwrap(); let clean = origin - .announce("route-flip-cam", crate::origin::RouteInfo::default().with_hops(clean_hops)) + .announce( + "route-flip-cam", + crate::origin::RouteInfo::default().with_hops(clean_hops), + ) .unwrap(); settle().await; assert!(futures::poll!(run.as_mut()).is_pending()); @@ -16239,7 +16248,9 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("lonely-cam", crate::origin::RouteInfo::default()).unwrap(); + let _cam = origin + .announce("lonely-cam", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; // Every stream is answered with the same refusal, so a retry would show up as a @@ -16311,7 +16322,9 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _local = origin.announce("local-cam", crate::origin::RouteInfo::default()).unwrap(); + let _local = origin + .announce("local-cam", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; // The only stream is the PUBLISH_NAMESPACE request we open ourselves. @@ -16355,7 +16368,9 @@ mod tests { async fn publish_namespace_withdraws_by_reset() { for version in [Version::Draft18, Version::Draft20, Version::Draft22] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let local = origin.announce("local-cam", crate::origin::RouteInfo::default()).unwrap(); + let local = origin + .announce("local-cam", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; let session = @@ -16419,7 +16434,9 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _local = origin.announce("local-cam", crate::origin::RouteInfo::default()).unwrap(); + let _local = origin + .announce("local-cam", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; let ok = crate::lite::test_transport::Log::default(); @@ -16511,7 +16528,9 @@ mod tests { } = case; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let _cam = origin.announce("cam", crate::origin::RouteInfo::default()).unwrap(); - let _stats = origin.announce(".stats/node", crate::origin::RouteInfo::default()).unwrap(); + let _stats = origin + .announce(".stats/node", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; // Stream 1 is the peer's SUBSCRIBE_NAMESPACE; stream 2, if opened at all, is our @@ -16657,7 +16676,9 @@ mod tests { async fn a_non_solicit_subscribe_namespace_carries_namespace() { for version in [Version::Draft18] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let early = origin.announce("early-cam", crate::origin::RouteInfo::default()).unwrap(); + let early = origin + .announce("early-cam", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![Vec::new()]); @@ -16701,7 +16722,9 @@ mod tests { "{version:?}: existing match", ); - let _late = origin.announce("late-cam", crate::origin::RouteInfo::default()).unwrap(); + let _late = origin + .announce("late-cam", crate::origin::RouteInfo::default()) + .unwrap(); for _ in 0..100 { assert!(futures::poll!(run.as_mut()).is_pending()); if occurrences(&log, b"late-cam") >= 1 { @@ -16748,7 +16771,9 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let first = origin.announce("first-cam", crate::origin::RouteInfo::default()).unwrap(); + let first = origin + .announce("first-cam", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; // The first advertisement has send capacity, and the peer answers it. @@ -16783,7 +16808,9 @@ mod tests { // Send capacity runs out before the second advertisement can send its header. set_gate(&gate, false); - let _second = origin.announce("second-cam", crate::origin::RouteInfo::default()).unwrap(); + let _second = origin + .announce("second-cam", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; // Retiring the first needs no new stream, so the loop has to reach @@ -16912,7 +16939,9 @@ mod tests { let _standby = origin .announce( "solo-cam", - crate::origin::RouteInfo::default().with_instance(instance, 0).with_cost(0), + crate::origin::RouteInfo::default() + .with_instance(instance, 0) + .with_cost(0), ) .unwrap(); @@ -17017,7 +17046,9 @@ mod tests { let _warm = origin .announce( "cam", - crate::origin::RouteInfo::default().with_instance(instance, 0).with_cost(0), + crate::origin::RouteInfo::default() + .with_instance(instance, 0) + .with_cost(0), ) .unwrap(); @@ -17111,7 +17142,9 @@ mod tests { let _warm = origin .announce( "cam", - crate::origin::RouteInfo::default().with_instance(instance, 0).with_cost(0), + crate::origin::RouteInfo::default() + .with_instance(instance, 0) + .with_cost(0), ) .unwrap(); @@ -17307,7 +17340,8 @@ mod tests { "{version}: PUBLISH_NAMESPACE carries the auth" ); - cam.update(crate::origin::RouteInfo::default().with_auth(second)).unwrap(); + cam.update(crate::origin::RouteInfo::default().with_auth(second)) + .unwrap(); let expected = request_update( version, &ietf::PublishNamespaceUpdate { @@ -17385,7 +17419,8 @@ mod tests { poll_until(&mut run, &log, b"cam", 1).await; assert_eq!(occurrences(&log, b"late-secret"), 0, "named before it had an auth"); - cam.update(crate::origin::RouteInfo::default().with_auth(token)).unwrap(); + cam.update(crate::origin::RouteInfo::default().with_auth(token)) + .unwrap(); poll_until(&mut run, &log, b"cam", 2).await; assert_eq!(occurrences(&log, b"cam"), 2, "the request was not made again"); @@ -17403,10 +17438,16 @@ mod tests { let auth = crate::auth::Link::ietf(false); let present = |token: &'static [u8]| auth.present(bytes::Bytes::from_static(token), false).unwrap(); let a = origin - .announce("cam-a", crate::origin::RouteInfo::default().with_auth(present(b"a-first"))) + .announce( + "cam-a", + crate::origin::RouteInfo::default().with_auth(present(b"a-first")), + ) .unwrap(); let b = origin - .announce("cam-b", crate::origin::RouteInfo::default().with_auth(present(b"b-first"))) + .announce( + "cam-b", + crate::origin::RouteInfo::default().with_auth(present(b"b-first")), + ) .unwrap(); settle().await; @@ -17517,7 +17558,12 @@ mod tests { let origin = unheld_origin(); let mut cams: HashMap<&str, _> = ["a-cam", "b-cam"] .into_iter() - .map(|name| (name, origin.announce(name, crate::origin::RouteInfo::default()).unwrap())) + .map(|name| { + ( + name, + origin.announce(name, crate::origin::RouteInfo::default()).unwrap(), + ) + }) .collect(); settle().await; @@ -17838,7 +17884,9 @@ mod tests { let _warm = origin .announce( "cam", - crate::origin::RouteInfo::default().with_instance(instance, 0).with_cost(0), + crate::origin::RouteInfo::default() + .with_instance(instance, 0) + .with_cost(0), ) .unwrap(); @@ -17871,8 +17919,12 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _first = origin.announce("first-cam", crate::origin::RouteInfo::default()).unwrap(); - let _second = origin.announce("second-cam", crate::origin::RouteInfo::default()).unwrap(); + let _first = origin + .announce("first-cam", crate::origin::RouteInfo::default()) + .unwrap(); + let _second = origin + .announce("second-cam", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; // Every stream opens and then goes silent: an exhausted script parks rather than @@ -17977,7 +18029,8 @@ mod tests { assert!(futures::poll!(run.as_mut()).is_pending()); if matches!(stage, Stage::UpdateWrite) { let second = auth.present(bytes::Bytes::from_static(b"second"), false).unwrap(); - cam.update(crate::origin::RouteInfo::default().with_auth(second)).unwrap(); + cam.update(crate::origin::RouteInfo::default().with_auth(second)) + .unwrap(); settle().await; assert!(futures::poll!(run.as_mut()).is_pending()); assert!( @@ -18070,7 +18123,9 @@ mod tests { use std::sync::atomic::Ordering; for version in [Version::Draft18] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("lonely-cam", crate::origin::RouteInfo::default()).unwrap(); + let _cam = origin + .announce("lonely-cam", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; let session = crate::lite::test_transport::ScriptedSession::new(publish_namespace_ok(version).await).without_credit(); @@ -18121,7 +18176,9 @@ mod tests { const VERSION: Version = Version::Draft18; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("lonely-cam", crate::origin::RouteInfo::default()).unwrap(); + let _cam = origin + .announce("lonely-cam", crate::origin::RouteInfo::default()) + .unwrap(); settle().await; // No send capacity from the start: an admitted header cannot finish. diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index 16cf8637f41..fe8a29d631f 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -2127,7 +2127,9 @@ mod tests { /// enough: the question is only whether the bytes went out unasked. async fn announce_occurrences(peer_declared: Option) -> usize { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let _cam = origin.announce("solo-cam", crate::origin::RouteInfo::default()).unwrap(); + let _cam = origin + .announce("solo-cam", crate::origin::RouteInfo::default()) + .unwrap(); // An open gate: an unsolicited PUBLISH_NAMESPACE can reach the wire. let gate = kio::Producer::new(true); @@ -2232,7 +2234,9 @@ mod tests { fn auth_session(auth: bool) -> AuthSession { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let cam = origin.announce("solo-cam", crate::origin::RouteInfo::default()).unwrap(); + let cam = origin + .announce("solo-cam", crate::origin::RouteInfo::default()) + .unwrap(); let gate = kio::Producer::new(true); let session = crate::lite::test_transport::SinkSession::gated_bi(gate.consume()); diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 781aefd51f4..13ed0103daa 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -2697,7 +2697,9 @@ impl Subscriber { entry.live = Default::default(); } match &mut entry.dynamic { - Some(dynamic) => dynamic.poll_requested(waiter).map(|request| Some(request.ok_or(crate::Error::Closed))), + Some(dynamic) => dynamic + .poll_requested(waiter) + .map(|request| Some(request.ok_or(crate::Error::Closed))), None => Poll::Ready(None), } }) @@ -8603,11 +8605,11 @@ mod tests { for version in [Version::Draft18, Version::Draft20, Version::Draft22] { let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); - let source = origin.publish("broadcast", Default::default()).unwrap(); + let source = origin.route("broadcast", Default::default()).unwrap(); let resolved = origin.consume().request("broadcast", None).await.unwrap(); let peer = Arc::new(Peer { version, - dynamic: Mutex::new(Some(source.requests())), + dynamic: Mutex::new(Some(source.broadcast().requests())), park: Default::default(), log: Default::default(), }); @@ -8967,7 +8969,10 @@ mod tests { // What we are publishing to the peer: a real upstream route. let upstream = crate::Hops::try_from(vec![crate::Hop::new(7).unwrap()]).unwrap(); let _source = origin - .announce("room/host", crate::origin::RouteInfo::default().with_hops(upstream.clone())) + .announce( + "room/host", + crate::origin::RouteInfo::default().with_hops(upstream.clone()), + ) .unwrap(); announced.expect_next_active("room/host").await; let _advertised = publishing.expect_next_active("room/host").await; @@ -13225,7 +13230,8 @@ mod stitch_tests { let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "video", accepted_info( &ietf::Properties { @@ -13752,7 +13758,8 @@ mod stitch_tests { let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::default()).unwrap(); let track = broadcast - .broadcast().create_track("video", accepted_info(&Default::default(), version)) + .broadcast() + .create_track("video", accepted_info(&Default::default(), version)) .unwrap(); let mut h = Harness::with_timescale(Fill::Done, vec![], None); h.subscriber.version = version; diff --git a/rs/moq-net/src/lite/ietf.rs b/rs/moq-net/src/lite/ietf.rs index 16bb1e14138..d71e92cce4e 100644 --- a/rs/moq-net/src/lite/ietf.rs +++ b/rs/moq-net/src/lite/ietf.rs @@ -1318,7 +1318,8 @@ mod hop_tests { let upstream = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); let broadcast = upstream.route("room", crate::origin::RouteOptions::default()).unwrap(); let mut track = broadcast - .broadcast().create_track("video", track::Info::timed().with_timescale(Timescale::MILLI)) + .broadcast() + .create_track("video", track::Info::timed().with_timescale(Timescale::MILLI)) .unwrap(); let (downstream, sessions) = test_hop(&upstream, "room", [true, true]).await; let (copy, mut subscriber) = subscribe(&downstream).await; diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index 5b778e3ce6b..308b49eb6ae 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -1175,7 +1175,11 @@ impl AnnounceRun { /// The chain and cost to put on the wire for `route`, or `None` when it must /// not be forwarded. - fn outgoing(&self, route: &crate::origin::RouteInfo, absolute: &crate::Path) -> Option<(Hops, crate::origin::Cost)> { + fn outgoing( + &self, + route: &crate::origin::RouteInfo, + absolute: &crate::Path, + ) -> Option<(Hops, crate::origin::Cost)> { let mut hops = route.hops.clone(); // A route that already passed through us is a reflection. The origin @@ -2899,7 +2903,11 @@ mod announce_test { drop(removed); let mut churn = Vec::new(); for limit in 1..=4 { - churn.push(origin.announce(format!("a/{limit}"), origin::RouteInfo::default()).unwrap()); + churn.push( + origin + .announce(format!("a/{limit}"), origin::RouteInfo::default()) + .unwrap(), + ); *budget.write().ok().unwrap() = limit; assert!(run.poll(&mut stream, &consumer, &mut announced, &waiter).is_pending()); } @@ -3439,7 +3447,11 @@ mod announce_test { #[kio::test] async fn clamped_cost_change_is_quiet() { let mut h = harness().await; - let route = |cost| crate::origin::RouteInfo::default().with_hops(pub_hops()).with_cost(cost); + let route = |cost| { + crate::origin::RouteInfo::default() + .with_hops(pub_hops()) + .with_cost(cost) + }; h.announcement.update(route(u64::MAX)).unwrap(); kio::clock::sleep(crate::origin::Config::default().update_hold).await; settle().await; @@ -7181,7 +7193,10 @@ mod serve_group_test { for warm in [false, true] { let publisher = origin(1); let broadcast = publisher.route("room", crate::origin::RouteOptions::hidden()).unwrap(); - let mut track = broadcast.broadcast().create_track("test", crate::track::Info::timed()).unwrap(); + let mut track = broadcast + .broadcast() + .create_track("test", crate::track::Info::timed()) + .unwrap(); track.start_at(0).unwrap(); broadcast.announce().unwrap(); let relay = origin(2); @@ -8712,7 +8727,10 @@ mod tests { let version = Version::Lite07; let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); - let _track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let _track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); broadcast.announce().unwrap(); let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); peer_setup.set(crate::lite::Setup::default()); @@ -8769,7 +8787,10 @@ mod tests { let case = format!("{version:?}, {close:?}, blocked {blocked}"); let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); broadcast.announce().unwrap(); let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); @@ -9238,7 +9259,10 @@ mod tests { async fn a_cold_bounded_fetch_requests_the_prefix() { let origin = crate::origin::Config::new(Hop::new(1).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); - let track = broadcast.broadcast().create_track("video", track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", track::Info::timed()) + .unwrap(); let dynamic = track.requests(); let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); peer_setup.set(crate::lite::Setup::default()); @@ -9285,7 +9309,10 @@ mod tests { const VERSION: Version = Version::Lite07; let origin = crate::origin::Config::new(Hop::new(1).unwrap()).produce(); let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); - let track = broadcast.broadcast().create_track("video", track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", track::Info::timed()) + .unwrap(); broadcast.announce().unwrap(); let mut open = track.append_group().unwrap(); open.write_frame(crate::Timestamp::ZERO, b"a".to_vec()).unwrap(); diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 5faad339f75..1320328c657 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -6533,8 +6533,13 @@ mod tests { let origin = origin::Config::new(relay).produce(); let assigned = crate::Hop::new(777).unwrap(); - let local = origin.route("room/host", crate::origin::RouteOptions::default()).unwrap(); - let track = local.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let local = origin + .route("room/host", crate::origin::RouteOptions::default()) + .unwrap(); + let track = local + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"local".as_ref()).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-net/src/model/follow.rs b/rs/moq-net/src/model/follow.rs index f19656d6fed..457c8c45b4d 100644 --- a/rs/moq-net/src/model/follow.rs +++ b/rs/moq-net/src/model/follow.rs @@ -357,7 +357,7 @@ mod tests { use super::*; use crate::{ Error, Hop, Instance, Pattern, Patterns, - origin::{Cost, RouteInfo}, + origin::{Cost, RouteInfo, RouteOptions}, }; /// The follower's next event, which must arrive within the origin's update hold. @@ -386,6 +386,10 @@ mod tests { RouteInfo::default().with_instance(instance.clone(), 0) } + fn options(instance: &Instance) -> RouteOptions { + RouteOptions::default().with_instance(instance.clone(), 0) + } + #[kio::test] async fn follow_reports_the_route_serving_the_path() { let origin = Hop::new(1).unwrap().produce(); @@ -397,26 +401,26 @@ mod tests { assert_eq!(followed(&mut follow).await, ("start", "pool".into())); // A route beneath the path serves another broadcast. - let _beneath = origin.route("pool/job/thumbnail", crate::origin::RouteOptions::default()).unwrap(); + let _beneath = origin.route("pool/job/thumbnail", RouteOptions::default()).unwrap(); quiet(&mut follow).await; // The path itself, from the same instance, takes over without a restart. - let exact = origin.publish("pool/job", route(&instance)).unwrap(); + let exact = origin.route("pool/job", options(&instance)).unwrap(); assert_eq!(followed(&mut follow).await, ("update", "pool/job".into())); // The covering prefix no longer serves the path, so its changes are not seen. - pool.update(pool.route().with_cost(5)).unwrap(); + pool.update(pool.route().unwrap().with_cost(5)).unwrap(); quiet(&mut follow).await; // Another instance at the path. - exact.announce(route(&Instance::random())).unwrap(); + exact.announce_info(route(&Instance::random())).unwrap(); assert_eq!(followed(&mut follow).await, ("restart", "pool/job".into())); // It goes, so the prefix serves the path again: another instance. drop(exact); assert_eq!(followed(&mut follow).await, ("restart", "pool".into())); - pool.update(pool.route().with_cost(9)).unwrap(); + pool.update(pool.route().unwrap().with_cost(9)).unwrap(); assert_eq!(followed(&mut follow).await, ("update", "pool".into())); drop(pool); @@ -429,7 +433,7 @@ mod tests { async fn follow_starts_on_the_serving_route_when_joining_late() { let origin = Hop::new(1).unwrap().produce(); let _pool = origin.forward("pool", RouteInfo::default(), None).unwrap(); - let _exact = origin.route("pool/job", crate::origin::RouteOptions::default()).unwrap(); + let _exact = origin.route("pool/job", RouteOptions::default()).unwrap(); let mut follow = origin.consume().routes("pool/job").unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); @@ -442,7 +446,7 @@ mod tests { async fn follow_keeps_a_gap_between_routes_of_one_instance() { let origin = Hop::new(1).unwrap().produce(); let instance = Instance::random(); - let exact = origin.publish("pool/job", route(&instance)).unwrap(); + let exact = origin.route("pool/job", options(&instance)).unwrap(); let mut follow = origin.consume().routes("pool/job").unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); @@ -454,7 +458,7 @@ mod tests { assert_eq!(followed(&mut follow).await, ("start", "pool".into())); // A prefix standing while the path's route goes takes over in place. - let exact = origin.publish("pool/job", route(&instance)).unwrap(); + let exact = origin.route("pool/job", options(&instance)).unwrap(); assert_eq!(followed(&mut follow).await, ("update", "pool/job".into())); drop(exact); assert_eq!(followed(&mut follow).await, ("update", "pool".into())); @@ -465,13 +469,13 @@ mod tests { #[kio::test] 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(&Instance::random())).unwrap(); + let exact = origin.route("pool/job", RouteOptions::default()).unwrap(); let mut follow = origin.consume().routes("pool/job").unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool/job".into())); let instance = Instance::random(); let _pool = origin.forward("pool", route(&instance), None).unwrap(); - exact.announce(route(&instance)).unwrap(); + exact.announce_info(route(&instance)).unwrap(); assert_eq!(followed(&mut follow).await, ("restart", "pool/job".into())); drop(exact); @@ -487,7 +491,7 @@ mod tests { let _pool = origin.forward("pool", RouteInfo::default(), None).unwrap(); assert_eq!(followed(&mut follow).await, ("start", "pool".into())); - let _exact = origin.route("pool/job", crate::origin::RouteOptions::default()).unwrap(); + let _exact = origin.route("pool/job", RouteOptions::default()).unwrap(); assert_eq!(followed(&mut follow).await, ("restart", "pool/job".into())); } @@ -504,7 +508,9 @@ mod tests { .unwrap(); let mut follow = origin.consume().routes("room/alice").unwrap(); - let first = origin.route("room/alice", crate::origin::RouteOptions::default().with_cost(5)).unwrap(); + let first = origin + .route("room/alice", RouteOptions::default().with_cost(5)) + .unwrap(); let event = kio::clock::timeout(Duration::from_secs(1), follow.next()) .await .unwrap() @@ -515,7 +521,9 @@ mod tests { ); // A republish is another instance of the route that serves the path. - let _second = origin.route("room/alice", crate::origin::RouteOptions::default().with_cost(5)).unwrap(); + let _second = origin + .route("room/alice", RouteOptions::default().with_cost(5)) + .unwrap(); drop(first); let event = kio::clock::timeout(Duration::from_secs(1), follow.next()) .await @@ -559,13 +567,13 @@ mod tests { #[kio::test] async fn announced_hands_out_a_held_takeover_once() { let origin = Hop::new(1).unwrap().produce(); - let dynamic = origin.route_prefix("live", crate::origin::RouteOptions::default()).unwrap(); + let dynamic = origin.route_prefix("live", RouteOptions::default()).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 under another instance. let (_takeover, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; - origin.route("live", crate::origin::RouteOptions::default()).unwrap() + origin.route("live", RouteOptions::default()).unwrap() }); none(&mut announced).await; } @@ -576,14 +584,14 @@ mod tests { #[kio::test] async fn announced_hands_out_a_gap_while_resolving_once() { let origin = Hop::new(1).unwrap().produce(); - let dynamic = origin.route_prefix("", crate::origin::RouteOptions::default()).unwrap(); + let dynamic = origin.route_prefix("", RouteOptions::default()).unwrap(); let mut announced = origin.consume().follow("live", None).unwrap(); let (_arrival, _publish) = futures::join!(available(&mut announced), async { let _unanswered = requested(&dynamic).await; drop(dynamic); kio::clock::sleep(super::super::origin_impl::DEFAULT_UPDATE_HOLD * 2).await; - origin.route("live", crate::origin::RouteOptions::default()).unwrap() + origin.route("live", RouteOptions::default()).unwrap() }); none(&mut announced).await; } @@ -596,7 +604,7 @@ mod tests { let origin = Hop::new(1).unwrap().produce(); let instance = Instance::random(); let mut announced = origin.consume().follow("live", None).unwrap(); - let exact = origin.publish("live", route(&instance)).unwrap(); + let exact = origin.route("live", options(&instance)).unwrap(); let first = available(&mut announced).await; let dynamic = origin.forward("", route(&instance), None).unwrap(); @@ -614,12 +622,12 @@ mod tests { async fn announced_pinned_refuses_another_instance() { let origin = Hop::new(1).unwrap().produce(); let instance = Instance::random(); - let _first = origin.publish("live", route(&instance)).unwrap(); + let _first = origin.route("live", options(&instance)).unwrap(); let mut announced = origin.consume().follow("live", instance.clone()).unwrap(); let pinned = available(&mut announced).await; assert_eq!(pinned.info().instance.as_ref(), Some(&instance)); - let _second = origin.publish("live", route(&Instance::random())).unwrap(); + let _second = origin.route("live", RouteOptions::default()).unwrap(); none(&mut announced).await; // Unpinned, the same takeover is followed. @@ -632,7 +640,7 @@ mod tests { async fn announced_pinned_hands_out_its_instance_after_a_gap() { let origin = Hop::new(1).unwrap().produce(); let instance = Instance::random(); - let first = origin.publish("live", route(&instance)).unwrap(); + let first = origin.route("live", options(&instance)).unwrap(); let mut announced = origin.consume().follow("live", instance.clone()).unwrap(); assert_eq!( available(&mut announced).await.info().instance.as_ref(), @@ -640,7 +648,7 @@ mod tests { ); first.withdraw(); none(&mut announced).await; - first.announce(route(&instance)).unwrap(); + first.announce().unwrap(); assert_eq!( available(&mut announced).await.info().instance.as_ref(), Some(&instance) @@ -650,12 +658,12 @@ mod tests { #[kio::test] async fn announced_reports_a_dropped_prepared_answer() { let origin = Hop::new(1).unwrap().produce(); - let claim = origin.route_prefix("live", crate::origin::RouteOptions::default()).unwrap(); + let claim = origin.route_prefix("live", RouteOptions::default()).unwrap(); let mut announced = origin.consume().follow("live", None).unwrap(); let (result, ()) = futures::join!( kio::clock::timeout(Duration::from_secs(1), announced.available()), async { - let prepared = requested(&claim).await.route(crate::origin::RouteOptions::hidden()).unwrap(); + let prepared = requested(&claim).await.route(RouteOptions::hidden()).unwrap(); drop(prepared); } ); diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index ae169661ba9..594bbb64c64 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -589,7 +589,7 @@ impl RouteInfo { } /// Set the credential the advertising request carries; see [`Self::auth`]. - #[cfg(test)] + #[cfg(all(test, feature = "async"))] pub(crate) fn with_auth(mut self, auth: crate::auth::Credential) -> Self { self.auth = Some(auth); self @@ -3027,7 +3027,7 @@ impl Route { /// Re-price the route: lower wins among routes covering the same prefix and anonymity. /// A visible route changes in place, as an update to its readers; a hidden one - /// announces at this price. + /// keeps the price for when it next announces. /// /// Fails with [`Error::Closed`] once the route's broadcast closed or the origin's /// [`Driver`] was dropped. @@ -3051,7 +3051,10 @@ impl Route { if !self.state.announcement.is_live()? { return Ok(()); } - self.state.announcement.update_if(control.info(), None, || true).map(|_| ()) + self.state + .announcement + .update_if(control.info(), None, || true) + .map(|_| ()) } /// Block until a consumer requests a path under this prefix route, returning a @@ -3108,7 +3111,7 @@ impl Route { /// Announce with `info` as given, instance included when it names one, as a /// session's update does: for tests that shape an exact route's metadata. - #[cfg(test)] + #[cfg(all(test, feature = "async"))] pub(crate) fn announce_info(&self, mut info: RouteInfo) -> Result<(), Error> { let mut control = self.state.control.lock(); match &info.instance { @@ -3128,7 +3131,7 @@ impl Route { /// The queue a prefix route's requests arrive on, for tests that inspect it. #[cfg(test)] - pub(crate) fn server(&self) -> &kio::Shared { + fn server(&self) -> &kio::Shared { self.state.server.as_ref().expect("a prefix route has a server") } @@ -7348,7 +7351,10 @@ impl AnnounceConsumer { } #[cfg(test)] - pub(crate) async fn expect_next_active(&mut self, expected: impl TryInto) -> RouteInfo { + pub(crate) async fn expect_next_active( + &mut self, + expected: impl TryInto, + ) -> RouteInfo { let event = self.expect_next().await; Self::active(event, &expected.try_into().expect("expected path")) } @@ -7855,8 +7861,8 @@ impl ProduceTest for Hop { #[cfg(all(test, feature = "async"))] pub(crate) struct TestSelection { origin: Producer, - route: Option, - replacement: Option, + route: Option, + replacement: Option, } #[cfg(all(test, feature = "async"))] @@ -7866,7 +7872,11 @@ impl TestSelection { pub(crate) fn new() -> Self { let origin = Hop::new(1).unwrap().produce(); let route = origin - .forward("room", RouteInfo::default().with_via(Hop::new(Self::PEER).unwrap()), None) + .forward( + "room", + RouteInfo::default().with_via(Hop::new(Self::PEER).unwrap()), + None, + ) .unwrap(); Self { origin, @@ -8019,10 +8029,10 @@ mod tests { /// Yield to the driver until the server's front watcher delivers a request. #[cfg(feature = "async")] - async fn queued(server: &Requests) -> Request { + async fn queued(server: &Route) -> Request { let mut request = None; - settle(|| match server.poll_requested_broadcast(&kio::Waiter::noop()) { - Poll::Ready(Ok(popped)) => { + settle(|| match server.poll_requested(&kio::Waiter::noop()) { + Poll::Ready(Some(popped)) => { request = Some(popped); true } @@ -8418,7 +8428,7 @@ mod tests { let request = queued(&server).await; assert_eq!(request.path().as_str(), ".svc/p1/foo"); - assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); + assert!(server.poll_requested(&kio::Waiter::noop()).is_pending()); let source = broadcast::Info::new().produce(); request.serve(&source); @@ -8592,7 +8602,10 @@ mod tests { .unwrap() .scope("p1", &Patterns::from(Pattern::all())) .unwrap(); - assert!(matches!(project.route(".svc/foo", RouteOptions::hidden()), Err(Error::Unauthorized))); + assert!(matches!( + project.route(".svc/foo", RouteOptions::hidden()), + Err(Error::Unauthorized) + )); assert!(matches!( project.forward(".svc", RouteInfo::default(), None), Err(Error::Unauthorized) @@ -8601,7 +8614,7 @@ mod tests { project.forward(".svc/foo", RouteInfo::default(), None), Err(Error::Unauthorized) )); - project.route("cam", RouteOptions::default()).unwrap(); + let _cam = project.route("cam", RouteOptions::default()).unwrap(); } /// A mount reaches only what the handle already reaches, and mounts never nest. @@ -8702,23 +8715,25 @@ mod tests { #[kio::test] #[cfg(feature = "async")] - async fn broadcast_announces_its_own_path() { + async fn a_hidden_route_announces_its_own_path() { let producer = origin(1).produce(); let consumer = producer.consume(); let mut announced = consumer.announced(); let mut peer = consumer.clone().excluding(Hop::UNKNOWN).announced(); - // Created but not announced: invisible to local and peer cursors alike. + // Created but not announced: invisible to local and peer cursors alike, even + // once priced. let broadcast = producer.route("room/alice", RouteOptions::hidden()).unwrap(); + broadcast.set_cost(3).unwrap(); announced.assert_next_wait(); peer.assert_next_wait(); - broadcast.announce(RouteInfo::default().with_cost(3)).unwrap(); + broadcast.announce().unwrap(); assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(3)); assert_eq!(peer.expect_next_active("room/alice").await.cost, Cost::new(3)); - // Announcing again re-prices in place. - broadcast.announce(RouteInfo::default().with_cost(1)).unwrap(); + // Re-pricing a visible route updates it in place. + broadcast.set_cost(1).unwrap(); assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(1)); assert_eq!(peer.expect_next_active("room/alice").await.cost, Cost::new(1)); @@ -8743,21 +8758,23 @@ mod tests { } #[kio::test] - async fn broadcast_announcement_retracts_with_the_last_producer() { + async fn a_route_retracts_with_its_last_clone() { let producer = origin(1).produce(); let consumer = producer.consume(); let mut announced = consumer.announced(); - let broadcast = producer.route("room/alice", RouteOptions::hidden()).unwrap(); - let clone = broadcast.clone(); - broadcast.announce().unwrap(); + let route = producer.route("room/alice", RouteOptions::hidden()).unwrap(); + let clone = route.clone(); + let source = route.broadcast().clone(); + route.announce().unwrap(); announced.expect_next_active("room/alice").await; - // A clone keeps the broadcast, and its advertisement, alive. - drop(broadcast); + // A clone keeps the route alive; a broadcast producer does not. + drop(route); announced.assert_next_wait(); drop(clone); announced.expect_next_ended("room/alice").await; + assert!(!source.consume().is_closed()); } #[kio::test] @@ -8768,14 +8785,6 @@ mod tests { announced.expect_next_active("room/alice").await; } - #[kio::test] - async fn standalone_broadcast_cannot_announce() { - let broadcast = broadcast::Info::new().produce(); - assert!(matches!(broadcast.announce(), Err(Error::Closed))); - // Harmless without an advertisement to retract. - broadcast.withdraw(); - } - #[kio::test] async fn announce_replays_to_late_cursor() { let producer = origin(1).produce(); @@ -8880,7 +8889,7 @@ mod tests { // arrived in `order`. fn winners(order: impl Iterator) -> Vec { let producer = origin(1).produce(); - let _pool: Vec = order + let _pool: Vec = order .map(|id| { producer .forward( @@ -9038,7 +9047,7 @@ mod tests { let first = broadcast::Info::new().produce(); request.serve(&first); let resolved = pending.await.expect("the old route resolves"); - assert!(new.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); + assert!(new.poll_requested(&kio::Waiter::noop()).is_pending()); drop(old); assert_eq!(announced.expect_next_restarted("pool/job-0").await.hops, hops(&[10])); @@ -9087,7 +9096,7 @@ mod tests { /// An origin delivering restarts at once, and a way to claim `prefix` with a /// producer scoped to `scope`, from `hop` at `cost`. #[cfg(feature = "async")] - fn scoped_pool() -> (Producer, impl Fn(&str, &str, u64, u64) -> Requests) { + fn scoped_pool() -> (Producer, impl Fn(&str, &str, u64, u64) -> Route) { let producer = Config { update_hold: Duration::ZERO, ..Config::new(origin(1)) @@ -9098,7 +9107,11 @@ mod tests { claims .scope("", &scopes(&[scope])) .unwrap() - .forward(prefix, RouteInfo::default().with_hops(hops(&[hop])).with_cost(cost), None) + .forward( + prefix, + RouteInfo::default().with_hops(hops(&[hop])).with_cost(cost), + None, + ) .unwrap() }; (producer, claim) @@ -9107,7 +9120,7 @@ mod tests { /// Request `path` from `consumer` and have `server` answer it: the answer, and /// the requester's broadcast. #[cfg(feature = "async")] - async fn hold(consumer: &Consumer, path: &str, server: &Requests) -> (broadcast::Producer, broadcast::Consumer) { + async fn hold(consumer: &Consumer, path: &str, server: &Route) -> (broadcast::Producer, broadcast::Consumer) { let pending = consumer.request(path, None); let answer = broadcast::Info::new().produce(); queued(server).await.serve(&answer); @@ -9255,7 +9268,7 @@ mod tests { let request = queued(&identified).await; assert_eq!(request.path().as_str(), "room/alice"); assert!( - anonymous.poll_requested_broadcast(&kio::Waiter::noop()).is_pending(), + anonymous.poll_requested(&kio::Waiter::noop()).is_pending(), "the cheaper anonymous route must not serve" ); } @@ -9279,7 +9292,7 @@ mod tests { let request = queued(&unranked).await; assert_eq!(request.path().as_str(), "room/alice"); assert!( - demoted.poll_requested_broadcast(&kio::Waiter::noop()).is_pending(), + demoted.poll_requested(&kio::Waiter::noop()).is_pending(), "the cheaper demoted link must not serve" ); } @@ -9304,21 +9317,24 @@ mod tests { let mut announced = producer.consume().announced(); let dynamic = producer - .forward("room", RouteInfo::default().with_instance(instance(), 0).with_cost(5), None) + .forward( + "room", + RouteInfo::default().with_instance(instance(), 0).with_cost(5), + None, + ) .unwrap(); announced.expect_next_active("room").await; - dynamic.update(dynamic.route().with_cost(1)).unwrap(); + dynamic.update(dynamic.route().unwrap().with_cost(1)).unwrap(); let route = announced.expect_next_active("room").await; assert_eq!((route.instance, route.cost), (Some(instance()), Cost::new(1))); - assert_eq!(dynamic.route().cost, Cost::new(1)); + assert_eq!(dynamic.route().unwrap().cost, Cost::new(1)); - let broadcast = producer.route("lobby", RouteOptions::hidden()).unwrap(); + let options = RouteOptions::hidden().with_instance(instance(), 0).with_cost(5); + let broadcast = producer.route("lobby", options).unwrap(); assert!(broadcast.route().is_none(), "not announced yet"); - broadcast - .announce(RouteInfo::default().with_instance(instance(), 0).with_cost(5)) - .unwrap(); + broadcast.announce().unwrap(); announced.expect_next_active("lobby").await; - broadcast.announce(broadcast.route().unwrap().with_cost(1)).unwrap(); + broadcast.set_cost(1).unwrap(); let route = announced.expect_next_active("lobby").await; assert_eq!((route.instance, route.cost), (Some(instance()), Cost::new(1))); broadcast.withdraw(); @@ -9348,7 +9364,9 @@ mod tests { // Broad and cheap; narrow and expensive. Both present relative to a cursor // rooted below them, and the narrow one is what a request there resolves. let _broad = producer.announce("room", RouteInfo::default().with_cost(1)).unwrap(); - let _narrow = producer.announce("room/alice", RouteInfo::default().with_cost(9)).unwrap(); + let _narrow = producer + .announce("room/alice", RouteInfo::default().with_cost(9)) + .unwrap(); let consumer = producer .consume() @@ -9436,7 +9454,10 @@ mod tests { let mut announced = consumer.announced(); let _local = producer - .route("room/alice", RouteOptions::default().with_instance(instance(), 0).with_cost(5)) + .route( + "room/alice", + RouteOptions::default().with_instance(instance(), 0).with_cost(5), + ) .unwrap(); assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(5)); @@ -9492,7 +9513,10 @@ mod tests { let consumer = producer.consume(); let _local = producer - .route("room/alice", RouteOptions::default().with_instance(instance(), 0).with_cost(5)) + .route( + "room/alice", + RouteOptions::default().with_instance(instance(), 0).with_cost(5), + ) .unwrap(); let first = consumer.request("room/alice", None).await.expect("resolves locally"); @@ -9606,7 +9630,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let local = producer - .route("room/alice", RouteOptions::default().with_instance(instance(), 0).with_cost(5)) + .route( + "room/alice", + RouteOptions::default().with_instance(instance(), 0).with_cost(5), + ) .unwrap(); let _a = local.broadcast().create_track("a", None).unwrap(); let _b = local.broadcast().create_track("b", None).unwrap(); @@ -9799,7 +9826,7 @@ mod tests { .expect("the newer hopless route won the tie") .expect("resolves"); assert_eq!(resolved.info().path.as_str(), "room/alice"); - assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); + assert!(server.poll_requested(&kio::Waiter::noop()).is_pending()); } /// Ingress announce stats count advertised intervals, not the broadcast's @@ -9825,12 +9852,7 @@ mod tests { let broadcast = producer.route("room/alice", RouteOptions::hidden()).unwrap(); assert_eq!(announces(), (0, 0), "a hidden broadcast is not announced"); broadcast.announce().unwrap(); - broadcast - .announce(RouteInfo { - cost: Cost::new(3), - ..RouteInfo::default() - }) - .unwrap(); + broadcast.set_cost(3).unwrap(); assert_eq!(announces(), (1, 0), "a re-price is not another announce"); broadcast.withdraw(); assert_eq!(announces(), (1, 1)); @@ -9859,7 +9881,10 @@ mod tests { .unwrap(); announced.expect_next_active("room/alice").await; let _local = producer - .route("room/alice", RouteOptions::default().with_instance(instance(), 0).with_cost(2)) + .route( + "room/alice", + RouteOptions::default().with_instance(instance(), 0).with_cost(2), + ) .unwrap(); assert!(announced.expect_next_active("room/alice").await.hops.is_empty()); @@ -9868,7 +9893,7 @@ mod tests { for _ in 0..20 { kio::clock::sim::yield_now().await; } - assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); + assert!(server.poll_requested(&kio::Waiter::noop()).is_pending()); } /// Unannouncing ends the front the origin served from the broadcast and @@ -9886,7 +9911,10 @@ mod tests { 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.broadcast().consume().is_closed(), "the broadcast itself lives on"); + assert!( + !broadcast.broadcast().consume().is_closed(), + "the broadcast itself lives on" + ); // Announcing again serves a fresh front. broadcast.announce().unwrap(); @@ -9905,7 +9933,10 @@ mod tests { let consumer = producer.consume(); let broadcast = producer - .route("room/alice", RouteOptions::default().with_instance(crate::Instance::random(), 0)) + .route( + "room/alice", + RouteOptions::default().with_instance(crate::Instance::random(), 0), + ) .unwrap(); let mut dynamic = broadcast.broadcast().requests(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); @@ -9962,7 +9993,7 @@ mod tests { /// A front resolved through a served route, as a relay's upstream session serves /// one: the upstream broadcast's track requests arrive on the returned handle. #[cfg(feature = "async")] - async fn served_front() -> (Requests, broadcast::Producer, broadcast::Requests, broadcast::Consumer) { + async fn served_front() -> (Route, broadcast::Producer, broadcast::Requests, broadcast::Consumer) { let producer = origin(1).produce(); let consumer = producer.consume(); let server = producer @@ -10261,7 +10292,11 @@ mod tests { .unwrap(); // The same publisher, also reached through the peer, at a price the plain front skips. let _echo = producer - .forward("room", RouteInfo::default().with_hops(hops(&[10, 7])).with_cost(100), None) + .forward( + "room", + RouteInfo::default().with_hops(hops(&[10, 7])).with_cost(100), + None, + ) .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); @@ -10314,7 +10349,9 @@ mod tests { let echo = producer .forward( "room", - RouteInfo::default().with_instance(instance(), 0).with_hops(hops(&[10, 7])), + RouteInfo::default() + .with_instance(instance(), 0) + .with_hops(hops(&[10, 7])), None, ) .unwrap(); @@ -10623,7 +10660,9 @@ mod tests { async fn create_broadcast_accepts_a_path_at_the_wire_limits() { let producer = origin(1).produce(); let path = vec!["a"; Path::MAX_PARTS].join("/"); - let _broadcast = producer.route(path.as_str(), RouteOptions::hidden()).expect("max depth is allowed"); + let _broadcast = producer + .route(path.as_str(), RouteOptions::hidden()) + .expect("max depth is allowed"); let deeper = vec!["a"; Path::MAX_PARTS + 1].join("/"); assert!(matches!( producer.route(deeper.as_str(), RouteOptions::hidden()), @@ -10769,7 +10808,11 @@ mod tests { let chat = producer .scope("", &scopes(&["room/live/chat"])) .unwrap() - .forward("room/live", RouteInfo::default().with_hops(hops(&[7])).with_cost(1), None) + .forward( + "room/live", + RouteInfo::default().with_hops(hops(&[7])).with_cost(1), + None, + ) .unwrap(); assert_eq!(all.expect_next_active("room/live").await.cost, Cost::new(1)); assert_eq!(rooted.expect_next_active("").await.cost, Cost::new(1)); @@ -10779,7 +10822,11 @@ mod tests { let video_route = producer .scope("", &scopes(&["room/live/video"])) .unwrap() - .forward("room/live", RouteInfo::default().with_hops(hops(&[8])).with_cost(5), None) + .forward( + "room/live", + RouteInfo::default().with_hops(hops(&[8])).with_cost(5), + None, + ) .unwrap(); all.assert_next_wait(); rooted.assert_next_wait(); @@ -10943,7 +10990,7 @@ mod tests { let request = queued(&server).await; // Only one request reaches the server. - assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); + assert!(server.poll_requested(&kio::Waiter::noop()).is_pending()); let source = broadcast::Info::new().produce(); request.serve(&source); @@ -11138,14 +11185,8 @@ mod tests { let mut near = Vec::new(); let mut far = Vec::new(); for i in 0..k { - near.push( - peer.forward(format!("room/{i}"), route(&[9, 2], 2), None) - .unwrap(), - ); - far.push( - peer.forward(format!("room/{i}"), route(&[9, 3, 4], 4), None) - .unwrap(), - ); + near.push(peer.forward(format!("room/{i}"), route(&[9, 2], 2), None).unwrap()); + far.push(peer.forward(format!("room/{i}"), route(&[9, 3, 4], 4), None).unwrap()); } let mut announced = producer.consume().announced(); for _ in 0..k { @@ -11321,7 +11362,9 @@ mod tests { let producer = origin(1).produce(); let peer = producer.clone().with_link(Link::Peer); let mut announced = producer.consume().announced(); - let route = RouteInfo::default().with_instance(instance(), 0).with_hops(hops(&[9, 2])); + let route = RouteInfo::default() + .with_instance(instance(), 0) + .with_hops(hops(&[9, 2])); let first = peer.forward("room", route.clone(), None).unwrap(); let second = peer.forward("room", route.clone(), None).unwrap(); announced.expect_next_active("room").await; @@ -11418,12 +11461,19 @@ mod tests { // and retracts from the local view when the local route goes, even though // the peer's still covers it. let _shadow = peer - .forward("both", RouteInfo::default().with_hops(hops(&[7])).with_via(origin(7)), None) + .forward( + "both", + RouteInfo::default().with_hops(hops(&[7])).with_via(origin(7)), + None, + ) .unwrap(); let ingest = producer .forward( "both", - RouteInfo::default().with_hops(hops(&[5])).with_via(origin(5)).with_cost(9), + RouteInfo::default() + .with_hops(hops(&[5])) + .with_via(origin(5)) + .with_cost(9), None, ) .unwrap(); @@ -11463,7 +11513,11 @@ mod tests { let mut everyone = producer.consume().announced(); let _core = core - .forward("core", RouteInfo::default().with_hops(hops(&[7])).with_via(origin(7)), None) + .forward( + "core", + RouteInfo::default().with_hops(hops(&[7])).with_via(origin(7)), + None, + ) .unwrap(); assert_eq!( everyone.expect_next_active("core").await.source(), @@ -11472,7 +11526,11 @@ mod tests { toward_core.assert_next_wait(); let _mesh = peer - .forward("mesh", RouteInfo::default().with_hops(hops(&[8])).with_via(origin(8)), None) + .forward( + "mesh", + RouteInfo::default().with_hops(hops(&[8])).with_via(origin(8)), + None, + ) .unwrap(); assert_eq!( toward_core.expect_next_active("mesh").await.source(), @@ -11482,12 +11540,19 @@ mod tests { // A path both an upstream and a mesh peer reach: the upstream route is // cheaper, yet the upstream view selects the mesh peer's. let _cheap = core - .forward("both", RouteInfo::default().with_hops(hops(&[7])).with_via(origin(7)), None) + .forward( + "both", + RouteInfo::default().with_hops(hops(&[7])).with_via(origin(7)), + None, + ) .unwrap(); let mesh = peer .forward( "both", - RouteInfo::default().with_hops(hops(&[8])).with_via(origin(8)).with_cost(9), + RouteInfo::default() + .with_hops(hops(&[8])) + .with_via(origin(8)) + .with_cost(9), None, ) .unwrap(); @@ -11556,67 +11621,74 @@ mod tests { .unwrap(); assert!((&mut pending).now_or_never().is_none()); - let published = prepared.announce().unwrap(); + prepared.announce().unwrap(); let resolved = pending.await.unwrap(); - assert_eq!(resolved.info().instance, published.route().unwrap().instance); + assert_eq!(resolved.info().instance, prepared.route().unwrap().instance); assert_ne!( resolved.info().instance, - claim.route().instance, + claim.route().unwrap().instance, "a job is a stream of its own" ); assert!(resolved.track("video").is_ok()); } - /// Only `publish` announces a prepared answer, under its instance and after admission. + /// A hidden job's route is listed by no cursor until it announces, under its instance. #[kio::test] #[cfg(feature = "async")] - async fn a_prepared_answer_cannot_announce_itself() { + async fn a_hidden_job_route_is_listed_only_once_announced() { let producer = origin(1).produce(); let mut announced = producer.consume().announced(); let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); announced.assert_next_active("room"); let pending = producer.consume().request("room/alice", None); let prepared = queued(&claim).await.route(RouteOptions::hidden()).unwrap(); - let answer = prepared.broadcast().clone(); - - let other = RouteInfo::default().with_instance(crate::Instance::random(), 0); - assert!(matches!(answer.announce(other), Err(Error::Closed))); - assert!(answer.route().is_none()); + assert!(prepared.route().is_none()); announced.assert_next_wait(); - let published = prepared.announce().unwrap(); - let instance = published.route().and_then(|route| route.instance); + prepared.announce().unwrap(); + let instance = prepared.route().and_then(|route| route.instance); assert!(instance.is_some()); + match announced.expect_next().await { + AnnounceEvent::Takeover { announce, .. } => { + assert_eq!(announce.prefix.as_str(), "room/alice"); + assert_eq!(announce.route.instance, instance); + } + other => panic!("should take over from the claim: got {other:?}"), + } assert_eq!(pending.await.unwrap().info().instance, instance); } - /// Announcement control follows the origin role while fill clones retain publication lifetime. + /// Route clones share announcement control, while a fill handle on its broadcast + /// keeps the broadcast alive but not the route. #[kio::test] #[cfg(feature = "async")] - async fn publication_clones_share_control_and_fill_retention() { + async fn route_clones_share_control_and_fill_handles_do_not_retain_it() { let producer = origin(1).produce(); let consumer = producer.consume(); let mut events = consumer.announced(); - let publication = producer.route("room/alice", RouteOptions::hidden()).unwrap(); + let publication = producer + .route("room/alice", RouteOptions::hidden().with_instance(instance(), 0)) + .unwrap(); let fill = publication.broadcast().clone(); let control = publication.clone(); - publication - .announce(RouteInfo::default().with_instance(instance(), 0)) - .unwrap(); - events.expect_next_active("room/alice").await; + publication.announce().unwrap(); + assert_eq!(events.expect_next_active("room/alice").await.instance, Some(instance())); control.withdraw(); events.expect_next_ended("room/alice").await; assert!(publication.route().is_none()); - publication - .announce(RouteInfo::default().with_instance(instance(), 0)) - .unwrap(); - events.expect_next_active("room/alice").await; + publication.announce().unwrap(); + assert_eq!(events.expect_next_active("room/alice").await.instance, Some(instance())); drop(control); - drop(publication); events.assert_next_wait(); - consumer.request("room/alice", None).await.unwrap(); - drop(fill); + let held = consumer.request("room/alice", None).await.unwrap(); + drop(publication); events.expect_next_ended("room/alice").await; + assert!(matches!( + consumer.request("room/alice", None).await, + Err(Error::Unroutable) + )); + assert!(!held.is_closed(), "the fill handle keeps the broadcast alive"); + drop(fill); } /// A withdrawn stale publication cannot remove a replacement instance's route. @@ -11630,7 +11702,10 @@ mod tests { .unwrap(); let replacement_instance: crate::Instance = "01900000-0000-7000-8000-000000000002".parse().unwrap(); let replacement = producer - .route("room/alice", RouteOptions::default().with_instance(replacement_instance.clone(), 0)) + .route( + "room/alice", + RouteOptions::default().with_instance(replacement_instance.clone(), 0), + ) .unwrap(); old.withdraw(); old.broadcast().close(); @@ -11653,11 +11728,11 @@ mod tests { let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); let _pending = producer.consume().request("room/alice", None); let prepared = queued(&claim).await.route(RouteOptions::hidden()).unwrap(); - let answer = prepared.broadcast().clone(); + let clone = prepared.clone(); drop(claim); assert!(matches!(prepared.announce(), Err(Error::Unroutable))); - assert!(matches!(answer.announce(), Err(Error::Closed))); + assert!(matches!(clone.announce(), Err(Error::Closed))); } #[kio::test] @@ -11717,11 +11792,11 @@ mod tests { let claim = producer.route_prefix("room", RouteOptions::default()).unwrap(); let path = Path::from_static("room/alice"); let pending = producer.consume().request(path.clone(), None); - let publication = queued(&claim).await.route(RouteOptions::hidden()).unwrap().announce().unwrap(); + let publication = queued(&claim).await.route(RouteOptions::default()).unwrap(); let held = pending.await.unwrap(); publication.withdraw(); assert!( - claim.state.lock().served.get(&path).is_none(), + claim.server().lock().served.get(&path).is_none(), "withdrawn job still cached" ); let next = producer.consume().request(path, None); @@ -11745,7 +11820,7 @@ mod tests { let answer = async |path: &str| { let pending = consumer.request(path, None); - let published = queued(&claim).await.route(RouteOptions::hidden()).unwrap().announce().unwrap(); + let published = queued(&claim).await.route(RouteOptions::default()).unwrap(); pending.await.unwrap(); published }; @@ -11780,7 +11855,7 @@ mod tests { assert!(matches!(unknown.await, Err(Error::Unroutable))); let pending = consumer.request("room/alice", None); - let published = queued(&claim).await.route(RouteOptions::hidden()).unwrap().announce().unwrap(); + let published = queued(&claim).await.route(RouteOptions::default()).unwrap(); let instance = published.route().unwrap().instance.unwrap(); pending.await.expect("resolves"); @@ -11816,7 +11891,7 @@ mod tests { assert!(matches!(err, Error::NotFound), "unexpected end: {err}"); for other in [&sibling, &catch_all] { - assert!(other.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); + assert!(other.poll_requested(&kio::Waiter::noop()).is_pending()); } } @@ -12109,8 +12184,14 @@ mod tests { // Pending requests reject; new work refuses. assert!(matches!(pending.now_or_never().expect("rejected"), Err(Error::Closed))); - assert!(matches!(producer.announce("x", RouteInfo::default()), Err(Error::Closed))); - assert!(matches!(producer.route("x", RouteOptions::hidden()), Err(Error::Closed))); + assert!(matches!( + producer.announce("x", RouteInfo::default()), + Err(Error::Closed) + )); + assert!(matches!( + producer.route("x", RouteOptions::hidden()), + Err(Error::Closed) + )); let err = consumer .request("y", None) .now_or_never() @@ -12146,7 +12227,7 @@ mod tests { let server = producer.forward("room", RouteInfo::default(), None).unwrap(); 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 { + let Poll::Ready(Some(request)) = server.poll_requested(&kio::Waiter::noop()) else { panic!("front requested its route"); }; drop(driver); @@ -12175,7 +12256,7 @@ mod tests { let _pending = producer.consume().request("room/alice", None); driver.poll(Instant::ZERO, &kio::Waiter::noop()).unwrap(); let channel = server - .state + .server() .read() .requests .get(&Path::from_static("room/alice")) @@ -12185,7 +12266,7 @@ mod tests { let reenter = || { Arc::new(Reenter { table: producer.shared.clone(), - server: server.state.clone(), + server: server.server().clone(), woken: AtomicBool::new(false), }) }; @@ -12193,7 +12274,7 @@ mod tests { let waiter = kio::Waiter::new(std::task::Waker::from(request.clone())); assert!(channel.poll(&waiter, |_| Poll::<()>::Pending).is_pending()); let waiter = kio::Waiter::new(std::task::Waker::from(queue.clone())); - assert!(server.state.poll(&waiter, |_| Poll::Pending).is_pending()); + assert!(server.server().poll(&waiter, |_| Poll::Pending).is_pending()); if teardown { drop(driver); } else { @@ -12221,7 +12302,7 @@ mod tests { /// Announce a served route with `first` as its first hop, materialize /// "room/alice" through it with a one-group "before" track, and subscribe. #[cfg(feature = "async")] - async fn new(first: &[u64]) -> (Self, Requests, broadcast::Producer) { + async fn new(first: &[u64]) -> (Self, Route, broadcast::Producer) { let producer = origin(1).produce(); let consumer = producer.consume(); @@ -12271,7 +12352,7 @@ mod tests { /// Stand up a second served route with `first` as its first hop and hand /// back its handle, ready to answer the front's re-request. - fn standby(&self, first: &[u64]) -> Requests { + fn standby(&self, first: &[u64]) -> Route { self.producer .forward( "room", @@ -12287,7 +12368,7 @@ mod tests { /// rig's subscription resumes onto it: the successor group is delivered on /// the same subscription, at the group boundary. #[cfg(feature = "async")] - async fn assert_resumes(rig: &mut ResumeRig, server: &Requests) { + async fn assert_resumes(rig: &mut ResumeRig, server: &Route) { let request = queued(server).await; let replacement = broadcast::Info::new().produce(); let track = replacement.create_track("video", crate::track::Info::timed()).unwrap(); @@ -12418,7 +12499,7 @@ mod tests { ); kio::clock::sim::yield_now().await; assert!( - a.poll_requested_broadcast(&kio::Waiter::noop()).is_pending(), + a.poll_requested(&kio::Waiter::noop()).is_pending(), "the host asked again" ); } @@ -12472,7 +12553,7 @@ mod tests { ); settle(|| resolved.is_closed()).await; assert!( - second.poll_requested_broadcast(&kio::Waiter::noop()).is_pending(), + second.poll_requested(&kio::Waiter::noop()).is_pending(), "a route of another instance is never asked to resume" ); } @@ -12485,21 +12566,33 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let old = producer - .route("room/alice", RouteOptions::default() + .route( + "room/alice", + RouteOptions::default() .with_instance(crate::Instance::random(), 0) - .with_cost(9)) + .with_cost(9), + ) + .unwrap(); + let old_track = old + .broadcast() + .create_track("video", crate::track::Info::timed()) .unwrap(); - let old_track = old.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); 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; let new = producer - .route("room/alice", RouteOptions::default() + .route( + "room/alice", + RouteOptions::default() .with_instance(crate::Instance::random(), 0) - .with_cost(1)) + .with_cost(1), + ) + .unwrap(); + let new_track = new + .broadcast() + .create_track("video", crate::track::Info::timed()) .unwrap(); - let new_track = new.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); deliver(&old_track, &mut subscription, b"sticky").await; let replaced = consumer.request("room/alice", None).await.expect("resolves"); @@ -12530,7 +12623,10 @@ mod tests { let old = producer .route("room/alice", RouteOptions::default().with_instance(first.clone(), 0)) .unwrap(); - let _old_track = old.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let _old_track = old + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); assert_eq!( resolved.info().instance.as_ref(), @@ -12542,7 +12638,10 @@ mod tests { let new = producer .route("room/alice", RouteOptions::default().with_instance(instance.clone(), 0)) .unwrap(); - let new_track = new.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let new_track = new + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let named = consumer.request("room/alice", instance.clone()); let bare = consumer.request("room/alice", None); @@ -12582,9 +12681,15 @@ mod tests { // The answer and the new instance land in the same tick. let new = producer - .route("room/alice", RouteOptions::default().with_instance(crate::Instance::random(), 0)) + .route( + "room/alice", + RouteOptions::default().with_instance(crate::Instance::random(), 0), + ) + .unwrap(); + let new_track = new + .broadcast() + .create_track("video", crate::track::Info::timed()) .unwrap(); - let new_track = new.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); let stale = broadcast::Info::new().produce(); let _stale_track = stale.create_track("video", crate::track::Info::timed()).unwrap(); request.serve(&stale); @@ -12617,11 +12722,11 @@ mod tests { if answer_first { request.serve(&stale); dynamic - .update(dynamic.route().with_instance(instance.clone(), 0)) + .update(dynamic.route().unwrap().with_instance(instance.clone(), 0)) .unwrap(); } else { dynamic - .update(dynamic.route().with_instance(instance.clone(), 0)) + .update(dynamic.route().unwrap().with_instance(instance.clone(), 0)) .unwrap(); request.serve(&stale); } @@ -12636,7 +12741,7 @@ mod tests { matches!(pinned.await, Err(Error::Unroutable)), "a request pinned to the old instance resolved" ); - let cached = dynamic.state.lock().served.get(&Path::from_static("room/alice")); + let cached = dynamic.server().lock().served.get(&Path::from_static("room/alice")); assert!( cached.is_some_and(|cached| cached.consume().is_clone(&fresh.consume())), "the old answer was cached" @@ -12675,7 +12780,7 @@ mod tests { queued(&dynamic).await.reject(Error::NotFound); let instance = crate::Instance::random(); dynamic - .update(dynamic.route().with_instance(instance.clone(), 0)) + .update(dynamic.route().unwrap().with_instance(instance.clone(), 0)) .unwrap(); let fresh = broadcast::Info::new().produce(); @@ -12702,10 +12807,10 @@ mod tests { let request = queued(&dynamic).await; dynamic - .update(dynamic.route().with_instance(crate::Instance::random(), 0)) + .update(dynamic.route().unwrap().with_instance(crate::Instance::random(), 0)) .unwrap(); dynamic - .update(dynamic.route().with_instance(old.clone(), 0)) + .update(dynamic.route().unwrap().with_instance(old.clone(), 0)) .unwrap(); let stale = broadcast::Info::new().produce(); let _stale_track = stale.create_track("video", crate::track::Info::timed()).unwrap(); @@ -12729,12 +12834,18 @@ mod tests { let mut announced = producer.consume().announced(); let instance = crate::Instance::random(); let _old = producer - .route("room/alice", RouteOptions::default().with_instance(instance.clone(), 1).with_cost(1)) + .route( + "room/alice", + RouteOptions::default().with_instance(instance.clone(), 1).with_cost(1), + ) .unwrap(); assert_eq!(announced.expect_next_active("room/alice").await.cost, Cost::new(1)); let new = producer - .route("room/alice", RouteOptions::default().with_instance(instance.clone(), 2).with_cost(9)) + .route( + "room/alice", + RouteOptions::default().with_instance(instance.clone(), 2).with_cost(9), + ) .unwrap(); let newest = announced.expect_next_active("room/alice").await; assert_eq!( @@ -12898,7 +13009,7 @@ mod tests { 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(), + standby.poll_requested(&kio::Waiter::noop()).is_pending(), "first hop {first:?} moved off a route that still serves" ); } @@ -12927,7 +13038,9 @@ mod tests { let echo = producer .forward( "room", - RouteInfo::default().with_instance(instance(), 0).with_hops(hops(&[10, 7])), + RouteInfo::default() + .with_instance(instance(), 0) + .with_hops(hops(&[10, 7])), None, ) .unwrap(); @@ -12956,7 +13069,7 @@ mod tests { let err = next_group(&mut subscription).await.err().expect("subscription ends"); assert!(matches!(err, Error::Dropped), "unexpected end: {err}"); assert!( - echo.poll_requested_broadcast(&kio::Waiter::noop()).is_pending(), + echo.poll_requested(&kio::Waiter::noop()).is_pending(), "the front asked the requester for its own copy" ); } @@ -13232,7 +13345,10 @@ mod tests { let consumer = producer.consume(); let broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved @@ -13332,7 +13448,7 @@ mod tests { source.close(); settle(|| resolved.is_closed()).await; assert!( - server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending(), + server.poll_requested(&kio::Waiter::noop()).is_pending(), "the closed source was requested again" ); } @@ -13348,7 +13464,10 @@ mod tests { let consumer = producer.consume(); let broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"cached".as_ref()).unwrap(); group.finish().unwrap(); @@ -13452,7 +13571,10 @@ mod tests { async fn a_group_the_source_aborts_ends_while_the_track_lives() { let producer = origin(1).produce(); let broadcast = producer.route("live", RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let resolved = producer.consume().request("live", None).await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -13487,7 +13609,10 @@ mod tests { let leaf_consumer = leaf.consume(); let broadcast = leaf.route("room/alice", RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"cached".as_ref()).unwrap(); group.finish().unwrap(); @@ -13587,7 +13712,10 @@ mod tests { let first = producer .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); - let track = first.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = first + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved .track("video") @@ -13606,7 +13734,8 @@ mod tests { .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); let _incompatible = second - .broadcast().create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) + .broadcast() + .create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) .unwrap(); for _ in 0..10 { kio::clock::sim::yield_now().await; @@ -13628,13 +13757,7 @@ mod tests { /// A remote front serving "room/alice" with one read track, "video", whose first /// group was delivered. Returns the producer, the incumbent's track, and the reader. #[cfg(feature = "async")] - async fn remote_front() -> ( - Producer, - Requests, - broadcast::Producer, - track::Producer, - track::Subscriber, - ) { + async fn remote_front() -> (Producer, Route, broadcast::Producer, track::Producer, track::Subscriber) { let producer = origin(1).produce(); let server = producer .forward( @@ -13665,11 +13788,11 @@ mod tests { async fn an_unread_draining_track_releases_the_old_source() { let (producer, _server, _upstream, old, subscription) = remote_front().await; - let newcomer = producer.route("room/alice", RouteOptions::hidden()).unwrap(); - let mut handler = newcomer.requests(); - newcomer - .announce(RouteInfo::default().with_instance(instance(), 0)) + let newcomer = producer + .route("room/alice", RouteOptions::hidden().with_instance(instance(), 0)) .unwrap(); + let mut handler = newcomer.broadcast().requests(); + newcomer.announce().unwrap(); let _unanswered = kio::clock::timeout(Duration::from_secs(1), handler.requested_track()) .await .expect("the front asked the newcomer") @@ -13791,7 +13914,10 @@ mod tests { let newcomer = producer .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); - let _video = newcomer.create_track("video", crate::track::Info::timed()).unwrap(); + let _video = newcomer + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); for _ in 0..10 { kio::clock::sim::yield_now().await; } @@ -13814,7 +13940,10 @@ mod tests { let first = producer .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); - let track = first.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = first + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); 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(); @@ -13827,7 +13956,8 @@ mod tests { .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); let incompatible = second - .broadcast().create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) + .broadcast() + .create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) .unwrap(); for _ in 0..10 { kio::clock::sim::yield_now().await; @@ -13854,7 +13984,10 @@ mod tests { let first = producer .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); - let track = first.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = first + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); 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(); @@ -13868,7 +14001,8 @@ mod tests { .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); let incompatible = second - .broadcast().create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) + .broadcast() + .create_track("video", track::Info::default().with_timescale(crate::Timescale::MICRO)) .unwrap(); for _ in 0..10 { kio::clock::sim::yield_now().await; @@ -13910,7 +14044,10 @@ mod tests { let first = producer .route("room/alice", RouteOptions::default().with_instance(instance(), 0)) .unwrap(); - let track = first.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = first + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); 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(); @@ -13920,9 +14057,11 @@ mod tests { assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); drop(group); - let second = producer.route("room/alice", RouteOptions::hidden()).unwrap(); + let second = producer + .route("room/alice", RouteOptions::hidden().with_instance(instance(), 0)) + .unwrap(); let mut handler = second.broadcast().requests(); - second.announce(RouteInfo::default().with_instance(instance(), 0)).unwrap(); + second.announce().unwrap(); let request = kio::clock::timeout(Duration::from_secs(1), handler.requested_track()) .await .expect("the front asked the newcomer") @@ -14050,7 +14189,7 @@ mod tests { assert!(matches!(driver.poll(Instant::now(), &waiter), Err(Error::Closed))); } - /// A handler holding only its `Requests` keeps serving once every producer + /// A handler holding only its `Route` keeps serving once every producer /// handle drops, and the driver finishes once the handler is gone too. #[kio::test] #[cfg(feature = "async")] @@ -14086,7 +14225,10 @@ mod tests { let run = kio::clock::sim::spawn(crate::time::run(driver)); let consumer = producer.consume(); let broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -14111,7 +14253,10 @@ mod tests { let run = kio::clock::sim::spawn(crate::time::run(driver)); let consumer = producer.consume(); let broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); - let mut track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let mut track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); 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); @@ -14139,7 +14284,10 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); let broadcast = producer.route("room/alice", RouteOptions::default()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let sub = resolved.track("video").unwrap().subscribe(None).await.unwrap(); kio::clock::timeout(Duration::from_secs(1), track.demand().until(|wanted| wanted.is_some())) @@ -14168,7 +14316,7 @@ mod tests { let selected = broad.request_validity(&Path::from_static("room/a")).unwrap(); let pending = selected.current(); assert!(!pending.is_closed()); - broad.update(broad.route().with_cost(Cost::from(7))).unwrap(); + broad.update(broad.route().unwrap().with_cost(Cost::from(7))).unwrap(); assert!(!pending.is_closed()); // Another peer's winning route cannot change what a request on peer 2 names. let other = producer @@ -14309,14 +14457,17 @@ mod tests { let producer = origin(1).produce(); for path in ["room/./cam", "room/../cam", ".", ".."] { assert!(producer.route(path, RouteOptions::hidden()).is_err(), "created {path}"); - assert!(producer.announce(path, RouteInfo::default()).is_err(), "announced {path}"); + assert!( + producer.announce(path, RouteInfo::default()).is_err(), + "announced {path}" + ); } let scoped = producer .scope("room/..", &Patterns::from_iter([Pattern::all()])) .unwrap(); assert!(scoped.route("cam", RouteOptions::hidden()).is_err()); for path in ["room/.pro/cam", "room/a..b", "room/cam"] { - producer.route(path, RouteOptions::hidden()).unwrap(); + let _route = producer.route(path, RouteOptions::hidden()).unwrap(); } } @@ -14449,7 +14600,9 @@ mod tests { .collect(); let consumer = producer.consume().scope("project", &patterns).unwrap(); let cam = producer.announce("project/cam.hang", RouteInfo::default()).unwrap(); - let overlap = producer.announce("project/room/mic.hang", RouteInfo::default()).unwrap(); + let overlap = producer + .announce("project/room/mic.hang", RouteInfo::default()) + .unwrap(); let chat = producer.announce("project/lobby.chat", RouteInfo::default()).unwrap(); let mut routing = consumer.clone().covering().announced(); routing.expect_next_active("cam.hang").await; @@ -14460,7 +14613,9 @@ mod tests { selected.expect_next_active("lobby.chat").await; selected.assert_next_wait(); - let nested = producer.announce("project/room/lobby.chat", RouteInfo::default()).unwrap(); + let nested = producer + .announce("project/room/lobby.chat", RouteInfo::default()) + .unwrap(); selected.expect_next_active("room/lobby.chat").await; overlap.update(RouteInfo::default().with_cost(2)).unwrap(); drop(overlap); @@ -14484,7 +14639,10 @@ mod tests { let first_instance = crate::Instance::random(); let exact = producer - .announce("room/alice", RouteInfo::default().with_instance(first_instance.clone(), 0)) + .announce( + "room/alice", + RouteInfo::default().with_instance(first_instance.clone(), 0), + ) .unwrap(); assert!( matches!(selected.expect_next().await, AnnounceEvent::Start(a) if a.prefix.is_empty() && a.captures.is_some()) @@ -14573,7 +14731,10 @@ mod tests { resolved.is_clone(&original), "the view shares the origin's existing front" ); - let track = local.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = local + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let mut written = track.append_group().unwrap(); written.write_frame(crate::Timestamp::ZERO, b"frame".as_ref()).unwrap(); written.finish().unwrap(); @@ -14606,7 +14767,9 @@ mod tests { #[kio::test] async fn local_broadcast_wins_announcement_ties() { let producer = origin(1).produce(); - let remote = producer.announce("room/alice", RouteInfo::default().with_cost(9)).unwrap(); + let remote = producer + .announce("room/alice", RouteInfo::default().with_cost(9)) + .unwrap(); let local = producer.route("room/alice", RouteOptions::hidden()).unwrap(); local.announce().unwrap(); @@ -14654,7 +14817,10 @@ mod tests { let expiry = Duration::from_secs(1); let origin = expiring_origin(expiry); let broadcast = origin.route("test", RouteOptions::hidden()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let mut stalled = track.append_group().unwrap(); stalled.write_frame(crate::Timestamp::ZERO, b"x".as_slice()).unwrap(); @@ -14687,7 +14853,10 @@ mod tests { } .produce(); let broadcast = origin.route("test", RouteOptions::hidden()).unwrap(); - let track = broadcast.broadcast().create_track("video", crate::track::Info::timed()).unwrap(); + let track = broadcast + .broadcast() + .create_track("video", crate::track::Info::timed()) + .unwrap(); let mut stalled = track.append_group().unwrap(); stalled.write_frame(crate::Timestamp::ZERO, b"x".as_slice()).unwrap(); diff --git a/rs/moq-net/src/model/resume_model.rs b/rs/moq-net/src/model/resume_model.rs index bdab5e3e56d..cac76dd195c 100644 --- a/rs/moq-net/src/model/resume_model.rs +++ b/rs/moq-net/src/model/resume_model.rs @@ -458,7 +458,7 @@ impl Model { let track = broadcast.create_track("video", track::Info::timed()).unwrap(); let upstream = broadcast.consume(); let serving = kio::clock::sim::spawn(async move { - while let Ok(request) = kio::wait(|waiter| requests.poll_requested_broadcast(waiter)).await { + while let Some(request) = kio::wait(|waiter| requests.poll_requested(waiter)).await { request.serve(&upstream); } }); diff --git a/rs/moq-net/tests/integration/announce_covering_route.rs b/rs/moq-net/tests/integration/announce_covering_route.rs index 8f7480fcf00..6468bf11855 100644 --- a/rs/moq-net/tests/integration/announce_covering_route.rs +++ b/rs/moq-net/tests/integration/announce_covering_route.rs @@ -65,12 +65,16 @@ async fn covering(version: Option<&str>) -> Vec { let mut announced = observer.scope(REQUESTED, &everything).unwrap().covering().announced(); let mut log = Vec::new(); - let served = publisher.route(SERVED, moq_net::origin::RouteOptions::hidden()).unwrap(); + let served = publisher + .route(SERVED, moq_net::origin::RouteOptions::hidden()) + .unwrap(); served.announce().unwrap(); kio::clock::sleep(SETTLE).await; log.push(format!("served: {:?}", drain(&mut announced))); - let below = publisher.route(format!("{REQUESTED}/cam"), moq_net::origin::RouteOptions::hidden()).unwrap(); + let below = publisher + .route(format!("{REQUESTED}/cam"), moq_net::origin::RouteOptions::hidden()) + .unwrap(); below.announce().unwrap(); kio::clock::sleep(SETTLE).await; log.push(format!("below: {:?}", drain(&mut announced))); @@ -129,8 +133,12 @@ async fn relays_route_a_covering_claim_that_listings_omit() { ] { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let claim = publisher.route_prefix("room", moq_net::origin::RouteOptions::default()).unwrap(); - let listed = publisher.route("lobby.chat", moq_net::origin::RouteOptions::hidden()).unwrap(); + let claim = publisher + .route_prefix("room", moq_net::origin::RouteOptions::default()) + .unwrap(); + let listed = publisher + .route("lobby.chat", moq_net::origin::RouteOptions::hidden()) + .unwrap(); listed.announce().unwrap(); let relay = produce_origin(2); diff --git a/rs/moq-net/tests/integration/announce_takeover.rs b/rs/moq-net/tests/integration/announce_takeover.rs index 5a31d4b97a6..2a7caf387f1 100644 --- a/rs/moq-net/tests/integration/announce_takeover.rs +++ b/rs/moq-net/tests/integration/announce_takeover.rs @@ -45,11 +45,15 @@ struct Worker { impl Worker { fn new(hop: u64, claim: &str, name: &'static str) -> Self { let origin = produce_origin(hop); - let claim = Rc::new(origin.route_prefix(claim, moq_net::origin::RouteOptions::default()).unwrap()); + let claim = Rc::new( + origin + .route_prefix(claim, moq_net::origin::RouteOptions::default()) + .unwrap(), + ); let outputs = Rc::new(RefCell::new(Vec::new())); let (handler, served) = (claim.clone(), outputs.clone()); drop(kio::clock::sim::spawn(async move { - while let Ok(request) = handler.requested().await { + while let Some(request) = handler.requested().await { let prepared = request.route(moq_net::origin::RouteOptions::hidden()).unwrap(); let track = prepared .broadcast() @@ -61,7 +65,8 @@ impl Worker { let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, name.as_bytes().to_vec()).unwrap(); group.finish().unwrap(); - served.borrow_mut().push((prepared.announce().unwrap(), track)); + prepared.announce().unwrap(); + served.borrow_mut().push((prepared, track)); } })); Self { @@ -220,7 +225,10 @@ async fn an_unrequested_publish_is_a_start() { let mut announced = relay.consume().announced(); assert_eq!(drain(&mut announced).await, [("start", "pool".to_string(), None)]); - let _direct = worker.origin.route("pool/q", moq_net::origin::RouteOptions::default()).unwrap(); + let _direct = worker + .origin + .route("pool/q", moq_net::origin::RouteOptions::default()) + .unwrap(); settle().await; assert_eq!(drain(&mut announced).await, [("start", "pool/q".to_string(), None)]); }) diff --git a/rs/moq-net/tests/integration/auth.rs b/rs/moq-net/tests/integration/auth.rs index 0f45eb5269c..3b72bf0a5cb 100644 --- a/rs/moq-net/tests/integration/auth.rs +++ b/rs/moq-net/tests/integration/auth.rs @@ -143,8 +143,9 @@ async fn moqt_22_renewing_a_cancelled_announce_keeps_the_session() { let mut tokens = serve(pair.requests.take().unwrap(), |_| Some(Grant::all())); let (first, answer) = pair.client.auth().add("first").await.expect("kept for requests"); assert_eq!(answer, auth::Answer::Requests); - let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); - broadcast.announce(origin::RouteInfo::default().with_auth(first)).unwrap(); + let broadcast = client_origin + .route("room/x", origin::RouteOptions::default().with_auth(first)) + .unwrap(); let (_, first) = tokens.next().await.expect("the announce's token"); // Ending the grant cancels the announcement. The idle request reads that and the @@ -155,7 +156,7 @@ async fn moqt_22_renewing_a_cancelled_announce_keeps_the_session() { assert_eq!(token, b"first"); kio::clock::sleep(Duration::from_secs(1)).await; let (second, _) = pair.client.auth().add("second").await.expect("kept for requests"); - broadcast.announce(origin::RouteInfo::default().with_auth(second)).unwrap(); + broadcast.set_auth(Some(second)).unwrap(); let (token, _second) = tokens.next().await.expect("announced again"); assert_eq!(token, b"second"); assert_eq!(pair.client_transport.close_reason(), None); @@ -174,12 +175,13 @@ async fn moqt_22_a_cancelled_renewal_keeps_the_session() { (token == b"first").then(Grant::all) }); let (first, _) = pair.client.auth().add("first").await.expect("kept for requests"); - let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); - broadcast.announce(origin::RouteInfo::default().with_auth(first)).unwrap(); + let broadcast = client_origin + .route("room/x", origin::RouteOptions::default().with_auth(first)) + .unwrap(); let (_, first) = tokens.next().await.expect("the announce's token"); let (second, _) = pair.client.auth().add("second").await.expect("kept for requests"); - broadcast.announce(origin::RouteInfo::default().with_auth(second)).unwrap(); + broadcast.set_auth(Some(second)).unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; drop(first); kio::clock::sleep(Duration::from_secs(1)).await; @@ -198,8 +200,9 @@ async fn moqt_22_dropping_the_old_grant_with_its_renewal_keeps_the_announce() { let (mut pair, client_origin, server_origin) = connect_route_auth(MOQT_22).await; let mut requests = pair.requests.take().unwrap(); let (first, _) = pair.client.auth().add("first").await.expect("kept for requests"); - let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); - broadcast.announce(origin::RouteInfo::default().with_auth(first)).unwrap(); + let broadcast = client_origin + .route("room/x", origin::RouteOptions::default().with_auth(first)) + .unwrap(); let first = requests .next() .await @@ -208,7 +211,7 @@ async fn moqt_22_dropping_the_old_grant_with_its_renewal_keeps_the_announce() { wait_announced(&server_origin.consume(), "room/x", true).await; let (second, _) = pair.client.auth().add("second").await.expect("kept for requests"); - broadcast.announce(origin::RouteInfo::default().with_auth(second)).unwrap(); + broadcast.set_auth(Some(second)).unwrap(); let renewal = requests.next().await.expect("the renewal's token"); assert_eq!(renewal.token().as_ref(), b"second"); let second = renewal.accept(Grant::all()); @@ -253,8 +256,9 @@ async fn moqt_22_a_revoked_route_auth_remakes_its_announce() { let (first, _) = pair.client.auth().add("first").await.expect("granted"); let (token, presented) = tokens.next().await.expect("the AUTH stream's token"); assert_eq!(token, b"first"); - let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); - broadcast.announce(origin::RouteInfo::default().with_auth(first)).unwrap(); + let _route = client_origin + .route("room/x", origin::RouteOptions::default().with_auth(first)) + .unwrap(); let (token, carried) = tokens.next().await.expect("the announce's token"); assert_eq!(token, b"first"); wait_announced(&server_origin.consume(), "room/x", true).await; @@ -313,8 +317,9 @@ async fn a_route_auth_survives_a_reconnect(version: &'static str) { let mut first = connect_route_auth_on(version, &client_origin, &server_origin, Some(handle.clone())).await; let mut tokens = serve(first.requests.take().unwrap(), |_| Some(Grant::all())); let (token, _) = handle.add("first").await.expect("kept for requests"); - let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); - broadcast.announce(origin::RouteInfo::default().with_auth(token)).unwrap(); + let _route = client_origin + .route("room/x", origin::RouteOptions::default().with_auth(token)) + .unwrap(); let (token, _first) = tokens.next().await.expect("the announce's token"); assert_eq!(token, b"first"); @@ -339,14 +344,15 @@ async fn a_route_auth_renews_its_announce(version: &'static str) { let mut tokens = serve(pair.requests.take().unwrap(), |_| Some(Grant::all())); let (first, _) = pair.client.auth().add("first").await.expect("kept for requests"); - let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); - broadcast.announce(origin::RouteInfo::default().with_auth(first)).unwrap(); + let route = client_origin + .route("room/x", origin::RouteOptions::default().with_auth(first)) + .unwrap(); let (token, _first) = tokens.next().await.expect("the announce's token"); assert_eq!(token, b"first"); wait_announced(&server_origin.consume(), "room/x", true).await; let (second, _) = pair.client.auth().add("second").await.expect("kept for requests"); - broadcast.announce(origin::RouteInfo::default().with_auth(second)).unwrap(); + route.set_auth(Some(second)).unwrap(); let (token, _second) = tokens.next().await.expect("the renewal's token"); assert_eq!(token, b"second"); wait_announced(&server_origin.consume(), "room/x", true).await; @@ -608,12 +614,16 @@ async fn an_out_of_scope_announce_aborts_with_the_path(version: &'static str) { .await; // In scope: served, and nothing aborts. - let ok = publisher.route("baz/ok", moq_net::origin::RouteOptions::hidden()).unwrap(); + let ok = publisher + .route("baz/ok", moq_net::origin::RouteOptions::hidden()) + .unwrap(); ok.announce().unwrap(); wait_announced(&relay.consume(), "baz/ok", true).await; assert_eq!(pair.client_transport.close_reason(), None); - let bad = publisher.route("foo/bar", moq_net::origin::RouteOptions::hidden()).unwrap(); + let bad = publisher + .route("foo/bar", moq_net::origin::RouteOptions::hidden()) + .unwrap(); bad.announce().unwrap(); let err = pair.server.closed().await; assert!( @@ -632,7 +642,9 @@ async fn an_out_of_scope_announce_aborts_with_the_path(version: &'static str) { async fn a_broadcast_published_before_the_grant_is_checked(version: &'static str) { within(async { let publisher = produce_origin(2); - let early = publisher.route("foo/bar", moq_net::origin::RouteOptions::hidden()).unwrap(); + let early = publisher + .route("foo/bar", moq_net::origin::RouteOptions::hidden()) + .unwrap(); early.announce().unwrap(); let pair = connect(Options { @@ -674,7 +686,9 @@ async fn an_unanswered_token_holds_the_check(version: &'static str) { let auth = pair.client.auth(); let pending = kio::clock::sim::spawn(async move { auth.add("new").await }); let unanswered = requests.next().await.unwrap(); - let broadcast = publisher.route("foo/bar", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("foo/bar", moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; use futures::FutureExt; @@ -685,7 +699,9 @@ async fn an_unanswered_token_holds_the_check(version: &'static str) { let _issued = unanswered.accept(grant(&["foo"], &[])); let _token = pending.await.unwrap().unwrap(); assert_eq!(granted(&pair.client).await, grant(&["baz", "foo"], &[])); - let bad = publisher.route("still-bad", moq_net::origin::RouteOptions::hidden()).unwrap(); + let bad = publisher + .route("still-bad", moq_net::origin::RouteOptions::hidden()) + .unwrap(); bad.announce().unwrap(); assert!(matches!( pair.server.closed().await, @@ -716,7 +732,9 @@ async fn a_broadcast_withdrawn_while_its_token_waits_is_not_refused(version: &'s let auth = pair.client.auth(); let pending = kio::clock::sim::spawn(async move { auth.add("new").await }); let unanswered = requests.next().await.unwrap(); - let withdrawn = publisher.route("foo/bar", moq_net::origin::RouteOptions::hidden()).unwrap(); + let withdrawn = publisher + .route("foo/bar", moq_net::origin::RouteOptions::hidden()) + .unwrap(); withdrawn.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; withdrawn.withdraw(); @@ -725,7 +743,9 @@ async fn a_broadcast_withdrawn_while_its_token_waits_is_not_refused(version: &'s let _token = pending.await.unwrap().unwrap(); assert_eq!(granted(&pair.client).await, grant(&["baz", "other"], &[])); // Still enforcing: the next uncovered broadcast is the one named. - let bad = publisher.route("still-bad", moq_net::origin::RouteOptions::hidden()).unwrap(); + let bad = publisher + .route("still-bad", moq_net::origin::RouteOptions::hidden()) + .unwrap(); bad.announce().unwrap(); assert!(matches!( pair.server.closed().await, @@ -1123,7 +1143,9 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { /// version with AUTH has opened its Auth Stream on both sides. async fn connect_announced(version: &'static str) -> (Pair, moq_net::origin::Route) { let client_origin = produce_origin(2); - let broadcast = client_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = client_origin + .route("room/x", moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); let server_origin = produce_origin(1); let pair = connect(Options { @@ -1140,7 +1162,9 @@ async fn connect_announced(version: &'static str) -> (Pair, moq_net::origin::Rou async fn a_live_subscription_survives_union_renewal(version: &'static str) { within(async { let publisher = produce_origin(1); - let broadcast = publisher.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room/x", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let published = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); let received = produce_origin(2); @@ -1210,12 +1234,16 @@ async fn a_revoked_grant_cancels_its_subscriptions(version: &'static str) { // The server publishes room/x to the client; the client publishes up/y to the server. let server_origin = produce_origin(1); - let down = server_origin.route("room/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + let down = server_origin + .route("room/x", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let down_track = down.broadcast().create_track("video", timed()).unwrap(); down.announce().unwrap(); let client_origin = produce_origin(2); - let up = client_origin.route("up/y", moq_net::origin::RouteOptions::hidden()).unwrap(); + let up = client_origin + .route("up/y", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let up_track = up.broadcast().create_track("video", timed()).unwrap(); up.announce().unwrap(); @@ -1445,7 +1473,9 @@ async fn a_wildcard_grant_is_enforced(version: &'static str) { } assert_eq!(pair.client_transport.close_reason(), None); - let bad = publisher.route("room/alice/mic", moq_net::origin::RouteOptions::hidden()).unwrap(); + let bad = publisher + .route("room/alice/mic", moq_net::origin::RouteOptions::hidden()) + .unwrap(); bad.announce().unwrap(); assert!(matches!( pair.server.closed().await, @@ -1466,7 +1496,9 @@ async fn a_wildcard_grant_is_enforced(version: &'static str) { async fn nothing_outside_the_grant_reaches_the_peer(version: &'static str) { within(async { let publisher = produce_origin(2); - let early = publisher.route("foo/bar", moq_net::origin::RouteOptions::hidden()).unwrap(); + let early = publisher + .route("foo/bar", moq_net::origin::RouteOptions::hidden()) + .unwrap(); early.announce().unwrap(); // The relay accepts anything; only the grant it tells the client is narrow. @@ -1506,7 +1538,9 @@ async fn a_broadcast_received_from_the_peer_is_not_ours_to_check(version: &'stat within(async { let local = produce_origin(2); let relay = produce_origin(1); - let remote = relay.route("remote/x", moq_net::origin::RouteOptions::hidden()).unwrap(); + let remote = relay + .route("remote/x", moq_net::origin::RouteOptions::hidden()) + .unwrap(); remote.announce().unwrap(); let pair = connect(Options { @@ -1611,10 +1645,14 @@ async fn a_narrowing_deafens_one_path(version: &'static str) { }; let relay = produce_origin(1); - let audio = relay.route("room/alice/audio", moq_net::origin::RouteOptions::hidden()).unwrap(); + let audio = relay + .route("room/alice/audio", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let audio_track = audio.broadcast().create_track("opus", timed()).unwrap(); audio.announce().unwrap(); - let video = relay.route("room/alice/video", moq_net::origin::RouteOptions::hidden()).unwrap(); + let video = relay + .route("room/alice/video", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let video_track = video.broadcast().create_track("h264", timed()).unwrap(); video.announce().unwrap(); @@ -1699,10 +1737,14 @@ async fn a_narrowing_aborts_what_the_peer_published(version: &'static str) { }; let client_origin = produce_origin(2); - let mic = client_origin.route("room/bob/mic", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mic = client_origin + .route("room/bob/mic", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mic_track = mic.broadcast().create_track("opus", timed()).unwrap(); mic.announce().unwrap(); - let cam = client_origin.route("room/bob/cam", moq_net::origin::RouteOptions::hidden()).unwrap(); + let cam = client_origin + .route("room/bob/cam", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let cam_track = cam.broadcast().create_track("h264", timed()).unwrap(); cam.announce().unwrap(); @@ -1836,7 +1878,9 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { }; let relay = produce_origin(1); - let audio = relay.route("room/alice/audio", moq_net::origin::RouteOptions::hidden()).unwrap(); + let audio = relay + .route("room/alice/audio", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let audio_track = audio.broadcast().create_track("opus", timed()).unwrap(); audio.announce().unwrap(); @@ -1908,7 +1952,9 @@ async fn a_widening_brings_back_what_the_peer_published(version: &'static str) { }; let client_origin = produce_origin(2); - let mic = client_origin.route("room/bob/mic", moq_net::origin::RouteOptions::hidden()).unwrap(); + let mic = client_origin + .route("room/bob/mic", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mic_track = mic.broadcast().create_track("opus", timed()).unwrap(); mic.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/broadcast_close.rs b/rs/moq-net/tests/integration/broadcast_close.rs index adb82f6fa7e..30a67b041c8 100644 --- a/rs/moq-net/tests/integration/broadcast_close.rs +++ b/rs/moq-net/tests/integration/broadcast_close.rs @@ -22,7 +22,9 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { /// Close a published broadcast and check what `reader`'s origin answers afterwards. async fn close_then_lookup(publisher: moq_net::origin::Producer, reader: moq_net::origin::Producer) { - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let _track = broadcast.broadcast().create_track("video", None).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/catalog_acquisition.rs b/rs/moq-net/tests/integration/catalog_acquisition.rs index 04451455707..a0e9f5a50b5 100644 --- a/rs/moq-net/tests/integration/catalog_acquisition.rs +++ b/rs/moq-net/tests/integration/catalog_acquisition.rs @@ -26,11 +26,11 @@ async fn acquisition(version: &str, carries_instance: bool) { let version: Version = version.parse().unwrap(); let publisher = origin(1); let subscriber = origin(2); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); - let mut dynamic = broadcast.broadcast().requests(); - broadcast - .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) .unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let _old = link(version, &publisher, &subscriber, 100).await; let remote = subscriber .consume() @@ -41,7 +41,7 @@ async fn acquisition(version: &str, carries_instance: bool) { .unwrap(); let mut announced = subscriber.consume().announced(); let old_cost = match announced.next().await { - Some(moq_net::announce::Event::Start(announce)) => announce.route.cost, + Some(moq_net::announce::Event::Start(announce)) => announce.route.cost(), other => panic!("expected the first route, got {other:?}"), }; let mut pending = Box::pin(remote.track("catalog.json").unwrap().subscribe(None)); @@ -55,8 +55,8 @@ async fn acquisition(version: &str, carries_instance: bool) { // A replacement under a minted instance restarts the advertisement; a carried one only // updates it. let new_cost = match announced.next().await { - Some(moq_net::announce::Event::Update(announce)) if carries_instance => announce.route.cost, - Some(moq_net::announce::Event::Restart(announce)) if !carries_instance => announce.route.cost, + Some(moq_net::announce::Event::Update(announce)) if carries_instance => announce.route.cost(), + Some(moq_net::announce::Event::Restart(announce)) if !carries_instance => announce.route.cost(), other => panic!("{version}: unexpected route change {other:?}"), }; assert!(new_cost < old_cost, "the cheaper session wins the route"); diff --git a/rs/moq-net/tests/integration/catalog_churn.rs b/rs/moq-net/tests/integration/catalog_churn.rs index 1df092388e9..2e0f918e5b1 100644 --- a/rs/moq-net/tests/integration/catalog_churn.rs +++ b/rs/moq-net/tests/integration/catalog_churn.rs @@ -279,12 +279,12 @@ async fn execute(version: Version, ops: &[Op]) -> Result<(), Failure> { let relay_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.broadcast().create_track("catalog.json", info).unwrap(); - broadcast - .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) - .unwrap(); + broadcast.announce().unwrap(); let upstream = vec![ link(version, &publisher, &relay_a).await, diff --git a/rs/moq-net/tests/integration/catalog_handover.rs b/rs/moq-net/tests/integration/catalog_handover.rs index 80b6f979c7c..0e9fd55c34f 100644 --- a/rs/moq-net/tests/integration/catalog_handover.rs +++ b/rs/moq-net/tests/integration/catalog_handover.rs @@ -104,11 +104,11 @@ impl Topology { let relay_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); - let track = broadcast.broadcast().create_track("catalog.json", timed()).unwrap(); - broadcast - .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) .unwrap(); + let track = broadcast.broadcast().create_track("catalog.json", timed()).unwrap(); + broadcast.announce().unwrap(); let group = track.append_group().unwrap(); let p_to_a = link(version, &publisher, &relay_a, None).await; diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index fccb5cd9537..6c5f2a07dc9 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -58,7 +58,9 @@ struct Published { /// Announce one track described by `info`. fn publish(info: moq_net::track::Info) -> Published { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("data", info).unwrap(); broadcast.announce().unwrap(); Published { @@ -266,7 +268,9 @@ async fn datagrams_meter_the_bytes_on_the_wire() { for &version in &["moq-lite-07-wip", "moq-lite-06"] { kio::clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut track = broadcast.broadcast().create_track("data", compressed()).unwrap(); broadcast.announce().unwrap(); @@ -374,7 +378,9 @@ async fn ietf_fetch_keeps_the_stored_form() { for version in ["moq-transport-18", "moq-transport-22"] { kio::clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("data", compressed()).unwrap(); let mut group = track.append_group().unwrap(); for index in 0..3 { diff --git a/rs/moq-net/tests/integration/control_stats.rs b/rs/moq-net/tests/integration/control_stats.rs index 90b21310b7a..3a158ae4981 100644 --- a/rs/moq-net/tests/integration/control_stats.rs +++ b/rs/moq-net/tests/integration/control_stats.rs @@ -29,9 +29,12 @@ async fn control_classes_cross_lite_and_ietf_sessions_without_counting_payload() options.client_publish = Some(publisher.consume()); options.server_subscribe = Some(subscriber.clone()); let _pair = connect_mock(options).await; - let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "video", moq_net::track::Info::default().with_timescale(Timescale::MILLI), ) diff --git a/rs/moq-net/tests/integration/datagram.rs b/rs/moq-net/tests/integration/datagram.rs index 6e075a8371f..2a5a9601760 100644 --- a/rs/moq-net/tests/integration/datagram.rs +++ b/rs/moq-net/tests/integration/datagram.rs @@ -44,7 +44,9 @@ async fn connect_datagram_track() -> Fixture { let publisher = produce_origin(1); let consumer_origin = produce_origin(2); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let producer = broadcast.broadcast().create_track("datagrams", timed()).unwrap(); broadcast.announce().unwrap(); @@ -133,7 +135,9 @@ async fn ietf_delivers_datagrams_on(version: &str) { let publisher = produce_origin(1); let consumer_origin = produce_origin(2); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut producer = broadcast.broadcast().create_track("datagrams", timed()).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/dial_split_horizon.rs b/rs/moq-net/tests/integration/dial_split_horizon.rs index a15e2fe5c4a..f5ba1669dc4 100644 --- a/rs/moq-net/tests/integration/dial_split_horizon.rs +++ b/rs/moq-net/tests/integration/dial_split_horizon.rs @@ -147,7 +147,9 @@ async fn split_horizon(version: &str, [publisher_hop, subscriber_hop]: [Hop; 2]) let to_publisher = dial(version, &dialer, &publisher).await; let to_subscriber = dial(version, &dialer, &subscriber).await; - let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", None).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/drained_claim.rs b/rs/moq-net/tests/integration/drained_claim.rs index 720b12dfc3d..f87c986ebef 100644 --- a/rs/moq-net/tests/integration/drained_claim.rs +++ b/rs/moq-net/tests/integration/drained_claim.rs @@ -47,7 +47,7 @@ async fn settle() { /// track carries the worker's name. struct Worker { _claim: Rc, - /// Each output with its track, which would end once its publication drops. + /// Each output with its track, which would end once its route drops. outputs: Rc>>, origin: origin::Producer, } @@ -55,17 +55,22 @@ struct Worker { impl Worker { fn new(hop: u64, name: &'static str) -> Self { let origin = produce_origin(hop); - let claim = Rc::new(origin.route_prefix("pool", moq_net::origin::RouteOptions::default()).unwrap()); + let claim = Rc::new( + origin + .route_prefix("pool", moq_net::origin::RouteOptions::default()) + .unwrap(), + ); let outputs = Rc::new(RefCell::new(Vec::new())); let (handler, served) = (claim.clone(), outputs.clone()); drop(kio::clock::sim::spawn(async move { - while let Ok(request) = handler.requested().await { + while let Some(request) = handler.requested().await { let prepared = request.route(moq_net::origin::RouteOptions::hidden()).unwrap(); let track = prepared.broadcast().create_track("video", timed()).unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, name.as_bytes().to_vec()).unwrap(); group.finish().unwrap(); - served.borrow_mut().push((prepared.announce().unwrap(), track)); + prepared.announce().unwrap(); + served.borrow_mut().push((prepared, track)); } })); Self { @@ -110,7 +115,10 @@ async fn drained_claim(version: &str) { assert_eq!(watch(version, &relay).await, "a", "{version}"); // A closes its output and drains its session, so B wins the path from here on. - a.outputs.borrow().iter().for_each(|(output, _)| output.broadcast().close()); + a.outputs + .borrow() + .iter() + .for_each(|(output, _)| output.broadcast().close()); a_link.server.drain().send(Goaway::new()).unwrap(); // Past the linger, which is as long as the cache window, nothing reads the relay's // front for the path. diff --git a/rs/moq-net/tests/integration/empty_group.rs b/rs/moq-net/tests/integration/empty_group.rs index f85224c173c..ee1836d8084 100644 --- a/rs/moq-net/tests/integration/empty_group.rs +++ b/rs/moq-net/tests/integration/empty_group.rs @@ -31,7 +31,9 @@ async fn an_empty_group_arrives_empty() { let subscriber = produce_origin(2); let _pair = peer(version.parse::().unwrap(), &publisher, &subscriber).await; - let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("data", timed()).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/errored_end.rs b/rs/moq-net/tests/integration/errored_end.rs index 13b04e96804..4c75f86a660 100644 --- a/rs/moq-net/tests/integration/errored_end.rs +++ b/rs/moq-net/tests/integration/errored_end.rs @@ -78,7 +78,9 @@ async fn an_errored_end_keeps_its_history_across_a_hop() { let label = format!("{name} subscribe_first={subscribe_first}"); let version: Version = name.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); let mut track = broadcast.broadcast().create_track("video", info).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/extensions.rs b/rs/moq-net/tests/integration/extensions.rs index 573b61d0bed..53bf3a21e15 100644 --- a/rs/moq-net/tests/integration/extensions.rs +++ b/rs/moq-net/tests/integration/extensions.rs @@ -86,7 +86,9 @@ async fn a_side_that_declines_solicit_takes_unsolicited_announces() { } let pair = connect_mock(options).await; - let broadcast = publisher.route("room/cam", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room/cam", moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); kio::clock::sleep(SETTLE).await; diff --git a/rs/moq-net/tests/integration/fastest_reader.rs b/rs/moq-net/tests/integration/fastest_reader.rs index ff8948d54fc..7e9a792edbc 100644 --- a/rs/moq-net/tests/integration/fastest_reader.rs +++ b/rs/moq-net/tests/integration/fastest_reader.rs @@ -37,9 +37,12 @@ async fn relay(version: &str) -> Relay { let relay = origin(2); let pair = peer(version.parse::().unwrap(), &publisher, &relay).await; - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track("data", track::Info::default().with_timescale(moq_net::Timescale::MILLI)) + .broadcast() + .create_track("data", track::Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/fetch_cancel.rs b/rs/moq-net/tests/integration/fetch_cancel.rs index d8ca375265c..3f444eb3f7f 100644 --- a/rs/moq-net/tests/integration/fetch_cancel.rs +++ b/rs/moq-net/tests/integration/fetch_cancel.rs @@ -172,7 +172,9 @@ async fn a_refetch_within_the_linger_stays_on_the_relay(version: &str) { let relay = produce_origin(2); let _pair = peer(version, &publisher, &relay).await; - let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut dynamic = broadcast.broadcast().requests(); broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; diff --git a/rs/moq-net/tests/integration/fetch_fanout.rs b/rs/moq-net/tests/integration/fetch_fanout.rs index e35e461eb49..f2b33d33c01 100644 --- a/rs/moq-net/tests/integration/fetch_fanout.rs +++ b/rs/moq-net/tests/integration/fetch_fanout.rs @@ -19,8 +19,9 @@ async fn sequential_viewers_share_the_relays_fetched_groups() { for version in ["moq-lite-05", "moq-lite-06", "moq-lite-07-wip"] { let version: Version = version.parse().unwrap(); let publisher = origin(1); - let broadcast = publisher.publish("room", Default::default()).unwrap(); + let broadcast = publisher.route("room", origin::RouteOptions::default()).unwrap(); let track = broadcast + .broadcast() .create_track( "video", track::Info::default().with_timescale(moq_net::Timescale::MILLI), diff --git a/rs/moq-net/tests/integration/fetch_from_feed.rs b/rs/moq-net/tests/integration/fetch_from_feed.rs index 3f371ac5335..704ce43b640 100644 --- a/rs/moq-net/tests/integration/fetch_from_feed.rs +++ b/rs/moq-net/tests/integration/fetch_from_feed.rs @@ -32,9 +32,12 @@ struct Relay { /// A publisher on `version` with group 0 of an untimed track written, and the relay's view of it. async fn relay(version: &str) -> Relay { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut track = broadcast - .broadcast().create_track("video", moq_net::track::Info::default().with_timescale(None)) + .broadcast() + .create_track("video", moq_net::track::Info::default().with_timescale(None)) .unwrap(); broadcast.announce().unwrap(); track.write_frame(None, &b"0"[..]).unwrap(); diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index 7d13130e7d8..e67389f50f4 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -156,7 +156,9 @@ async fn a_subscribe_after_track_status_keeps_timestamps() { for version in ["moq-transport-18", "moq-transport-22"] { kio::clock::timeout(TIMEOUT, async { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); @@ -330,10 +332,7 @@ fn write_group(track: &moq_net::track::Producer, sequence: u64) { } /// Publish a live track of groups `0..groups`, which the publisher keeps writing. -fn publish_live( - origin: &moq_net::origin::Producer, - groups: u64, -) -> (moq_net::origin::Route, moq_net::track::Producer) { +fn publish_live(origin: &moq_net::origin::Producer, groups: u64) -> (moq_net::origin::Route, moq_net::track::Producer) { let broadcast = origin.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/fetch_pipeline.rs b/rs/moq-net/tests/integration/fetch_pipeline.rs index 14e836ed644..e9fe4b4ec13 100644 --- a/rs/moq-net/tests/integration/fetch_pipeline.rs +++ b/rs/moq-net/tests/integration/fetch_pipeline.rs @@ -54,7 +54,9 @@ async fn fetch_ahead( ) { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut dynamic = broadcast.broadcast().requests(); broadcast.announce().unwrap(); @@ -135,7 +137,9 @@ async fn a_refused_info_fails_the_fetch_sent_with_it() { async fn first_fetch(version: &str, relays: u64, rtt: Duration) -> Duration { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); let mut group = track.append_group().unwrap(); diff --git a/rs/moq-net/tests/integration/finished_broadcast_mock.rs b/rs/moq-net/tests/integration/finished_broadcast_mock.rs index 61003b83cd4..2b9ab256db6 100644 --- a/rs/moq-net/tests/integration/finished_broadcast_mock.rs +++ b/rs/moq-net/tests/integration/finished_broadcast_mock.rs @@ -39,7 +39,9 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { /// the subscriber read: the frame payloads and the error it ended with, if any. async fn round(finish_broadcast: bool) -> (Vec>, Option) { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/finite_relay.rs b/rs/moq-net/tests/integration/finite_relay.rs index 2a6129bf4f8..e067519ea02 100644 --- a/rs/moq-net/tests/integration/finite_relay.rs +++ b/rs/moq-net/tests/integration/finite_relay.rs @@ -60,7 +60,9 @@ enum Arrival { async fn round(name: &str, arrival: Arrival) -> (Vec, Result<(), moq_net::Error>) { let version: Version = name.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut track = broadcast.broadcast().create_track("tail", timed()).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/goaway.rs b/rs/moq-net/tests/integration/goaway.rs index b5990b804bd..d0f400b35b5 100644 --- a/rs/moq-net/tests/integration/goaway.rs +++ b/rs/moq-net/tests/integration/goaway.rs @@ -369,11 +369,19 @@ async fn goaway_keeps_new_subscribes(version: Version) { kio::clock::timeout(TEST_TIMEOUT, async { // Server publishes a broadcast with one live track. let pub_origin = produce_origin(Hop::random()); - let broadcast = pub_origin.route("test", moq_net::origin::RouteOptions::hidden()).expect("create broadcast"); + let broadcast = pub_origin + .route("test", moq_net::origin::RouteOptions::hidden()) + .expect("create broadcast"); broadcast.announce().expect("announce"); - let track = broadcast.broadcast().create_track("video", timed()).expect("create track"); + let track = broadcast + .broadcast() + .create_track("video", timed()) + .expect("create track"); // A second track with content ready for the subscribe opened after the GOAWAY. - let audio = broadcast.broadcast().create_track("audio", timed()).expect("create track"); + let audio = broadcast + .broadcast() + .create_track("audio", timed()) + .expect("create track"); let mut audio_group = audio.append_group().expect("append group"); audio_group .write_frame(moq_net::Timestamp::ZERO, b"audio".as_ref()) @@ -483,7 +491,9 @@ async fn goaway_keeps_new_subscribes_moq_transport_22() { async fn goaway_drains_routes(version: Version) { kio::clock::timeout(TEST_TIMEOUT, async { let pub_origin = produce_origin(Hop::random()); - let broadcast = pub_origin.route("test", moq_net::origin::RouteOptions::hidden()).expect("create broadcast"); + let broadcast = pub_origin + .route("test", moq_net::origin::RouteOptions::hidden()) + .expect("create broadcast"); broadcast.announce().expect("announce"); let sub_origin = produce_origin(Hop::random()); @@ -496,7 +506,7 @@ async fn goaway_drains_routes(version: Version) { let sub = sub_origin.consume(); let route = crate::support::announced(&sub, "test").await; assert_ne!( - route.cost, + route.cost(), moq_net::origin::Cost::DRAIN, "a healthy route must not start out draining" ); @@ -514,7 +524,7 @@ async fn goaway_drains_routes(version: Version) { else { continue; }; - if update.prefix.as_str() == "test" && update.route.cost == moq_net::origin::Cost::DRAIN { + if update.prefix.as_str() == "test" && update.route.cost() == moq_net::origin::Cost::DRAIN { break; } } diff --git a/rs/moq-net/tests/integration/group_order.rs b/rs/moq-net/tests/integration/group_order.rs index 80385ca8b54..7305e7e1b48 100644 --- a/rs/moq-net/tests/integration/group_order.rs +++ b/rs/moq-net/tests/integration/group_order.rs @@ -113,9 +113,12 @@ fn carries_order(version: &str) -> bool { async fn round(version: &str, relay: bool, order: Order) -> Vec { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "ordered", Info::default().with_timescale(Timescale::MILLI).with_max_age(FOREVER), ) @@ -187,9 +190,12 @@ async fn merged_subscribers_keep_their_own_order() { for version in ["moq-lite-07-wip", "moq-transport-18"] { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "ordered", Info::default().with_timescale(Timescale::MILLI).with_max_age(FOREVER), ) diff --git a/rs/moq-net/tests/integration/history_groups.rs b/rs/moq-net/tests/integration/history_groups.rs index 0039ea57f6e..7a322c0c52a 100644 --- a/rs/moq-net/tests/integration/history_groups.rs +++ b/rs/moq-net/tests/integration/history_groups.rs @@ -42,9 +42,12 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { async fn round(version: &str, relay: bool, newest_first: bool) -> Vec<(u64, usize)> { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "history", Info::default().with_timescale(Timescale::MILLI).with_max_age(FOREVER), ) @@ -200,9 +203,12 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { // Older drafts canonicalize group 0 to the live edge instead of replay. let version: Version = "moq-lite-07-wip".parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "history", Info::default().with_timescale(Timescale::MILLI).with_max_age(FOREVER), ) diff --git a/rs/moq-net/tests/integration/idle_cancel_refetch.rs b/rs/moq-net/tests/integration/idle_cancel_refetch.rs index 73c3273a670..82002647c9a 100644 --- a/rs/moq-net/tests/integration/idle_cancel_refetch.rs +++ b/rs/moq-net/tests/integration/idle_cancel_refetch.rs @@ -21,9 +21,12 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { #[kio::test] async fn a_group_cut_by_an_idle_cancel_is_refetched_whole() { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track("audio", moq_net::track::Info::default().with_timescale(None)) + .broadcast() + .create_track("audio", moq_net::track::Info::default().with_timescale(None)) .unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/instance.rs b/rs/moq-net/tests/integration/instance.rs index 212db8a70f8..6bdaa2c5e63 100644 --- a/rs/moq-net/tests/integration/instance.rs +++ b/rs/moq-net/tests/integration/instance.rs @@ -30,7 +30,7 @@ async fn started(announced: &mut announce::Consumer) -> Instance { .expect("announce hung") .expect("announce ended") { - announce::Event::Start(announce) => announce.route.instance.expect("a delivered route has an instance"), + announce::Event::Start(announce) => announce.route.instance().clone(), other => panic!("expected a start, got {other:?}"), } } @@ -56,7 +56,10 @@ async fn job_reannounced(version: &str) { let relay = produce_origin(2); let instance: Instance = "job".parse().unwrap(); let job = publisher - .route("job", moq_net::origin::RouteOptions::default().with_instance(instance.clone(), 0)) + .route( + "job", + moq_net::origin::RouteOptions::default().with_instance(instance.clone(), 0), + ) .unwrap(); let _session = link(version, &publisher, &relay).await; let mut announced = relay.consume().announced(); diff --git a/rs/moq-net/tests/integration/late_lower_group.rs b/rs/moq-net/tests/integration/late_lower_group.rs index 3e1c8273236..8cbcb365d86 100644 --- a/rs/moq-net/tests/integration/late_lower_group.rs +++ b/rs/moq-net/tests/integration/late_lower_group.rs @@ -83,9 +83,12 @@ async fn read_all(sub: &mut moq_net::track::Subscriber) -> Vec<(u64, usize)> { async fn session(version: &str, relay: bool, start: Option) -> Vec<(u64, usize)> { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "late", Info::default() .with_timescale(moq_net::Timescale::MILLI) @@ -155,9 +158,12 @@ async fn session(version: &str, relay: bool, start: Option) -> Vec<(u64, us async fn in_process(start: Option) -> Vec<(u64, usize)> { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "late", Info::default() .with_timescale(moq_net::Timescale::MILLI) @@ -208,9 +214,12 @@ async fn an_explicit_floor_receives_a_group_created_below_the_first_served_group async fn merged(version: &str) -> (Vec<(u64, usize)>, Vec<(u64, usize)>) { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "late", Info::default() .with_timescale(moq_net::Timescale::MILLI) diff --git a/rs/moq-net/tests/integration/mesh_withdraw.rs b/rs/moq-net/tests/integration/mesh_withdraw.rs index c80a328cd9d..d35449c42a7 100644 --- a/rs/moq-net/tests/integration/mesh_withdraw.rs +++ b/rs/moq-net/tests/integration/mesh_withdraw.rs @@ -9,12 +9,13 @@ use crate::support; -use std::{collections::HashMap, time::Duration}; +use std::time::Duration; use futures::channel::mpsc; -use moq_net::{Hop, Version, announce, cache, origin}; +use moq_net::{Hop, Version, cache, origin}; use support::harness::{MockConnectOptions, MockPair, connect_mock, peer, peer_with_latency}; +use support::{Kind, drain, watch}; fn produce_origin(hop: u64) -> origin::Producer { produce(hop, origin::Config::default().update_hold) @@ -32,48 +33,6 @@ fn produce(hop: u64, hold: Duration) -> origin::Producer { producer } -/// The kind of an [`announce::Event`] for a prefix. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -enum Kind { - Start, - Update, - Restart, - Takeover, - End, -} - -/// Every update per prefix the watcher has seen. Await [`kio::clock::sim::idle`] -/// first, so every link, hold and quarantine in the mesh has settled. -fn drain(watched: &mut mpsc::UnboundedReceiver<(String, Kind)>) -> HashMap> { - let mut updates = HashMap::>::new(); - while let Ok((prefix, kind)) = watched.try_recv() { - updates.entry(prefix).or_default().push(kind); - } - updates -} - -/// Watch `announced` from its own task, the way a session's announce writer does: -/// it runs when woken, between the relays' own tasks, rather than only once the -/// test task is polled again, which would coalesce every intermediate update. -fn watch(mut announced: announce::Consumer) -> mpsc::UnboundedReceiver<(String, Kind)> { - let (tx, rx) = mpsc::unbounded(); - kio::clock::sim::spawn(async move { - while let Some(event) = announced.next().await { - let (kind, announce) = match event { - announce::Event::Start(announce) => (Kind::Start, announce), - announce::Event::Update(announce) => (Kind::Update, announce), - announce::Event::Restart(announce) => (Kind::Restart, announce), - announce::Event::Takeover { announce, .. } => (Kind::Takeover, announce), - announce::Event::End(announce) => (Kind::End, announce), - }; - if tx.unbounded_send((announce.prefix.to_string(), kind)).is_err() { - break; - } - } - }); - rx -} - /// `n` relays meshed over `edges`, watched from the last one. struct Mesh { nodes: Vec, @@ -226,7 +185,9 @@ async fn partial_mesh_withdraw_retracts_once() { let mut watched: Vec<_> = nodes.iter().map(|node| watch(node.consume().announced())).collect(); for publisher in [5, 13, 22, 26, 32] { - let broadcast = nodes[publisher].route(format!("room/{publisher}"), moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = nodes[publisher] + .route(format!("room/{publisher}"), moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); kio::clock::sim::idle().await; for (relay, watched) in watched.iter_mut().enumerate() { @@ -280,7 +241,9 @@ async fn retracted_relay_ignores_a_stale_path() { } let mut watched: Vec<_> = nodes.iter().map(|node| watch(node.consume().announced())).collect(); - let broadcast = nodes[7].route("room/7", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = nodes[7] + .route("room/7", moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); kio::clock::sim::idle().await; for watched in watched.iter_mut() { @@ -363,7 +326,10 @@ impl Cluster { /// Publish `path` from the client and require everyone to see it. Returns /// what the watching client saw. async fn publish(&mut self, path: &str) -> (moq_net::origin::Route, Vec) { - let broadcast = self.publisher.route(path, moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = self + .publisher + .route(path, moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); kio::clock::sim::idle().await; let client = drain(&mut self.client).remove(path).unwrap(); @@ -474,7 +440,9 @@ async fn late_better_path(mesh: &str, client: &str) -> (Vec, Vec) { kio::clock::sim::idle().await; assert!(drain(&mut watcher).is_empty()); - let broadcast = publishing.route("room/a", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publishing + .route("room/a", moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); kio::clock::sim::idle().await; let published = drain(&mut watcher).remove("room/a").unwrap(); @@ -685,129 +653,3 @@ async fn withdrawal_counts(capped: bool) -> (usize, usize, usize) { } (hunted, revived, extra) } - -/// A permissive source sends an over-limit path to prove ingress refusal; an -/// accepted boundary path then proves egress counts the relay's own stamp. -#[kio::test] -async fn hop_limit_bounds_receive_and_send() { - for name in [ - "moq-lite-03", - "moq-lite-04", - "moq-lite-05", - "moq-lite-06", - "moq-lite-07-wip", - "moq-transport-18", - "moq-transport-22", - ] { - let version = name.parse().unwrap(); - let source = produce_origin(1); - let mut config = origin::Config::new(Hop::new(2).unwrap()); - config.max_hops = origin::HopLimit::new(2).unwrap(); - config.pool = cache::Pool::unbounded(); - let (relay, driver) = origin::Producer::new(config); - support::harness::spawn(driver); - let sink = produce_origin(3); - let _upstream = peer(version, &source, &relay).await; - let _downstream = peer(version, &relay, &sink).await; - let mut received = watch(relay.consume().announced()); - let mut sent = watch(sink.consume().announced()); - kio::clock::sim::idle().await; - let route = |count: u64| { - origin::RouteInfo::default().with_hops( - moq_net::Hops::try_from((100..100 + count).map(|id| Hop::new(id).unwrap()).collect::>()) - .unwrap(), - ) - }; - let _long = source.publish("long", route(2)).unwrap(); - let _boundary = source.publish("boundary", route(1)).unwrap(); - let short = source.publish("short", route(0)).unwrap(); - kio::clock::sim::idle().await; - let received = drain(&mut received); - assert!(!received.contains_key("long"), "{name}: accepted over-limit path"); - assert!(received.contains_key("boundary"), "{name}: refused boundary path"); - assert!(received.contains_key("short"), "{name}: refused short path"); - let sent_initial = drain(&mut sent); - assert_eq!(sent_initial.len(), 1, "{name}: {sent_initial:?}"); - assert!(sent_initial.contains_key("short"), "{name}: forwarded over-limit path"); - - if matches!(name, "moq-lite-03" | "moq-lite-04") { - // These wires have no route metadata update: withdraw, then replace it. - drop(short); - kio::clock::sim::idle().await; - assert_eq!( - drain(&mut sent).get("short").and_then(|kinds| kinds.last()), - Some(&Kind::End), - "{name}" - ); - let _replacement = source.publish("short", route(1)).unwrap(); - kio::clock::sim::idle().await; - assert!(drain(&mut sent).is_empty(), "{name}: forwarded over-limit replacement"); - continue; - } - short.announce(route(1)).unwrap(); - kio::clock::sim::idle().await; - let ended = drain(&mut sent); - assert_eq!( - ended.get("short").and_then(|kinds| kinds.last()), - Some(&Kind::End), - "{name}: {ended:?}" - ); - } -} - -/// A cheaper route at the cap wins locally but cannot be forwarded, so the relay -/// advertises the pricier in-cap route instead of withdrawing the prefix, and -/// withdraws only once no in-cap route is left. -#[kio::test] -async fn hop_limit_falls_back_to_a_forwardable_route() { - // Only wires carrying a route cost can rank a longer route first. - for name in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { - let version = name.parse().unwrap(); - let near = produce_origin(1); - let far = produce_origin(4); - let mut config = origin::Config::new(Hop::new(2).unwrap()); - config.max_hops = origin::HopLimit::new(3).unwrap(); - config.pool = cache::Pool::unbounded(); - let (relay, driver) = origin::Producer::new(config); - support::harness::spawn(driver); - let sink = produce_origin(3); - let _near = peer(version, &near, &relay).await; - let _far = peer(version, &far, &relay).await; - let _downstream = peer(version, &relay, &sink).await; - let mut sent = watch(sink.consume().announced()); - kio::clock::sim::idle().await; - - let route = |first: u64, count: u64, cost: u64| { - origin::RouteInfo::default() - .with_hops( - moq_net::Hops::try_from( - (first..first + count) - .map(|id| Hop::new(id).unwrap()) - .collect::>(), - ) - .unwrap(), - ) - .with_cost(origin::Cost::new(cost)) - }; - // Three hops at the relay once the sender is appended: in the cap, but full. - let _cheap = far.publish("room", route(100, 2, 1)).unwrap(); - // Two hops at the relay, so it has room for the relay's own. - let pricey = near.publish("room", route(200, 1, 50)).unwrap(); - kio::clock::sim::idle().await; - let started = drain(&mut sent); - assert_eq!( - started.get("room").and_then(|kinds| kinds.last()), - Some(&Kind::Start), - "{name}: withdrew a prefix an in-cap route reaches: {started:?}" - ); - - drop(pricey); - kio::clock::sim::idle().await; - let ended = drain(&mut sent); - assert_eq!( - ended.get("room").and_then(|kinds| kinds.last()), - Some(&Kind::End), - "{name}: forwarded a route at the cap: {ended:?}" - ); - } -} diff --git a/rs/moq-net/tests/integration/model.rs b/rs/moq-net/tests/integration/model.rs index 41e2af15e47..ef66b70313d 100644 --- a/rs/moq-net/tests/integration/model.rs +++ b/rs/moq-net/tests/integration/model.rs @@ -16,9 +16,12 @@ fn origin_front_serves_media_with_only_explicit_polls() { let waiter = kio::Waiter::noop(); let (origin, mut driver) = origin::Producer::new(origin::Config::new(Hop::new(1).unwrap())); driver.poll(now, &waiter).unwrap(); - let broadcast = origin.route("room/live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = origin + .route("room/live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "video", track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) @@ -44,7 +47,10 @@ fn origin_front_serves_media_with_only_explicit_polls() { // Driver teardown also works without any executor-owned tasks. drop(driver); - assert!(matches!(origin.route("after-close", moq_net::origin::RouteOptions::hidden()), Err(Error::Closed))); + assert!(matches!( + origin.route("after-close", moq_net::origin::RouteOptions::hidden()), + Err(Error::Closed) + )); } #[test] @@ -57,7 +63,9 @@ fn follow_resolves_with_only_explicit_polls() { // 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.route("room/live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = origin + .route("room/live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); assert!(following.poll_available(&waiter).is_pending()); // Announcing starts the path, so the next poll asks and the driver serves it. diff --git a/rs/moq-net/tests/integration/multi_cdn.rs b/rs/moq-net/tests/integration/multi_cdn.rs index 4282557e405..0973425d869 100644 --- a/rs/moq-net/tests/integration/multi_cdn.rs +++ b/rs/moq-net/tests/integration/multi_cdn.rs @@ -135,7 +135,7 @@ fn via_a(announce: &announce::Event) -> bool { | announce::Event::Takeover { announce: a, .. } => &a.route, announce::Event::End(_) => return false, }; - route.hops.iter().any(|hop| *hop == Hop::new(A).unwrap()) + route.hops().iter().any(|hop| *hop == Hop::new(A).unwrap()) } struct Topology { @@ -161,11 +161,11 @@ impl Topology { let cdn_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); - let track = broadcast.broadcast().create_track("video", timed()).unwrap(); - broadcast - .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) .unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let pushes = vec![ push(lite, &publisher, &cdn_a).await, diff --git a/rs/moq-net/tests/integration/partial_group.rs b/rs/moq-net/tests/integration/partial_group.rs index a09264eba82..3d704c88d33 100644 --- a/rs/moq-net/tests/integration/partial_group.rs +++ b/rs/moq-net/tests/integration/partial_group.rs @@ -34,9 +34,12 @@ async fn round(version: &str) -> Option, moq_net::Error>> { let downstream = produce_origin(2); let _pair = peer(version.parse::().unwrap(), &publisher, &downstream).await; - let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track("data", Info::default().with_timescale(Timescale::MILLI)) + .broadcast() + .create_track("data", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index bd801a51b4f..a5cbfb357bc 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -45,9 +45,12 @@ fn millis(ms: u64) -> Timestamp { /// over one session on it. async fn read(version: Option<&str>, range: Range) -> Result, Error> { let publisher = produce_origin(1); - let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "data", Info::default().with_timescale(Timescale::MILLI).with_max_age(FOREVER), ) diff --git a/rs/moq-net/tests/integration/range_read.rs b/rs/moq-net/tests/integration/range_read.rs index 5d6ba7bd57f..c6f719b2c08 100644 --- a/rs/moq-net/tests/integration/range_read.rs +++ b/rs/moq-net/tests/integration/range_read.rs @@ -63,9 +63,12 @@ async fn fixture( relay: bool, ) -> (moq_net::broadcast::Consumer, moq_net::track::Producer, impl Sized) { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "video", moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) diff --git a/rs/moq-net/tests/integration/received_rewind.rs b/rs/moq-net/tests/integration/received_rewind.rs index 1b05ca174bc..afda0f16c5b 100644 --- a/rs/moq-net/tests/integration/received_rewind.rs +++ b/rs/moq-net/tests/integration/received_rewind.rs @@ -53,9 +53,12 @@ async fn relay( timescale: Option, ) -> (Option, Vec) { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track("data", Info::default().with_timescale(timescale)) + .broadcast() + .create_track("data", Info::default().with_timescale(timescale)) .unwrap(); broadcast.announce().unwrap(); @@ -176,7 +179,9 @@ async fn a_timed_track_keeps_its_timestamps_through_a_relay() { /// timestamp. async fn fetch_only(version: &str) -> Vec, moq_net::Error>> { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("data", Info::default()).unwrap(); broadcast.announce().unwrap(); write_group(&track, 0); diff --git a/rs/moq-net/tests/integration/rejoin.rs b/rs/moq-net/tests/integration/rejoin.rs index 73fcf1f0638..a7a5b79560f 100644 --- a/rs/moq-net/tests/integration/rejoin.rs +++ b/rs/moq-net/tests/integration/rejoin.rs @@ -45,7 +45,9 @@ async fn rejoin_recovers_the_group_reset_on_leave() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); @@ -139,7 +141,9 @@ async fn rejoin_skips_a_cache_kept_by_another_handle() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); @@ -197,7 +201,9 @@ async fn rejoin_keeps_the_cache_when_the_backlog_lands_newest_first() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); @@ -271,7 +277,9 @@ async fn rejoin_mid_group_keeps_the_head_for_later_readers() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); // Left open, as a JSON snapshot group stays open for its deltas. @@ -343,7 +351,9 @@ async fn rejoin_goes_live_without_the_join_head() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); let mut open = track.append_group().unwrap(); @@ -412,7 +422,9 @@ async fn rejoin_during_the_cancel_skips_the_cache() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); @@ -475,7 +487,9 @@ async fn rejoin_waits_for_the_answers_first_frame() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); @@ -547,7 +561,9 @@ async fn leaving_after_the_cache_window_keeps_the_latest_group() { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("catalog", timed()).unwrap(); broadcast.announce().unwrap(); let mut group = track.append_group().unwrap(); @@ -621,7 +637,9 @@ async fn rejoin_keeps_source_timestamps() { let publisher = produce_origin(1); let client = produce_origin(2); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); @@ -705,11 +723,11 @@ async fn quiet_catalog_survives_cache_expiry(version: Version, takeover: bool) { kio::clock::timeout(TEST_TIMEOUT + moq_net::cache::DEFAULT_EXPIRY * 5, async { let publisher = produce_origin(1); let relay = produce_origin(2); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); - let track = broadcast.broadcast().create_track("catalog", timed()).unwrap(); - broadcast - .announce(moq_net::origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) .unwrap(); + let track = broadcast.broadcast().create_track("catalog", timed()).unwrap(); + broadcast.announce().unwrap(); let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"catalog".as_ref()).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-net/tests/integration/relay_upstream_close.rs b/rs/moq-net/tests/integration/relay_upstream_close.rs index 55443ce4a48..207390a2e90 100644 --- a/rs/moq-net/tests/integration/relay_upstream_close.rs +++ b/rs/moq-net/tests/integration/relay_upstream_close.rs @@ -90,11 +90,14 @@ async fn read(mut sub: moq_net::track::Subscriber) -> Outcome { async fn round(name: &str, end: End) -> Vec { let version: Version = name.parse().unwrap(); let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let tracks: Vec<_> = (0..TRACKS) .map(|index| { broadcast - .broadcast().create_track(format!("track{index}").as_str(), timed()) + .broadcast() + .create_track(format!("track{index}").as_str(), timed()) .unwrap() }) .collect(); diff --git a/rs/moq-net/tests/integration/replacement.rs b/rs/moq-net/tests/integration/replacement.rs index eaf29e31857..8d0a8ff3f36 100644 --- a/rs/moq-net/tests/integration/replacement.rs +++ b/rs/moq-net/tests/integration/replacement.rs @@ -82,19 +82,21 @@ async fn replace(version: &str, instance: Option) { let publisher = produce_origin(1); let viewer = produce_origin(3); - let mut route = origin::RouteInfo::default(); - route.instance = instance.clone(); - let cam = publisher.publish("cam", route).unwrap(); - let video = cam.create_track("video", timed()).unwrap(); - let audio = cam.create_track("audio", timed()).unwrap(); - let meta = cam.create_track("meta", timed()).unwrap(); + let options = match &instance { + Some(instance) => origin::RouteOptions::default().with_instance(instance.clone(), 0), + None => origin::RouteOptions::default(), + }; + let cam = publisher.route("cam", options).unwrap(); + let video = cam.broadcast().create_track("video", timed()).unwrap(); + let audio = cam.broadcast().create_track("audio", timed()).unwrap(); + let meta = cam.broadcast().create_track("meta", timed()).unwrap(); let _first = link(version, &publisher, &viewer).await; let mut announced = viewer.consume().announced(); match next_event(&mut announced).await { announce::Event::Start(announce) => { assert_eq!(announce.prefix.as_str(), "cam"); - let carried = announce.route.instance.as_ref().expect("every route has an instance"); + let carried = announce.route.instance(); assert_eq!(carried.is_minted(), !carries, "{version}: minted {carried}"); if carries && let Some(instance) = &instance { assert_eq!(carried, instance, "{version}: carried instance"); @@ -157,7 +159,7 @@ async fn minted_lite06() { .expect("timed out"); } -/// lite-07 carries the instance the publication minted, or the stable one it names. +/// lite-07 carries the instance the route minted, or the stable one it names. #[kio::test] async fn carried_lite07() { for instance in [None, Some("cam".parse().unwrap())] { @@ -190,7 +192,9 @@ async fn route_death(version: &str, relayed: bool, wait: Duration) { let relay = produce_origin(2); let viewer = produce_origin(3); - let cam = publisher.route("cam", moq_net::origin::RouteOptions::default()).unwrap(); + let cam = publisher + .route("cam", moq_net::origin::RouteOptions::default()) + .unwrap(); let video = cam.broadcast().create_track("video", timed()).unwrap(); let upstream = if relayed { &relay } else { &viewer }; diff --git a/rs/moq-net/tests/integration/route_change.rs b/rs/moq-net/tests/integration/route_change.rs index dc88167c129..b36b5c80640 100644 --- a/rs/moq-net/tests/integration/route_change.rs +++ b/rs/moq-net/tests/integration/route_change.rs @@ -118,11 +118,11 @@ impl Topology { let relay_b = produce_origin(3); let subscriber = produce_origin(4); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); - let track = broadcast.broadcast().create_track("video", timed()).unwrap(); - broadcast - .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) .unwrap(); + let track = broadcast.broadcast().create_track("video", timed()).unwrap(); + broadcast.announce().unwrap(); let p_to_a = link(version, &publisher, &relay_a).await; let p_to_b = link(version, &publisher, &relay_b).await; @@ -387,14 +387,15 @@ async fn route_dies_across_instances(version: &str, trigger: Trigger) { let relay_b = produce_origin(4); let relay = produce_origin(5); let downstream = produce_origin(6); - let broadcast_a = publisher_a.route("live", moq_net::origin::RouteOptions::default()).unwrap(); - let broadcast_b = publisher_b.route("live", moq_net::origin::RouteOptions::default()).unwrap(); + let broadcast_a = publisher_a + .route("live", moq_net::origin::RouteOptions::default()) + .unwrap(); + let broadcast_b = publisher_b + .route("live", moq_net::origin::RouteOptions::default()) + .unwrap(); let track_a = broadcast_a.broadcast().create_track("video", timed()).unwrap(); let track_b = broadcast_b.broadcast().create_track("video", timed()).unwrap(); - assert_ne!( - broadcast_a.route().unwrap().instance, - broadcast_b.route().unwrap().instance - ); + assert_ne!(broadcast_a.instance(), broadcast_b.instance()); let p_to_a = link(version, &publisher_a, &relay_a).await; let _p_to_b = link(version, &publisher_b, &relay_b).await; @@ -441,8 +442,8 @@ async fn route_dies_across_instances(version: &str, trigger: Trigger) { announce::Event::Restart(announce) => { assert_eq!(announce.prefix.as_str(), "live"); assert_eq!( - announce.route.instance, - broadcast_b.route().unwrap().instance, + announce.route.instance(), + &broadcast_b.instance(), "{version} {trigger:?}: restarted onto the wrong instance" ); } @@ -496,7 +497,7 @@ async fn better_route_restarts(version: &str) { match announced.next().await.expect("announced") { announce::Event::Restart(announce) => { assert_eq!(announce.prefix.as_str(), "live"); - assert_eq!(announce.route.hops.len(), 1, "{version}: the direct route"); + assert_eq!(announce.route.hops().len(), 1, "{version}: the direct route"); } other => panic!("{version}: expected a restart, got {other:?}"), } @@ -678,9 +679,7 @@ async fn lagging_route_dies(version: Version) { ); let broadcast = p.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); - broadcast - .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) - .unwrap(); + broadcast.announce().unwrap(); let p_a = lagged(version, &p, &a, Duration::from_millis(300)).await; let p_b = lagged(version, &p, &b, Duration::ZERO).await; let a_r = lagged(version, &a, &r, Duration::ZERO).await; @@ -767,9 +766,7 @@ async fn undetected_outage(budget: Duration) -> BTreeMap> { ); let broadcast = p.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); - broadcast - .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) - .unwrap(); + broadcast.announce().unwrap(); let p_o = link(version, &p, &o).await; let o_m1 = link(version, &o, &m1).await; let o_m2 = link(version, &o, &m2).await; @@ -902,9 +899,11 @@ async fn redundant_pair_follows_the_next_instance(version: &str, loss: Loss) { let mut replicas = Vec::new(); for (name, hop, cost) in [("P1", 1, 1), ("P2", 2, 5)] { let publisher = produce_origin(hop); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", origin::RouteOptions::hidden().with_cost(cost)) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); - broadcast.announce(origin::RouteInfo::default().with_cost(cost)).unwrap(); + broadcast.announce().unwrap(); let link = link(version, &publisher, &subscriber).await; replicas.push(Replica { name, @@ -1015,7 +1014,9 @@ async fn replaced_behind_a_relay(version: &str) { let mut replicas = Vec::new(); for (name, hop, cost) in [("P1", 1, None), ("P2", 2, Some(1_000))] { let publisher = produce_origin(hop); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); let link = priced_link(version, &publisher, &relay, cost).await; @@ -1108,13 +1109,17 @@ async fn compression_changes_behind_a_relay(compress: bool) { let mut replicas = Vec::new(); for (name, hop, cost, compress) in [("P1", 1, None, true), ("P2", 2, Some(1_000), compress)] { let publisher = produce_origin(hop); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); - let track = broadcast - .broadcast().create_track("video", timed().with_compress(compress)) + let broadcast = publisher + .route( + "live", + origin::RouteOptions::hidden().with_instance(instance.clone(), 0), + ) .unwrap(); - broadcast - .announce(origin::RouteInfo::default().with_instance(instance.clone(), 0)) + let track = broadcast + .broadcast() + .create_track("video", timed().with_compress(compress)) .unwrap(); + broadcast.announce().unwrap(); let link = priced_link(version, &publisher, &relay, cost).await; replicas.push(Replica { name, @@ -1204,11 +1209,11 @@ async fn producer_replaced(version: &str) { let relay = produce_origin(2); let subscriber = produce_origin(3); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); - let mut dynamic = broadcast.broadcast().requests(); - broadcast - .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) .unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let (tx, mut producers) = mpsc::unbounded(); kio::clock::sim::spawn(async move { while let Ok(request) = dynamic.requested_track().await { diff --git a/rs/moq-net/tests/integration/route_health.rs b/rs/moq-net/tests/integration/route_health.rs index 0cd8f8e365a..fe914935e85 100644 --- a/rs/moq-net/tests/integration/route_health.rs +++ b/rs/moq-net/tests/integration/route_health.rs @@ -56,9 +56,7 @@ async fn silent_kill(budget: Duration, detect: Duration) -> Vec { ); let broadcast = p.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); - broadcast - .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) - .unwrap(); + broadcast.announce().unwrap(); let p_o = link(version, &p, &o).await; let o_m1 = link(version, &o, &m1).await; let o_m2 = link(version, &o, &m2).await; @@ -193,9 +191,7 @@ async fn payload_stall(stall: Stall, span: Duration) -> (Observed, Observed) { ); let broadcast = p.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); - broadcast - .announce(origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) - .unwrap(); + broadcast.announce().unwrap(); let p_o = link(version, &p, &o).await; let o_m1 = link(version, &o, &m1).await; let o_m2 = link(version, &o, &m2).await; diff --git a/rs/moq-net/tests/integration/segmented_frame.rs b/rs/moq-net/tests/integration/segmented_frame.rs index a0f15880d18..260cdbec1db 100644 --- a/rs/moq-net/tests/integration/segmented_frame.rs +++ b/rs/moq-net/tests/integration/segmented_frame.rs @@ -30,7 +30,9 @@ async fn a_segmented_frame_crosses_whole() { let version: Version = version.parse().unwrap(); let publisher = origin(1); let viewer = origin(2); - let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.broadcast().create_track("file", info).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/session_close.rs b/rs/moq-net/tests/integration/session_close.rs index ba759b6fb09..8699c6e86f3 100644 --- a/rs/moq-net/tests/integration/session_close.rs +++ b/rs/moq-net/tests/integration/session_close.rs @@ -42,7 +42,9 @@ async fn setup(version: &str) -> Setup { async fn setup_with_gate(version: &str, gate: Option>) -> Setup { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); @@ -104,7 +106,9 @@ async fn setup_with_gate(version: &str, gate: Option>) -> Se async fn track_info_interest_precedes_a_subscription() { for version in ["moq-lite-05", "moq-lite-06", "moq-lite-07-wip"] { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); let subscriber = produce_origin(2); @@ -226,7 +230,9 @@ async fn abort_cuts_a_drain_short_for(version: &str) { async fn close_withdraws_announcements_before_closing_the_transport() { for version in ["moq-lite-01", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse().unwrap()); @@ -247,7 +253,9 @@ async fn close_withdraws_announcements_before_closing_the_transport() { async fn close_times_out_waiting_for_announcement_acknowledgements() { for version in ["moq-lite-01", "moq-lite-07-wip", "moq-transport-18", "moq-transport-22"] { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse().unwrap()); diff --git a/rs/moq-net/tests/integration/session_idle.rs b/rs/moq-net/tests/integration/session_idle.rs index 99768f0e44a..a7f6cf0e765 100644 --- a/rs/moq-net/tests/integration/session_idle.rs +++ b/rs/moq-net/tests/integration/session_idle.rs @@ -39,7 +39,9 @@ struct Setup { async fn setup(version: &str) -> Setup { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/session_panic.rs b/rs/moq-net/tests/integration/session_panic.rs index cc12ac8e01b..c1b6c44400b 100644 --- a/rs/moq-net/tests/integration/session_panic.rs +++ b/rs/moq-net/tests/integration/session_panic.rs @@ -125,7 +125,10 @@ async fn a_panicking_session_leaves_the_others_serving() { .unwrap_or_else(|_| panic!("{version}: the panicked session never closed")); // The other session still serves: a fresh announcement reaches the relay. - let later = healthy.origin.route("later", moq_net::origin::RouteOptions::hidden()).unwrap(); + let later = healthy + .origin + .route("later", moq_net::origin::RouteOptions::hidden()) + .unwrap(); later.announce().unwrap(); until(&mut announced, "later", true).await; crate::support::announced(&relay.consume(), "healthy").await; diff --git a/rs/moq-net/tests/integration/slow_joiner.rs b/rs/moq-net/tests/integration/slow_joiner.rs index 97788bb01d2..651b6e03778 100644 --- a/rs/moq-net/tests/integration/slow_joiner.rs +++ b/rs/moq-net/tests/integration/slow_joiner.rs @@ -30,9 +30,12 @@ async fn stalled_read(version: Version, budget: Duration) -> BTreeSet { let publisher = origin(1); let relay = origin(2); let viewer = origin(3); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let source = broadcast - .broadcast().create_track("audio", track::Info::default().with_timescale(Timescale::MILLI)) + .broadcast() + .create_track("audio", track::Info::default().with_timescale(Timescale::MILLI)) .unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/source_errors.rs b/rs/moq-net/tests/integration/source_errors.rs index 2a754a54fde..0865d93313f 100644 --- a/rs/moq-net/tests/integration/source_errors.rs +++ b/rs/moq-net/tests/integration/source_errors.rs @@ -51,7 +51,9 @@ async fn relayed(version: &str) -> Relayed { let publisher = produce_origin(1); let relay = produce_origin(2); let far = produce_origin(3); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index f997031c2c7..2731c7a9c99 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -20,10 +20,17 @@ async fn one_stream_credit_serves_every_backlogged_group() { let version: Version = version.parse().unwrap(); let publisher = origin(1); let viewer = origin(2); - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let info = track::Info::default().with_timescale(moq_net::Timescale::MILLI); let tracks: Vec<_> = (0..2) - .map(|i| broadcast.broadcast().create_track(format!("{i}"), info.clone()).unwrap()) + .map(|i| { + broadcast + .broadcast() + .create_track(format!("{i}"), info.clone()) + .unwrap() + }) .collect(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/subscribe_priority.rs b/rs/moq-net/tests/integration/subscribe_priority.rs index 9d0a14c7978..3710f28014a 100644 --- a/rs/moq-net/tests/integration/subscribe_priority.rs +++ b/rs/moq-net/tests/integration/subscribe_priority.rs @@ -48,9 +48,12 @@ async fn priority(track: &moq_net::track::Producer, want: i8) -> Result<(), Stri /// publisher sees the priority rise and fall back. async fn follows(version: Version, relay: bool) -> Result<(), String> { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track("video", Info::default().with_timescale(Timescale::MILLI)) + .broadcast() + .create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index 08636013b44..21a24f03462 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -61,9 +61,12 @@ async fn subscribe(remote: &moq_net::broadcast::Consumer, subscription: Subscrip /// one joins. async fn ahead_then_live(version: Option<&str>, relay: bool) -> (Vec, Vec) { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) + .broadcast() + .create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); broadcast.announce().unwrap(); for sequence in 0..=3 { @@ -126,9 +129,12 @@ async fn sparse_ranges_reach_the_publisher_on_lite07() { let sparse = [Range::groups(0..1), Range::groups(3..4)]; for version in LITE { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) + .broadcast() + .create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); broadcast.announce().unwrap(); @@ -210,9 +216,12 @@ async fn range_fixture_version(version: &str, relay: bool) -> RangeFixture { async fn range_fixture_history(version: &str, relay: bool, history: u64) -> RangeFixture { let publisher = produce_origin(1); - let broadcast = publisher.route("ranges", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("ranges", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) + .broadcast() + .create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); broadcast.announce().unwrap(); for sequence in 0..history { @@ -745,9 +754,12 @@ async fn unresolved_time_reader_never_changes_sibling_demand() { async fn a_covered_bounded_subscription_stays_open() { for version in LITE { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast - .broadcast().create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) + .broadcast() + .create_track("quiet", Info::default().with_timescale(moq_net::Timescale::MILLI)) .unwrap(); broadcast.announce().unwrap(); for sequence in [0, 1, 2, 4, 5] { diff --git a/rs/moq-net/tests/integration/subscribe_tracks.rs b/rs/moq-net/tests/integration/subscribe_tracks.rs index d9745dcc83c..5461c419ed0 100644 --- a/rs/moq-net/tests/integration/subscribe_tracks.rs +++ b/rs/moq-net/tests/integration/subscribe_tracks.rs @@ -49,7 +49,9 @@ struct Setup { async fn setup(version: Version) -> Setup { let publisher = produce_origin(1); - let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/subscribe_with_track.rs b/rs/moq-net/tests/integration/subscribe_with_track.rs index b323c7e48a6..8f14f39a2de 100644 --- a/rs/moq-net/tests/integration/subscribe_with_track.rs +++ b/rs/moq-net/tests/integration/subscribe_with_track.rs @@ -68,7 +68,8 @@ async fn first_frame(version: &str, relays: usize, arrival: Arrival) -> Duration let broadcast = nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "video", moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) diff --git a/rs/moq-net/tests/integration/subscriber_max_age.rs b/rs/moq-net/tests/integration/subscriber_max_age.rs index 22595847dc8..749841fa452 100644 --- a/rs/moq-net/tests/integration/subscriber_max_age.rs +++ b/rs/moq-net/tests/integration/subscriber_max_age.rs @@ -39,9 +39,12 @@ async fn relay_forwards_the_most_tolerant_subscriber_max_age() { let viewer = origin(3); let _upstream = peer(version, &publisher, &relay).await; let _downstream = peer(version, &relay, &viewer).await; - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut source = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "catalog", track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) @@ -105,9 +108,12 @@ async fn relay_forwards_the_smallest_stated_min_delay() { let _upstream = peer(lite07, &publisher, &relay).await; let _modern = peer(lite07, &relay, &modern).await; let _legacy = peer(lite06, &relay, &legacy).await; - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut source = broadcast - .broadcast().create_track( + .broadcast() + .create_track( "catalog", track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) diff --git a/rs/moq-net/tests/integration/subscription_end_integrity.rs b/rs/moq-net/tests/integration/subscription_end_integrity.rs index 64d7f41f124..f782305e1d3 100644 --- a/rs/moq-net/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-net/tests/integration/subscription_end_integrity.rs @@ -56,7 +56,9 @@ fn expected() -> Vec> { /// payloads and the error it ended with, if any. async fn round(drop_session: bool) -> (Vec>, Option) { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); @@ -213,7 +215,9 @@ enum Kill { /// `recv_group` and that group end with once it drains what arrived. async fn killed(version: &str, kill: Kill) -> (Option, Option) { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); @@ -318,7 +322,9 @@ async fn a_session_close_cancels_the_track_from_either_side() { /// the error the fetch ends with. async fn fetch_killed(version: &str, kill: Kill) -> moq_net::Error { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut dynamic = broadcast.broadcast().requests(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/support/mod.rs b/rs/moq-net/tests/integration/support/mod.rs index 2848df14f87..43ed09dbfef 100644 --- a/rs/moq-net/tests/integration/support/mod.rs +++ b/rs/moq-net/tests/integration/support/mod.rs @@ -3,6 +3,7 @@ pub mod harness; pub mod mock; +use futures::channel::mpsc; use moq_net::{announce, goaway, origin, track}; /// Wait until anyone wants the track, returning the group they want. @@ -40,6 +41,51 @@ pub async fn announced(consumer: &origin::Consumer, path: &str) -> origin::Route } } +/// The kind of an [`announce::Event`] for a prefix. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[allow(dead_code, reason = "shared by several test binaries, each using only part of it")] +pub enum Kind { + Start, + Update, + Restart, + Takeover, + End, +} + +/// Every update per prefix the watcher has seen. Await [`kio::clock::sim::idle`] +/// first, so every link, hold and quarantine in the mesh has settled. +#[allow(dead_code, reason = "shared by several test binaries, each using only part of it")] +pub fn drain(watched: &mut mpsc::UnboundedReceiver<(String, Kind)>) -> std::collections::HashMap> { + let mut updates = std::collections::HashMap::>::new(); + while let Ok((prefix, kind)) = watched.try_recv() { + updates.entry(prefix).or_default().push(kind); + } + updates +} + +/// Watch `announced` from its own task, the way a session's announce writer does: +/// it runs when woken, between the relays' own tasks, rather than only once the +/// test task is polled again, which would coalesce every intermediate update. +#[allow(dead_code, reason = "shared by several test binaries, each using only part of it")] +pub fn watch(mut announced: announce::Consumer) -> mpsc::UnboundedReceiver<(String, Kind)> { + let (tx, rx) = mpsc::unbounded(); + kio::clock::sim::spawn(async move { + while let Some(event) = announced.next().await { + let (kind, announce) = match event { + announce::Event::Start(announce) => (Kind::Start, announce), + announce::Event::Update(announce) => (Kind::Update, announce), + announce::Event::Restart(announce) => (Kind::Restart, announce), + announce::Event::Takeover { announce, .. } => (Kind::Takeover, announce), + announce::Event::End(announce) => (Kind::End, announce), + }; + if tx.unbounded_send((announce.prefix.to_string(), kind)).is_err() { + break; + } + } + }); + rx +} + /// 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/synced.rs b/rs/moq-net/tests/integration/synced.rs index c2c30b12e2a..322a4dc23b0 100644 --- a/rs/moq-net/tests/integration/synced.rs +++ b/rs/moq-net/tests/integration/synced.rs @@ -133,7 +133,9 @@ async fn a_cold_relay_syncs_then_forwards_upstream_routes_as_live() { assert!(announced.try_next().is_none()); let upstream = produce_origin(1); - let broadcast = upstream.route("room/cam", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = upstream + .route("room/cam", moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(upstream.consume()); 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 3cc41ef6ab1..c0e0758eace 100644 --- a/rs/moq-net/tests/integration/track_abort_over_session.rs +++ b/rs/moq-net/tests/integration/track_abort_over_session.rs @@ -26,7 +26,9 @@ async fn after_abort(version: &str, hops: u32) { let publisher = produce_origin(1); let relay = produce_origin(2); let far = produce_origin(3); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version.parse::().unwrap()); @@ -77,9 +79,7 @@ abort_test!(abort_06_two, "moq-lite-06", 2); async fn recreate(finish: bool) { let origin = produce_origin(1); let broadcast = origin.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); - broadcast - .announce(moq_net::origin::RouteInfo::default().with_instance(moq_net::Instance::random(), 0)) - .unwrap(); + broadcast.announce().unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); let remote = origin.consume().request("bench", None).await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); diff --git a/rs/moq-net/tests/integration/track_info_cancel.rs b/rs/moq-net/tests/integration/track_info_cancel.rs index b804e944df9..175ef066adf 100644 --- a/rs/moq-net/tests/integration/track_info_cancel.rs +++ b/rs/moq-net/tests/integration/track_info_cancel.rs @@ -70,13 +70,13 @@ async fn withdrawn_broadcast_releases_track_info(version: &str, answered: bool, let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); let reader = produce_origin(2); - let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); - let mut dynamic = broadcast.broadcast().requests(); - let mut route = origin::RouteInfo::default(); + let mut options = origin::RouteOptions::hidden(); if explicit { - route.instance = Some("019a1234-5678-7000-8000-000000000001".parse().unwrap()); + options = options.with_instance("019a1234-5678-7000-8000-000000000001".parse().unwrap(), 0); } - broadcast.announce(route).unwrap(); + let broadcast = publisher.route("room", options).unwrap(); + let mut dynamic = broadcast.broadcast().requests(); + broadcast.announce().unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(publisher.consume()); options.client_subscribe = Some(reader.clone()); diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index 23ebc717d78..53a6c51e6fb 100644 --- a/rs/moq-net/tests/integration/track_tail.rs +++ b/rs/moq-net/tests/integration/track_tail.rs @@ -80,7 +80,9 @@ struct Pair { async fn connect(version: &str) -> Pair { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/tracks.rs b/rs/moq-net/tests/integration/tracks.rs index 7b3df076c80..5dc3577fc94 100644 --- a/rs/moq-net/tests/integration/tracks.rs +++ b/rs/moq-net/tests/integration/tracks.rs @@ -64,7 +64,9 @@ async fn resolve(origin: &moq_net::origin::Producer) -> moq_net::broadcast::Cons #[kio::test] async fn a_session_lists_its_peers_tracks() { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let a = broadcast.broadcast().create_track("a", None).unwrap(); broadcast.announce().unwrap(); @@ -94,7 +96,9 @@ async fn a_session_lists_its_peers_tracks() { #[kio::test] async fn a_listing_carries_track_info() { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let info = moq_net::track::Info::default() .with_timescale(moq_net::Timescale::MILLI) .with_max_age(Duration::from_secs(3)) @@ -127,7 +131,9 @@ async fn a_listing_carries_track_info() { #[kio::test] async fn a_listed_track_serves_its_cached_group() { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); broadcast.announce().unwrap(); let (subscriber, _pair) = connect(&publisher, 2, lite07()).await; @@ -160,7 +166,9 @@ async fn a_listed_track_serves_its_cached_group() { #[kio::test] async fn a_relay_shares_its_upstream_listing() { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let a = broadcast.broadcast().create_track("a", None).unwrap(); broadcast.announce().unwrap(); @@ -194,7 +202,9 @@ async fn a_relay_shares_its_upstream_listing() { #[kio::test] async fn lite06_cannot_list() { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let _a = broadcast.broadcast().create_track("a", None).unwrap(); broadcast.announce().unwrap(); @@ -211,7 +221,9 @@ async fn lite06_cannot_list() { #[kio::test] async fn a_listing_past_the_announces_cap_is_reset() { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); const CAP: usize = 10; let _tracks: Vec<_> = (0..CAP) .map(|i| broadcast.broadcast().create_track(format!("t{i}"), None).unwrap()) diff --git a/rs/moq-net/tests/integration/tracks_ietf.rs b/rs/moq-net/tests/integration/tracks_ietf.rs index 078a7986bc3..4d33a7bea00 100644 --- a/rs/moq-net/tests/integration/tracks_ietf.rs +++ b/rs/moq-net/tests/integration/tracks_ietf.rs @@ -98,7 +98,9 @@ async fn read(sub: &mut moq_net::track::Subscriber) -> Option<(u64, Vec)> { async fn a_listing_of_our_own_peer_fails_alone() { for version in DRAFTS { let publisher = produce_origin(1); - let broadcast = publisher.route("bcast", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let video = broadcast.broadcast().create_track("video", None).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/unannounce_release.rs b/rs/moq-net/tests/integration/unannounce_release.rs index f6298b83cd8..4369abed8fd 100644 --- a/rs/moq-net/tests/integration/unannounce_release.rs +++ b/rs/moq-net/tests/integration/unannounce_release.rs @@ -24,7 +24,9 @@ async fn release(version: Version) { options.client_subscribe = Some(relay.clone()); let _pair = connect_mock(options).await; - let broadcast = publisher.route("a/b", moq_net::origin::RouteOptions::default()).unwrap(); + let broadcast = publisher + .route("a/b", moq_net::origin::RouteOptions::default()) + .unwrap(); let track = broadcast.broadcast().create_track("t", None).unwrap(); let consumer = relay.consume(); diff --git a/rs/moq-net/tests/integration/untimed.rs b/rs/moq-net/tests/integration/untimed.rs index 52f39301824..60fa9520a2d 100644 --- a/rs/moq-net/tests/integration/untimed.rs +++ b/rs/moq-net/tests/integration/untimed.rs @@ -110,7 +110,9 @@ async fn next_frame(subscriber: &mut track::Subscriber) -> Option { async fn frame_through(hops: &[&str], info: track::Info) -> (Option, track::Info) { let timestamp = info.timescale.map(|_| millis(7)); let chain = Chain::new(hops).await; - let broadcast = chain.nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = chain.nodes[0] + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut producer = broadcast.broadcast().create_track("data", info).unwrap(); broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; @@ -176,7 +178,9 @@ async fn a_relay_forwards_an_untimed_track_untimed() { async fn an_explicit_start_holds_on_an_untimed_track() { for version in ["moq-lite-03", "moq-lite-06", "moq-lite-07-wip", "moq-transport-22"] { let chain = Chain::new(&[version]).await; - let broadcast = chain.nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = chain.nodes[0] + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut producer = broadcast.broadcast().create_track("data", untimed()).unwrap(); broadcast.announce().unwrap(); for _ in 0..5 { @@ -211,7 +215,9 @@ async fn an_explicit_start_holds_on_an_untimed_track() { async fn datagrams_arrive_as_published() { for version in ["moq-lite-05", "moq-lite-07-wip", "moq-transport-22"] { let chain = Chain::new(&[version]).await; - let broadcast = chain.nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = chain.nodes[0] + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut producer = broadcast.broadcast().create_track("data", untimed()).unwrap(); broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; @@ -238,7 +244,9 @@ async fn datagrams_arrive_as_published() { async fn a_fetched_untimed_frame_arrives_untimed() { for version in ["moq-lite-06", "moq-lite-07-wip", "moq-transport-18"] { let chain = Chain::new(&[version]).await; - let broadcast = chain.nodes[0].route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = chain.nodes[0] + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let mut dynamic = broadcast.broadcast().requests(); broadcast.announce().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; diff --git a/rs/moq-net/tests/integration/warm_backfill.rs b/rs/moq-net/tests/integration/warm_backfill.rs index b98b107373d..38ba67b9dce 100644 --- a/rs/moq-net/tests/integration/warm_backfill.rs +++ b/rs/moq-net/tests/integration/warm_backfill.rs @@ -65,9 +65,12 @@ async fn a_newcomer_on_a_warm_relay_gets_the_backfill() { let publisher = origin(1); let relay = origin(2); let _link = peer(version.parse::().unwrap(), &publisher, &relay).await; - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let source = broadcast - .broadcast().create_track("video", Info::default().with_timescale(Timescale::MILLI)) + .broadcast() + .create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); for sequence in 0..GROUPS { let mut group = source.create_group(moq_net::group::Info { sequence }).unwrap(); @@ -96,9 +99,12 @@ async fn a_refused_transport_backfill_keeps_delivering_live() { let publisher = origin(1); let relay = origin(2); let _link = peer(version.parse::().unwrap(), &publisher, &relay).await; - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let source = broadcast - .broadcast().create_track("video", Info::default().with_timescale(Timescale::MILLI)) + .broadcast() + .create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); for sequence in 0..GROUPS { let mut group = source.create_group(sequence.into()).unwrap(); diff --git a/rs/moq-net/tests/integration/wide_hop.rs b/rs/moq-net/tests/integration/wide_hop.rs index d4d832f1389..d0f4854c536 100644 --- a/rs/moq-net/tests/integration/wide_hop.rs +++ b/rs/moq-net/tests/integration/wide_hop.rs @@ -28,10 +28,12 @@ async fn widest_hop_crosses_each_varint_form() { let upstream: Version = "moq-transport-18".parse().unwrap(); let _upstream = peer(upstream, &source, &relay).await; let _downstream = peer(downstream.parse().unwrap(), &relay, &sink).await; - let _route = source.route_prefix("room", moq_net::origin::RouteOptions::default()).unwrap(); + let _route = source + .route_prefix("room", moq_net::origin::RouteOptions::default()) + .unwrap(); kio::clock::sim::idle().await; - let ids = |route: origin::RouteInfo| route.hops.iter().map(|hop| hop.id()).collect::>(); + let ids = |route: origin::RouteInfo| route.hops().iter().map(|hop| hop.id()).collect::>(); let at_relay = crate::support::announced(&relay.consume(), "room").await; assert_eq!(ids(at_relay), [u64::MAX], "{downstream}"); let at_sink = crate::support::announced(&sink.consume(), "room").await; diff --git a/rs/moq-net/tests/integration/wide_sequence.rs b/rs/moq-net/tests/integration/wide_sequence.rs index d752411303b..ee59b152d4e 100644 --- a/rs/moq-net/tests/integration/wide_sequence.rs +++ b/rs/moq-net/tests/integration/wide_sequence.rs @@ -19,7 +19,9 @@ async fn largest_quic_sequence_reaches_the_subscriber() { let publisher = produce_origin(1); let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.route("ladder", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("ladder", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MICRO); let track = broadcast.broadcast().create_track("data", info).unwrap(); broadcast.announce().unwrap(); @@ -86,7 +88,9 @@ async fn wide_sequence_fails_only_its_subscription() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let wide = broadcast.broadcast().create_track("wide", timed()).unwrap(); let narrow = broadcast.broadcast().create_track("narrow", timed()).unwrap(); broadcast.announce().unwrap(); @@ -146,7 +150,9 @@ async fn a_later_wide_group_fails_only_that_subscription() { let relay = produce_origin(2); let client = produce_origin(3); - let broadcast = publisher.route("bench", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("bench", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let wide = broadcast.broadcast().create_track("wide", timed()).unwrap(); let narrow = broadcast.broadcast().create_track("narrow", timed()).unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/widened_max_age.rs b/rs/moq-net/tests/integration/widened_max_age.rs index 13205aa071d..11b2e869c0f 100644 --- a/rs/moq-net/tests/integration/widened_max_age.rs +++ b/rs/moq-net/tests/integration/widened_max_age.rs @@ -73,9 +73,12 @@ impl Chain { if let Some(relay) = &relay { links.push(peer(version, relay, &viewer).await); } - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let source = broadcast - .broadcast().create_track("video", Info::default().with_timescale(Timescale::MILLI)) + .broadcast() + .create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); broadcast.announce().unwrap(); Self { @@ -299,9 +302,12 @@ async fn wider_newcomers_after_the_first_pull_nothing_upstream() { .tier(moq_net::stats::Tier::new(moq_net::Path::from_static("upstream"))) .session(moq_net::Path::from_static("")); let _upstream = connect_mock(options).await; - let broadcast = publisher.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("live", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let source = broadcast - .broadcast().create_track("video", Info::default().with_timescale(Timescale::MILLI)) + .broadcast() + .create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); for sequence in 0..GROUPS { let mut group = source.create_group(moq_net::group::Info { sequence }).unwrap(); diff --git a/rs/moq-net/tests/integration/zero_copy.rs b/rs/moq-net/tests/integration/zero_copy.rs index d3a287b07f5..1ab304a5f01 100644 --- a/rs/moq-net/tests/integration/zero_copy.rs +++ b/rs/moq-net/tests/integration/zero_copy.rs @@ -54,7 +54,9 @@ async fn frames_cross_without_a_copy() { } ); - let broadcast = publisher.route("room", moq_net::origin::RouteOptions::hidden()).unwrap(); + let broadcast = publisher + .route("room", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.broadcast().create_track("video", info).unwrap(); broadcast.announce().unwrap(); diff --git a/test/audio-quality/clients/js/src/capture.test.ts b/test/audio-quality/clients/js/src/capture.test.ts index 4a3e9901f64..85671d88bdf 100644 --- a/test/audio-quality/clients/js/src/capture.test.ts +++ b/test/audio-quality/clients/js/src/capture.test.ts @@ -74,10 +74,10 @@ test("arrival capture refuses an unsupported container", () => { test("the observer shares playback demand and closes without ending playback", async () => { const origin = new Origin.Producer(); - const publishedPublication = origin.createBroadcast(Path.from("tone.hang")); - const published = publishedPublication.broadcast; + const publishedRoute = origin.route(Path.from("tone.hang"), { hidden: true }); + const published = publishedRoute.broadcast; const track = published.createTrack("audio", { timescale: Time.Timescale.MILLI }); - publishedPublication.announce(); + publishedRoute.announce(); const source = new Broadcast({ origin, name: Path.from("tone.hang"), follow: false, catalogFormat: "manual" }); const capture = new Capture({ broadcast: new Signal(source), @@ -117,10 +117,10 @@ test("at auto the observer asks for the decoder's 2 s budget, not the target", a // A capture cut to the target would drop the frames later than it, which are what the target // is measured from, so a trace recorded that way can never show the player falling short. const origin = new Origin.Producer(); - const publishedPublication = origin.createBroadcast(Path.from("tone.hang")); - const published = publishedPublication.broadcast; + const publishedRoute = origin.route(Path.from("tone.hang"), { hidden: true }); + const published = publishedRoute.broadcast; const track = published.createTrack("audio", { timescale: Time.Timescale.MILLI }); - publishedPublication.announce(); + publishedRoute.announce(); const source = new Broadcast({ origin, name: Path.from("tone.hang"), follow: false, catalogFormat: "manual" }); const capture = new Capture({ broadcast: new Signal(source), @@ -147,10 +147,10 @@ test("at auto the observer asks for the decoder's 2 s budget, not the target", a /** Capture a legacy track, then end its first group with `end` once that group's reader is in flight. */ async function captureGroupEnd(end: (group: Group.Producer) => void): Promise { const origin = new Origin.Producer(); - const publishedPublication = origin.createBroadcast(Path.from("tone.hang")); - const published = publishedPublication.broadcast; + const publishedRoute = origin.route(Path.from("tone.hang"), { hidden: true }); + const published = publishedRoute.broadcast; const track = published.createTrack("audio", { timescale: Time.Timescale.MILLI }); - publishedPublication.announce(); + publishedRoute.announce(); const source = new Broadcast({ origin, name: Path.from("tone.hang"), follow: false, catalogFormat: "manual" }); const capture = new Capture({ broadcast: new Signal(source), diff --git a/test/drain/drain.ts b/test/drain/drain.ts index 544eb680015..2e25ff88e6b 100644 --- a/test/drain/drain.ts +++ b/test/drain/drain.ts @@ -109,11 +109,11 @@ await new Promise((resolve, reject) => { // ── publisher on B ──────────────────────────────────────────────────────────── const published = new Moq.Origin.Producer(); -const broadcastPublication = published.createBroadcast(path); -const broadcast = broadcastPublication.broadcast; +const broadcastRoute = published.route(path, { hidden: true }); +const broadcast = broadcastRoute.broadcast; const track = broadcast.createTrack(trackName, { timescale: Moq.Time.Timescale.MILLI }); // The instance the publication mints is what says B's route serves the same stream as A's. -broadcastPublication.announce(); +broadcastRoute.announce(); const publisher = new Moq.Connection({ url: new URL(`http://127.0.0.1:${bPort}/`), publish: published.consume(), diff --git a/test/interop/clients/js-native/hls.ts b/test/interop/clients/js-native/hls.ts index a71613872b5..9db7c8d5d0d 100644 --- a/test/interop/clients/js-native/hls.ts +++ b/test/interop/clients/js-native/hls.ts @@ -47,7 +47,7 @@ const connection = await Moq.Connection.connect({ publish: origin.consume(), }); try { - const publication = origin.createBroadcast(Moq.Path.from(path)); + const publication = origin.route(Moq.Path.from(path), { hidden: true }); const broadcast = publication.broadcast; const renditions: { video: Record; audio: Record } = { video: {}, diff --git a/test/interop/clients/js-native/server.ts b/test/interop/clients/js-native/server.ts index 8c9e78f822e..36b56e236b7 100644 --- a/test/interop/clients/js-native/server.ts +++ b/test/interop/clients/js-native/server.ts @@ -17,17 +17,17 @@ const version = (0xff000000 + Number(name.split("-").at(-1))) as Ietf.IetfVersio const alpns = [`moqt-${Number(version) - 0xff000000}`]; const extensions = Extensions.offered(); const origin = new Moq.Origin.Producer(); -const broadcastPublication = origin.createBroadcast(Moq.Path.from("handover")); -const broadcast = broadcastPublication.broadcast; +const broadcastRoute = origin.route(Moq.Path.from("handover"), { hidden: true }); +const broadcast = broadcastRoute.broadcast; const video = broadcast.createTrack("video"); -broadcastPublication.announce(); -const markerPublication = origin.createBroadcast(Moq.Path.from("replacement")); -const marker = markerPublication.broadcast; +broadcastRoute.announce(); +const markerRoute = origin.route(Moq.Path.from("replacement"), { hidden: true }); +const marker = markerRoute.broadcast; const ready = marker.createTrack("ready"); const markerGroup = ready.appendGroup(); markerGroup.writeFrame({ payload: new Uint8Array([42]) }); markerGroup.finish(); -markerPublication.announce(); +markerRoute.announce(); type Socket = { protocol: string; diff --git a/test/interop/clients/js-native/tail.ts b/test/interop/clients/js-native/tail.ts index 5ff5fabae80..5d559e4e9f9 100644 --- a/test/interop/clients/js-native/tail.ts +++ b/test/interop/clients/js-native/tail.ts @@ -117,8 +117,8 @@ const connection = await Moq.Connection.connect({ }); try { if (role === "publish") { - const broadcastPublication = origin.createBroadcast(Moq.Path.from(path)); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = origin.route(Moq.Path.from(path), { hidden: true }); + const broadcast = broadcastRoute.broadcast; const track = broadcast.createTrack("tail", { compress, ...(status ? { priority: 2 } : {}) }); if (cached) write(track); if (history) serveHistory(track); @@ -127,7 +127,7 @@ try { head = track.appendGroup(); for (const payload of frames(0).slice(0, LATE_HEAD)) head.writeFrame({ payload }); } - broadcastPublication.announce(); + broadcastRoute.announce(); const lines = createInterface({ input: process.stdin }); const commands = lines[Symbol.asyncIterator](); if (head) { diff --git a/test/interop/clients/js/src/finish.ts b/test/interop/clients/js/src/finish.ts index 6e8c6e66443..031a0763987 100644 --- a/test/interop/clients/js/src/finish.ts +++ b/test/interop/clients/js/src/finish.ts @@ -70,8 +70,8 @@ export function finish( state.result = await readFinish(origin, path, frames, Milli(timeout)); return; } - const broadcastPublication = origin.createBroadcast(Moq.Path.from(path)); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = origin.route(Moq.Path.from(path), { hidden: true }); + const broadcast = broadcastRoute.broadcast; const config: Catalog.VideoConfig = { codec: "avc1.42001e", codedWidth: Catalog.u53(320), @@ -133,21 +133,21 @@ export function finish( serving, ); serving.close(); - broadcastPublication.announce(); + broadcastRoute.announce(); // Keep the finished broadcast up for the late readers, then take it offline. state.lingerUs = LINGER * 1000; state.ready = true; await sleep(Nano.fromMilli(LINGER)); broadcast.close(); - const healthPublication = origin.createBroadcast(Moq.Path.from(`${path}.health`)); - const health = healthPublication.broadcast; + const healthRoute = origin.route(Moq.Path.from(`${path}.health`), { hidden: true }); + const health = healthRoute.broadcast; const healthTrack = health.createTrack("live"); const group = healthTrack.appendGroup(); group.writeFrame({ payload: new TextEncoder().encode("session-alive") }); group.finish(); healthTrack.finish(); healthTrack.close(); - healthPublication.announce(); + healthRoute.announce(); state.ended = true; await ack; health.close(); diff --git a/test/interop/compat/client.ts b/test/interop/compat/client.ts index 82fd9a594a6..c901d3123bd 100644 --- a/test/interop/compat/client.ts +++ b/test/interop/compat/client.ts @@ -307,8 +307,14 @@ if (command === "sign") { } else if (command === "publish") { install(); const origin = new Moq.Origin.Producer(); - const publication = origin.createBroadcast(Moq.Path.from(args[1])); - // Released packages return the fill producer directly; current ones return its publication. + const path = Moq.Path.from(args[1]); + // Released packages create with `createBroadcast`, which returns the fill producer directly or, + // later, its publication; current ones create a route that owns its broadcast. + type Released = { createBroadcast(path: Moq.Path.Valid): { announce(): void } }; + const publication = + "route" in origin + ? origin.route(path, { hidden: true }) + : (origin as unknown as Released).createBroadcast(path); const broadcast = ("broadcast" in publication ? publication.broadcast : publication) as Moq.Broadcast.Producer; const track = broadcast.createTrack("data", { timescale: Moq.Time.Timescale.MICRO }); publication.announce(); diff --git a/test/interop/ietf-range-updates.ts b/test/interop/ietf-range-updates.ts index 473cd79c18c..e16cd588c2f 100644 --- a/test/interop/ietf-range-updates.ts +++ b/test/interop/ietf-range-updates.ts @@ -16,7 +16,7 @@ const input: { draft: number; subscribe: number[]; updates: number[][] } = JSON. const version = (0xff000000 + input.draft) as IetfVersion; const pair = createMockTransportPair(`moqt-${input.draft}`); const origin = new OriginProducer(); -const publication = origin.createBroadcast(Path.from("room")); +const publication = origin.route(Path.from("room"), { hidden: true }); const track = publication.broadcast.createTrack("video"); publication.announce(); const publisher = new Publisher({ diff --git a/test/interop/sign.ts b/test/interop/sign.ts index 5350943c000..9efa3a77e58 100644 --- a/test/interop/sign.ts +++ b/test/interop/sign.ts @@ -56,7 +56,7 @@ for (const { track, group, timescale, frames } of input.rust) { // Groups signed through the JS wrappers, tapped raw off the net broadcast. const inner = new Broadcast.Producer(); -const signed = new Signed.Producer(inner, key, path); +const signed = new Signed.Producer(inner, key, { path, instance: Instance.random() }); const producers = new Map(); const taps = new Map(); const js: Group[] = []; diff --git a/test/interop/track-status.ts b/test/interop/track-status.ts index 32a8a8cb290..aa039738264 100644 --- a/test/interop/track-status.ts +++ b/test/interop/track-status.ts @@ -19,9 +19,8 @@ const version = (0xff000000 + input.draft) as IetfVersion; const pair = createMockTransportPair(); const origin = new OriginProducer(); -const broadcastPublication = origin.createBroadcast(Path.from("room")); -const broadcast = broadcastPublication.broadcast; -broadcastPublication.announce(); +const broadcastRoute = origin.route(Path.from("room")); +const broadcast = broadcastRoute.broadcast; const track = broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: Milli(5000), priority: 2 }); const group = track.createGroup(4n); group.writeFrame({ payload: new Uint8Array([1]), timestamp: Timestamp.fromMillis(0) }); diff --git a/test/interop/tracks.ts b/test/interop/tracks.ts index a0ccec2deb6..da0776e06ca 100644 --- a/test/interop/tracks.ts +++ b/test/interop/tracks.ts @@ -23,9 +23,8 @@ const settle = () => new Promise((resolve) => setTimeout(resolve, 0)); if (input.mode === "answer") { const origin = new OriginProducer(); - const broadcastPublication = origin.createBroadcast(Path.from("room")); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = origin.route(Path.from("room")); + const broadcast = broadcastRoute.broadcast; broadcast.createTrack("a", { timescale: Timescale.MILLI, maxAge: Milli(3000), priority: 9, refresh: 4 }); broadcast.createTrack("b"); diff --git a/test/max-age/client.ts b/test/max-age/client.ts index 64b10455b86..0151d85dbeb 100644 --- a/test/max-age/client.ts +++ b/test/max-age/client.ts @@ -14,10 +14,10 @@ if (!address || !protocol || !["publish", "subscribe"].includes(mode)) const origin = new Producer(); const ages = [undefined, Milli(0), Milli(30_000)]; if (mode === "publish") { - const broadcastPublication = origin.createBroadcast(Path.from("age")); - const broadcast = broadcastPublication.broadcast; + const broadcastRoute = origin.route(Path.from("age"), { hidden: true }); + const broadcast = broadcastRoute.broadcast; for (const [i, maxAge] of ages.entries()) broadcast.createTrack(String(i), { maxAge }); - broadcastPublication.announce(); + broadcastRoute.announce(); } const url = new URL(address); const transport = new Session(url, { diff --git a/test/p2p/src/main.ts b/test/p2p/src/main.ts index 083fd0f65cd..6573c133491 100644 --- a/test/p2p/src/main.ts +++ b/test/p2p/src/main.ts @@ -50,9 +50,8 @@ window.checkTransport = async () => { const publishing = new Moq.Origin.Producer(); const consuming = new Moq.Origin.Producer(); const path = Moq.Path.from("peer/data"); - const broadcastPublication = publishing.createBroadcast(path); - const broadcast = broadcastPublication.broadcast; - broadcastPublication.announce(); + const broadcastRoute = publishing.route(path); + const broadcast = broadcastRoute.broadcast; const track = broadcast.createTrack("data", { timescale: Moq.Time.Timescale.MILLI }); let client: Awaited> | undefined; let server: Awaited> | undefined; diff --git a/test/receive-credit/sender.ts b/test/receive-credit/sender.ts index 7ea3575d038..7a74ad4119f 100644 --- a/test/receive-credit/sender.ts +++ b/test/receive-credit/sender.ts @@ -36,11 +36,11 @@ const websocket = certificate === "websocket"; if (!websocket) install(); const origin = new Moq.Origin.Producer(); -const broadcastPublication = origin.createBroadcast(Moq.Path.from("room")); -const broadcast = broadcastPublication.broadcast; +const broadcastRoute = origin.route(Moq.Path.from("room"), { hidden: true }); +const broadcast = broadcastRoute.broadcast; const low = broadcast.createTrack("low"); const high = broadcast.createTrack("high"); -broadcastPublication.announce(); +broadcastRoute.announce(); const session = await Moq.Connection.connect({ url: new URL(address), diff --git a/test/video/src/captions.ts b/test/video/src/captions.ts index df6cbc31935..a5805b7adc4 100644 --- a/test/video/src/captions.ts +++ b/test/video/src/captions.ts @@ -11,8 +11,8 @@ import { Source } from "../../../js/watch/src/text/source"; /** Caption selection controls exercised by the browser harness. */ export function captions() { const origin = new Origin.Producer(); - const producerPublication = origin.createBroadcast(Path.from("captions")); - const producer = producerPublication.broadcast; + const producerRoute = origin.route(Path.from("captions"), { hidden: true }); + const producer = producerRoute.broadcast; const textCatalog: NonNullable = { renditions: {} }; const catalog: Catalog.Root = { text: textCatalog }; for (const [name, text] of [ @@ -25,7 +25,7 @@ export function captions() { group.writeFrame({ payload: Legacy.encodeFrame(new TextEncoder().encode(text), Micro(1_000_000)) }); group.finish(); } - producerPublication.announce(); + producerRoute.announce(); const broadcast = new Broadcast({ origin, name: Path.from("captions"), catalogFormat: "manual", catalog }); const target = new Signal(undefined); const source = new Source({ broadcast, target }); diff --git a/test/video/src/poster.ts b/test/video/src/poster.ts index 370eb18a3ed..5a470095187 100644 --- a/test/video/src/poster.ts +++ b/test/video/src/poster.ts @@ -9,8 +9,8 @@ import { Player } from "@moq/watch"; async function poster(audio: boolean, buffered: boolean) { const origin = new Origin.Producer(); const name = Path.from("poster"); - const producerPublication = origin.createBroadcast(name); - const producer = producerPublication.broadcast; + const producerRoute = origin.route(name, { hidden: true }); + const producer = producerRoute.broadcast; const track = producer.createTrack("video"); const group = track.appendGroup(); const audioTrack = audio ? producer.createTrack("audio") : undefined; @@ -39,7 +39,7 @@ async function poster(audio: boolean, buffered: boolean) { }, }), }; - producerPublication.announce(); + producerRoute.announce(); const canvas = document.createElement("canvas"); document.body.append(canvas); const enabled = new Signal(true); From 6e89ee354f12fc25cddc834f5b1b9cf56728ff6b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 3 Nov 2026 21:33:13 -0800 Subject: [PATCH 04/19] wip: migrate Rust crates and bindings to the Route handle --- c/moq/MIGRATE.md | 12 + c/moq/test/probe.c | 30 +- cpp/moq/MIGRATE.md | 12 + cpp/moq/bench/main.cpp | 5 +- cpp/moq/test/probe.cpp | 33 +- cpp/obs/src/moq-dock.cpp | 5 + cpp/obs/src/moq-output.cpp | 31 +- cpp/obs/src/moq-output.h | 6 + cpp/obs/test/moq-audio-encoder-test.cpp | 5 +- cpp/obs/test/moq-source-test.cpp | 22 +- dart/moq/MIGRATE.md | 11 + dart/moq/README.md | 4 +- dart/moq/bench/ffi.dart | 9 +- dart/moq/lib/src/aliases.dart | 21 +- dart/moq/lib/src/client.dart | 13 +- dart/moq/lib/src/server.dart | 15 +- dart/moq/test/moq_test.dart | 152 ++-- dart/moq_ffi/lib/src/moq.dart | 738 ++++++++---------- dart/moq_ffi/test/future_test.dart | 9 +- demo/carla/sim/moq_carla_sim/main.py | 6 +- demo/carla/sim/moq_carla_sim/runtime.py | 18 +- demo/carla/sim/tests/test_runtime.py | 8 +- doc/bin/obs.md | 2 +- doc/lib/c/index.md | 30 +- doc/lib/cpp/index.md | 10 +- doc/lib/dart/index.md | 18 +- doc/lib/go/index.md | 9 +- doc/lib/kt/index.md | 9 +- doc/lib/py/index.md | 7 +- doc/lib/swift/index.md | 9 +- go/wrapper/MIGRATE.md | 16 + go/wrapper/README.md | 6 +- go/wrapper/client.go | 8 +- go/wrapper/example_test.go | 13 +- go/wrapper/moq_test.go | 216 +++-- go/wrapper/origin.go | 176 +++-- go/wrapper/origin_internal_test.go | 49 +- go/wrapper/publish.go | 6 +- go/wrapper/reconnect_test.go | 10 +- go/wrapper/runtime_bench_test.go | 8 +- go/wrapper/server.go | 8 +- go/wrapper/types.go | 20 +- kt/moq/MIGRATE.md | 16 + .../kotlin/dev/moq/Aliases.kt | 32 +- .../jvmAndAndroidMain/kotlin/dev/moq/Flows.kt | 8 +- .../jvmAndAndroidMain/kotlin/dev/moq/Moq.kt | 15 +- .../kotlin/dev/moq/Server.kt | 16 +- .../kotlin/dev/moq/SmokeTest.kt | 113 +-- kt/moq/src/jvmTest/kotlin/dev/moq/FfiBench.kt | 6 +- py/moq-ffi/tests/exit_inside_callback.py | 5 +- py/moq-rs/MIGRATE.md | 14 + py/moq-rs/README.md | 34 +- py/moq-rs/benches/ffi.py | 3 +- py/moq-rs/docs/index.md | 6 +- py/moq-rs/examples/clock.py | 6 +- py/moq-rs/examples/serve_clock.py | 6 +- py/moq-rs/moq/__init__.py | 12 +- py/moq-rs/moq/client.py | 12 +- py/moq-rs/moq/origin.py | 167 ++-- py/moq-rs/moq/publish.py | 6 +- py/moq-rs/moq/server.py | 16 +- py/moq-rs/moq/types.py | 8 +- py/moq-rs/tests/test_local.py | 173 ++-- py/moq-rs/tests/test_server.py | 37 +- py/moq-rs/tests/test_testing_clock.py | 3 +- rs/hang/examples/subscribe.rs | 4 +- rs/hang/examples/video.rs | 7 +- rs/moq-archive/README.md | 2 +- rs/moq-audio/src/decode/consumer.rs | 14 +- rs/moq-bench/src/connection.rs | 47 +- rs/moq-boy/src/input.rs | 9 +- rs/moq-boy/src/main.rs | 23 +- rs/moq-c/MIGRATE.md | 16 + rs/moq-c/README.md | 21 +- rs/moq-c/c-tests/audio-decode-output.c | 11 +- rs/moq-c/c-tests/decode-output.c | 14 +- rs/moq-c/c-tests/timestamps.c | 11 +- rs/moq-c/src/api.rs | 329 ++++---- rs/moq-c/src/origin.rs | 247 +++--- rs/moq-c/src/publish.rs | 138 +--- rs/moq-c/src/test.rs | 317 +++++--- rs/moq-cli/src/announced.rs | 7 +- rs/moq-cli/src/archive.rs | 47 +- rs/moq-cli/src/complete.rs | 3 +- rs/moq-cli/src/fetch.rs | 23 +- rs/moq-cli/src/hls.rs | 37 +- rs/moq-cli/src/hls/record.rs | 8 +- rs/moq-cli/src/main.rs | 32 +- rs/moq-cli/src/play/media.rs | 110 ++- rs/moq-cli/src/publish.rs | 151 ++-- rs/moq-cli/src/report.rs | 27 +- rs/moq-cli/src/report/echo_test.rs | 4 +- rs/moq-cli/src/rtc.rs | 16 +- rs/moq-cli/src/rtsp.rs | 18 +- rs/moq-cli/src/transcode.rs | 43 +- rs/moq-cli/tests/integration/export.rs | 13 +- rs/moq-cli/tests/integration/instances.rs | 12 +- rs/moq-cli/tests/integration/listen.rs | 8 +- rs/moq-crypto/MIGRATE.md | 2 +- rs/moq-crypto/README.md | 20 +- rs/moq-crypto/benches/sign.rs | 14 +- rs/moq-crypto/src/sign/broadcast.rs | 19 +- rs/moq-crypto/src/sign/mod.rs | 4 +- rs/moq-crypto/src/sign/tests.rs | 16 +- rs/moq-crypto/tests/transport.rs | 9 +- rs/moq-ffi/MIGRATE.md | 16 + rs/moq-ffi/src/bench.rs | 14 +- rs/moq-ffi/src/ffi.rs | 7 +- rs/moq-ffi/src/origin.rs | 380 +++++---- rs/moq-ffi/src/producer.rs | 2 +- rs/moq-ffi/src/test.rs | 426 +++++----- rs/moq-gst/src/sink/imp.rs | 38 +- rs/moq-gst/src/sink/session.rs | 34 +- rs/moq-gst/src/source/imp.rs | 151 ++-- rs/moq-hls/src/export/archive_tests.rs | 4 +- rs/moq-hls/src/export/mod.rs | 307 ++++---- rs/moq-hls/src/export/rendition.rs | 22 +- rs/moq-hls/src/server/mod.rs | 36 +- rs/moq-hls/src/server/routes.rs | 76 +- rs/moq-hls/tests/integration/conformance.rs | 6 +- rs/moq-hls/tests/integration/finish.rs | 4 +- rs/moq-hls/tests/integration/restart.rs | 3 +- rs/moq-hls/tests/integration/server.rs | 36 +- rs/moq-hls/tests/integration/support.rs | 21 +- rs/moq-mux/benches/containers.rs | 5 +- rs/moq-mux/benches/export.rs | 10 +- rs/moq-mux/src/catalog/hang/consumer.rs | 25 +- rs/moq-mux/src/catalog/producer.rs | 15 +- rs/moq-mux/src/container/consumer.rs | 16 +- rs/moq-mux/src/container/source.rs | 35 +- rs/moq-mux/src/container/test_util.rs | 6 +- rs/moq-mux/src/container/ts/export_test.rs | 185 +++-- rs/moq-mux/src/container/ts/programs.rs | 76 +- rs/moq-mux/src/follow.rs | 20 +- rs/moq-mux/src/linger.rs | 33 +- rs/moq-mux/src/source.rs | 129 +-- rs/moq-relay/src/cluster.rs | 53 +- rs/moq-relay/src/internal.rs | 30 +- rs/moq-relay/src/web.rs | 21 +- rs/moq-relay/tests/drills.rs | 58 +- .../tests/integration/auth_lifetime.rs | 76 +- .../tests/integration/bitrate_caps.rs | 6 +- .../tests/integration/cluster_drain.rs | 17 +- .../tests/integration/cluster_fresh_port.rs | 5 +- .../tests/integration/cluster_idle.rs | 5 +- .../tests/integration/cluster_unknown.rs | 15 +- rs/moq-relay/tests/integration/connection.rs | 17 +- rs/moq-relay/tests/integration/embed.rs | 10 +- .../tests/integration/goaway_cluster.rs | 32 +- .../tests/integration/hidden_cluster.rs | 6 +- .../tests/integration/public_rules.rs | 10 +- .../tests/integration/runtime_uring.rs | 40 +- .../tests/integration/runtime_workers.rs | 10 +- .../tests/integration/shutdown_signal.rs | 5 +- rs/moq-relay/tests/integration/smoke.rs | 59 +- .../tests/integration/tenant_matrix.rs | 11 +- .../tests/integration/upstream_links.rs | 13 +- rs/moq-room/src/chat.rs | 8 +- rs/moq-room/src/room.rs | 10 +- rs/moq-rtc/src/client/mod.rs | 4 +- rs/moq-rtc/src/egress.rs | 44 +- rs/moq-rtc/src/ingest.rs | 13 + rs/moq-rtc/src/lib.rs | 65 +- rs/moq-rtc/src/server/whep.rs | 14 +- rs/moq-rtc/src/server/whip.rs | 14 +- rs/moq-rtmp/src/dial.rs | 70 +- rs/moq-rtmp/src/server.rs | 72 +- rs/moq-rtsp/README.md | 10 +- rs/moq-rtsp/src/client.rs | 16 +- rs/moq-srt/src/server.rs | 20 +- rs/moq-srt/src/ts.rs | 26 +- rs/moq-stats/benches/aggregate.rs | 19 +- rs/moq-stats/benches/producer_tick.rs | 4 +- rs/moq-stats/src/aggregate.rs | 91 ++- rs/moq-stats/src/consume.rs | 9 +- rs/moq-stats/src/produce.rs | 51 +- rs/moq-tokio/examples/chat.rs | 16 +- rs/moq-tokio/examples/clock.rs | 16 +- rs/moq-tokio/src/client.rs | 6 +- rs/moq-tokio/src/connection.rs | 11 +- rs/moq-tokio/src/origin.rs | 7 +- rs/moq-tokio/src/server.rs | 10 +- rs/moq-tokio/src/webrtc/tests.rs | 4 +- rs/moq-tokio/tests/integration/backend.rs | 24 +- rs/moq-tokio/tests/integration/broadcast.rs | 273 +++---- .../tests/integration/datagram_delivery.rs | 8 +- rs/moq-tokio/tests/integration/max_age.rs | 10 +- rs/moq-tokio/tests/integration/migrate.rs | 22 +- .../tests/integration/receive_credit.rs | 26 +- rs/moq-tokio/tests/integration/runtime.rs | 6 +- rs/moq-tokio/tests/integration/sim.rs | 7 +- .../integration/subscription_end_integrity.rs | 10 +- rs/moq-tokio/tests/integration/unannounce.rs | 6 +- rs/moq-transcode/README.md | 6 +- rs/moq-transcode/examples/transcode.rs | 6 +- rs/moq-transcode/src/lib.rs | 6 +- rs/moq-uring/benches/session_lite.rs | 10 +- .../tests/integration/receive_credit.rs | 9 +- rs/moq-uring/tests/integration/session.rs | 20 +- rs/moq-uring/tests/integration/web.rs | 10 +- rs/moq-video/src/decode/decoder.rs | 3 +- swift/MIGRATE.md | 16 + swift/README.md | 6 +- swift/Sources/Moq/Aliases.swift | 10 +- swift/Sources/Moq/Broadcast.swift | 6 +- swift/Sources/Moq/Origin.swift | 148 ++-- swift/Tests/MoqTests/FfiBench.swift | 4 +- swift/Tests/MoqTests/SmokeTests.swift | 109 +-- test/interop/clients/cpp/main.cpp | 17 +- test/interop/clients/go/main.go | 23 +- test/interop/clients/python/interop.py | 10 +- test/interop/clients/rust/catalog.rs | 10 +- test/interop/clients/rust/control.rs | 8 +- test/interop/clients/rust/finish.rs | 24 +- test/interop/clients/rust/goaway.rs | 7 +- test/interop/clients/rust/hls.rs | 6 +- test/interop/clients/rust/tail.rs | 8 +- 217 files changed, 4595 insertions(+), 3908 deletions(-) diff --git a/c/moq/MIGRATE.md b/c/moq/MIGRATE.md index 568c8ec1267..753cd076046 100644 --- a/c/moq/MIGRATE.md +++ b/c/moq/MIGRATE.md @@ -4,6 +4,18 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Publishing goes through one `moq_route` handle + +`moq_origin_producer_create_broadcast(origin, path, &publication)` is `moq_origin_producer_route(origin, path, &options, &route)`, and `moq_origin_producer_requests(origin, prefix, &requests)` is `moq_origin_producer_route_prefix(origin, prefix, &options, &route)`; start `options` from `moq_route_options_default()`. A `moq_route` replaces `moq_publication`, `moq_origin_requests`, and `moq_broadcast_prepared`: + +- `moq_publication_broadcast(publication)` is `moq_route_broadcast(route, &broadcast)`, which fails on a prefix route. +- `moq_publication_announce(publication, &route)` is `moq_route_announce(route)`, and re-pricing is `moq_route_set_cost(route, cost)`; `moq_publication_unannounce` is `moq_route_withdraw`. +- `moq_origin_requests_requested_broadcast` is `moq_route_requested`, whose value is NULL once the origin closes. +- `moq_broadcast_request_prepare` then `moq_broadcast_prepared_publish` is `moq_broadcast_request_route(request, &options, &route)`: create it hidden to fill it first, then announce it. +- `moq_route_instance(route)` returns the stream's instance, kept across withdraw and announce. + +`moq_announce_route` is `moq_route_options`, given at creation, with a leading `hidden`. The default route is visible at once, so set `hidden` and call `moq_route_announce` after filling the catalog to keep the old order. Hold the route while the broadcast should stay announced: `moq_route_cancel` or freeing its last handle retracts it, and `moq_broadcast_producer_close` ends both. The `moq_route` record on `moq_announce.route` is `moq_route_info`. + ### Media setup refusals are typed Audio and video subscribe setup now reports `MOQ_ERROR_UNSUPPORTED_CONFIG` when the decoder refuses a codec, layout, or description. Handle this variant to try another rendition instead of inspecting an audio/video error message or `Unsupported`. Decoder faults, such as a backend that fails to open, and later peer and decode failures keep their existing errors. Regenerate bindings and rebuild the matching native library together. diff --git a/c/moq/test/probe.c b/c/moq/test/probe.c index 5ab02854386..c23a27e4ec5 100644 --- a/c/moq/test/probe.c +++ b/c/moq/test/probe.c @@ -288,18 +288,22 @@ int main(void) /* Publisher: a server whose origin serves one broadcast with one track. */ moq_origin_config origin_config = moq_origin_config_default(); moq_origin_producer *origin = moq_origin_producer_new(&origin_config); - moq_publication *publication = NULL; - ok(moq_origin_producer_create_broadcast(origin, "probe", &publication), "create_broadcast"); - moq_broadcast_producer *broadcast = moq_publication_broadcast(publication); + /* Hidden until its track exists; the route keeps it announced while it is held. */ + moq_route_options route_options = moq_route_options_default(); + route_options.hidden = true; + moq_route *route = NULL; + ok(moq_origin_producer_route(origin, "probe", &route_options, &route), "route"); + moq_broadcast_producer *broadcast = NULL; + ok(moq_route_broadcast(route, &broadcast), "route broadcast"); + char *instance = moq_route_instance(route); + CHECK(instance && instance[0] != '\0'); + moq_string_free(instance); moq_track_info info = moq_track_info_default(); info.timescale.has_value = true; info.timescale.value = 1000000; moq_track_producer *track = NULL; ok(moq_broadcast_producer_publish_track(broadcast, "data", &info, &track), "publish_track"); - moq_announce_route route = moq_announce_route_default(); - ok(moq_publication_announce(publication, &route), "announce"); - /* Releasing the publication keeps the route: the subscriber below still reaches it. */ - moq_publication_free(publication); + ok(moq_route_announce(route), "announce"); const char *generate[] = {"localhost"}; const char *versions[] = {"moq-lite-07-wip"}; @@ -419,6 +423,7 @@ int main(void) moq_server_free(server); moq_track_producer_free(track); moq_broadcast_producer_free(broadcast); + moq_route_free(route); moq_origin_producer_free(origin); /* A first dial that keeps failing still returns the session, whose state names each failed @@ -455,10 +460,13 @@ int main(void) * while moq_shutdown drains the dispatcher; none may run once it returns, even as the * handles are freed afterward. */ moq_origin_producer *late_origin = moq_origin_producer_new(&origin_config); - moq_publication *late_publication = NULL; - ok(moq_origin_producer_create_broadcast(late_origin, "late", &late_publication), "late broadcast"); - moq_broadcast_producer *late_broadcast = moq_publication_broadcast(late_publication); - moq_publication_free(late_publication); + moq_route_options late_options = moq_route_options_default(); + late_options.hidden = true; + moq_route *late_route = NULL; + ok(moq_origin_producer_route(late_origin, "late", &late_options, &late_route), "late route"); + moq_broadcast_producer *late_broadcast = NULL; + ok(moq_route_broadcast(late_route, &late_broadcast), "late broadcast"); + moq_route_free(late_route); moq_track_producer *late_track = NULL; ok(moq_broadcast_producer_publish_track(late_broadcast, "data", &info, &late_track), "late track"); moq_track_consumer *late = NULL; diff --git a/cpp/moq/MIGRATE.md b/cpp/moq/MIGRATE.md index 5d21f4f59c0..3d4de85d1dd 100644 --- a/cpp/moq/MIGRATE.md +++ b/cpp/moq/MIGRATE.md @@ -2,6 +2,18 @@ ## Unreleased +### Publishing goes through one `moq::Route` handle + +`OriginProducer::create_broadcast(path)` is `route(path, options)`, and `requests(prefix)` is `route_prefix(prefix, options)`; `{}` options are the default. Each returns a `std::shared_ptr`, which replaces `moq::Publication`, `moq::OriginRequests`, and `moq::BroadcastPrepared`: + +- `Publication::broadcast()` is `Route::broadcast()`, which returns an error on a prefix route. +- `Publication::announce(route)` is `announce()`, and re-pricing is `set_cost(cost)`; `unannounce()` is `withdraw()`. +- `OriginRequests::requested_broadcast()` is `requested()`, which resolves to `nullptr` once the origin closes. +- `BroadcastRequest::prepare()` then `BroadcastPrepared::publish()` is `BroadcastRequest::route(options)`: create it hidden to fill it first, then `announce()`. +- `instance()` is the stream's instance, kept across `withdraw()` and `announce()`. + +`moq::AnnounceRoute` is `moq::RouteOptions{hidden, cost, instance, epoch}`, given at creation. A route is visible at once unless `hidden`; set it and call `announce()` after filling the catalog to keep the old order. Hold the route while the broadcast should stay announced: `cancel()` or releasing its last handle retracts it, and closing its broadcast ends both. `moq::Route`, the record on `moq::Announce::route`, is `moq::RouteInfo`. + ### `moq::VideoInit::lower` takes either producer kind ([#7699](https://github.com/moq-dev/moq/pull/7699)) `lower` is `std::optional` instead of a `std::shared_ptr`. Assign `moq::MediaProducer(moq::MediaProducer::kTrack{producer})`, or `kStream` for a `moq::MediaTrackStreamProducer`. diff --git a/cpp/moq/bench/main.cpp b/cpp/moq/bench/main.cpp index 91653e4326c..dde2857309f 100644 --- a/cpp/moq/bench/main.cpp +++ b/cpp/moq/bench/main.cpp @@ -98,7 +98,10 @@ Reader read(Case c, std::shared_ptr consumer, const std::vec void throughput(Case c, double budget, std::vector &results) { auto origin = moq::OriginProducer::init({uint64_t(64 << 20)}); - auto broadcast = ok(origin->create_broadcast("bench"))->broadcast(); + moq::RouteOptions hidden; + hidden.hidden = true; + auto route = ok(origin->route("bench", hidden)); + auto broadcast = ok(route->broadcast()); std::vector> tracks; std::vector> consumers; moq::TrackInfo info; diff --git a/cpp/moq/test/probe.cpp b/cpp/moq/test/probe.cpp index 706a8984065..a2631622138 100644 --- a/cpp/moq/test/probe.cpp +++ b/cpp/moq/test/probe.cpp @@ -267,24 +267,23 @@ int main() // It prints the message Rust's Display gives. CHECK(fingerprints.error().to_string() == "bind: not listening; call listen() first"); - // Publisher: a server whose origin serves one broadcast with one track. Dropping the - // publication keeps the route, which lasts until the broadcast closes. + // Publisher: a server whose origin serves one broadcast with one track. The route, created + // hidden until its track exists, keeps the broadcast announced while it is held. auto origin = moq::OriginProducer::init({}); - std::shared_ptr broadcast; - std::shared_ptr track; - { - auto publication = ok(origin->create_broadcast("probe"), "create_broadcast"); - broadcast = publication->broadcast(); - moq::TrackInfo info; - info.timescale = 1000000; - track = ok(broadcast->publish_track("data", info), "publish_track"); - ok(publication->announce({}), "announce"); - } - - // A closed broadcast's publication can no longer announce. - auto stale = ok(origin->create_broadcast("stale"), "create_broadcast"); - ok(stale->broadcast()->close(), "close stale broadcast"); - auto reannounced = stale->announce({}); + moq::RouteOptions hidden; + hidden.hidden = true; + auto route = ok(origin->route("probe", hidden), "route"); + CHECK(!route->instance().empty()); + auto broadcast = ok(route->broadcast(), "route broadcast"); + moq::TrackInfo info; + info.timescale = 1000000; + auto track = ok(broadcast->publish_track("data", info), "publish_track"); + ok(route->announce(), "announce"); + + // A route whose broadcast closed can no longer announce. + auto stale = ok(origin->route("stale", {}), "route"); + ok(ok(stale->broadcast(), "stale broadcast")->close(), "close stale broadcast"); + auto reannounced = stale->announce(); CHECK(!reannounced); CHECK(std::holds_alternative(reannounced.error().get_variant())); diff --git a/cpp/obs/src/moq-dock.cpp b/cpp/obs/src/moq-dock.cpp index 21699589dd2..02eb02b029f 100644 --- a/cpp/obs/src/moq-dock.cpp +++ b/cpp/obs/src/moq-dock.cpp @@ -1124,6 +1124,11 @@ void MoQDock::StartStream() return; } + if (auto *moq = static_cast(obs_obj_get_data(output))) { + const auto instance = moq->GetInstance(); + if (!instance.empty()) + publishSummary += QStringLiteral("\nInstance ") + QString::fromStdString(instance); + } pollTimer->start(); SetRunning(true); diff --git a/cpp/obs/src/moq-output.cpp b/cpp/obs/src/moq-output.cpp index 95bfb576647..028edce4a81 100644 --- a/cpp/obs/src/moq-output.cpp +++ b/cpp/obs/src/moq-output.cpp @@ -166,19 +166,20 @@ bool MoQOutput::Start() return false; } - // Create the broadcast on an origin of our own, then announce it so subscribers - // can discover it. Stop() finishes it, so each Start creates a fresh one, under a - // fresh instance the broadcast mints and keeps across reconnects. Only the - // broadcast is kept: the route outlives the publication until the broadcast closes. + // Route the broadcast on an origin of our own, visible at once so subscribers can + // discover it. Stop() closes it, so each Start creates a fresh route, under a fresh + // instance it mints and keeps across reconnects. The route is held until Reset(): + // releasing it would retract the broadcast. LOG_INFO("Publishing broadcast: %s", path.c_str()); auto next_origin = moq::OriginProducer::init(moq::OriginConfig{}); - auto publication = next_origin->create_broadcast(path); - if (!publication) { - LOG_ERROR("Failed to create broadcast: %s", publication.error().to_string().c_str()); + auto next_route = next_origin->route(path, {}); + if (!next_route) { + LOG_ERROR("Failed to create broadcast: %s", next_route.error().to_string().c_str()); return false; } - if (auto announced = (*publication)->announce({}); !announced) { - LOG_ERROR("Failed to announce broadcast: %s", announced.error().to_string().c_str()); + auto next_broadcast = (*next_route)->broadcast(); + if (!next_broadcast) { + LOG_ERROR("Failed to create broadcast: %s", next_broadcast.error().to_string().c_str()); return false; } @@ -228,11 +229,13 @@ bool MoQOutput::Start() { std::lock_guard lock(mutex); url = server; + instance = (*next_route)->instance(); } { std::lock_guard lock(media_mutex); origin = next_origin; - broadcast = (*publication)->broadcast(); + route = *next_route; + broadcast = *next_broadcast; } // NOTE: You could publish the same broadcasts to multiple sessions if you want (redundant ingest). @@ -369,6 +372,7 @@ void MoQOutput::Reset() connected = false; live = false; url.clear(); + instance.clear(); last_failure_code = MoQError::None; last_failure_reason.clear(); token_refusal.clear(); @@ -403,6 +407,7 @@ void MoQOutput::Reset() if (broadcast) broadcast->close(); broadcast.reset(); + route.reset(); origin.reset(); // The session owns the drain after this request, even if the output dies now. @@ -425,6 +430,12 @@ void MoQOutput::Reset() SetBitrate(encoder, bitrate); } +std::string MoQOutput::GetInstance() +{ + std::lock_guard lock(mutex); + return instance; +} + bool MoQOutput::TryGetConnectionStats(ConnectionStats *out) { if (!out) diff --git a/cpp/obs/src/moq-output.h b/cpp/obs/src/moq-output.h index 796c5e516e1..333528baf39 100644 --- a/cpp/obs/src/moq-output.h +++ b/cpp/obs/src/moq-output.h @@ -59,6 +59,9 @@ class MoQOutput { // Prefer this over obs_output_get_connect_time_ms, which stays 0 for sub-ms connects. bool IsLiveSession(); + // The route's instance for this Start(), kept through session reconnects; empty when stopped. + std::string GetInstance(); + // Most recent connect/reconnect failure for this Start(), or empty when none. // Thread-safe; the dock polls this while connecting, while reconnecting, and on stop. void CopyLastFailure(int *code, std::string *reason); @@ -184,6 +187,7 @@ class MoQOutput { bool connected = false; bool live = false; std::string url; + std::string instance; int last_failure_code = 0; std::string last_failure_reason; std::string token_refusal; @@ -195,6 +199,8 @@ class MoQOutput { // Never held across an OBS call that can wait on an encoder thread. std::mutex media_mutex; std::shared_ptr origin; + // Keeps the broadcast announced; the broadcast closing retracts it. + std::shared_ptr route; std::shared_ptr broadcast; std::map video_tracks; std::map audio_tracks; diff --git a/cpp/obs/test/moq-audio-encoder-test.cpp b/cpp/obs/test/moq-audio-encoder-test.cpp index f7f19fd9b15..682658d1ebb 100644 --- a/cpp/obs/test/moq-audio-encoder-test.cpp +++ b/cpp/obs/test/moq-audio-encoder-test.cpp @@ -203,9 +203,8 @@ void CheckSubscriberDecodes(const char *preset, size_t channels) return; auto origin = moq::OriginProducer::init(moq::OriginConfig{}); - auto publication = TestOk(origin->create_broadcast("room"), "create_broadcast"); - auto broadcast = publication->broadcast(); - TestOk(publication->announce({}), "announce"); + auto route = TestOk(origin->route("room", {}), "route"); + auto broadcast = TestOk(route->broadcast(), "route broadcast"); moq::AudioInit init{}; init.format = moq::AudioFormat::kOpus; diff --git a/cpp/obs/test/moq-source-test.cpp b/cpp/obs/test/moq-source-test.cpp index 16ad9730569..c52a145c915 100644 --- a/cpp/obs/test/moq-source-test.cpp +++ b/cpp/obs/test/moq-source-test.cpp @@ -585,8 +585,10 @@ class Publisher { uint64_t start_us = 1'000'000) : timestamp_us(start_us) { - auto publication = TestOk(relay.origin->create_broadcast(path), "create_broadcast"); - broadcast = publication->broadcast(); + moq::RouteOptions hidden; + hidden.hidden = true; + route = TestOk(relay.origin->route(path, hidden), "route"); + broadcast = TestOk(route->broadcast(), "route broadcast"); if (video) { moq::VideoInit init{}; init.format = moq::VideoFormat::kAvc3; @@ -603,7 +605,7 @@ class Publisher { TestOk(moq::MediaTrackProducer::audio(broadcast, moq::MediaTarget::kNamed{}, init), "audio producer"); } - TestOk(publication->announce(moq::AnnounceRoute{}), "announce"); + TestOk(route->announce(), "announce"); } ~Publisher() { (void)broadcast->close(); } @@ -632,6 +634,8 @@ class Publisher { timeout); } + // Keeps the broadcast announced for the publisher's lifetime. + std::shared_ptr route; std::shared_ptr broadcast; std::shared_ptr video; std::shared_ptr audio; @@ -1607,9 +1611,13 @@ int main() auto snapshot = TestOk(catalogs->next().get(), "catalog snapshot"); CHECK(snapshot.has_value()); auto config = snapshot->video.begin()->second; - std::shared_ptr hidden; + std::shared_ptr hidden; if (sibling) { - hidden = TestOk(relay.origin->create_broadcast("obs/hidden"), "unannounced sibling"); + // A different stream than the one the rendition pins, hidden until announced. + moq::RouteOptions options; + options.hidden = true; + options.instance = "obs-test-other"; + hidden = TestOk(relay.origin->route("obs/hidden", options), "unannounced sibling"); config.broadcast = "./hidden"; config.instance = "obs-test-pinned"; } @@ -1632,9 +1640,7 @@ int main() const int frames = g_output_frames; CHECK(publisher.WriteUntil([&] { return g_output_frames >= frames + 3; })); // A different stream is a real resolution failure. - moq::AnnounceRoute route; - route.instance = "obs-test-other"; - TestOk(hidden->announce(route), "announce mismatched sibling"); + TestOk(hidden->announce(), "announce mismatched sibling"); } CHECK(WaitFor([] { std::lock_guard lock(g_candidate_mutex); diff --git a/dart/moq/MIGRATE.md b/dart/moq/MIGRATE.md index 455dd1ca3a3..067ea058f62 100644 --- a/dart/moq/MIGRATE.md +++ b/dart/moq/MIGRATE.md @@ -4,6 +4,17 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Publishing goes through one `MoqRoute` handle + +`Moq.createBroadcast(path)`, `Server.createBroadcast(path)`, and `OriginProducer.createBroadcast(path: ...)` are `route(path, options: ...)` (`route(path: ..., options: RouteOptions())` on the generated `OriginProducer`), and `OriginProducer.requests(prefix: ...)` is `routePrefix(prefix: ..., options: RouteOptions())`. Each returns a `MoqRoute`, which replaces `Publication`, `OriginRequests`, and `BroadcastPrepared`: + +- `Publication.announce(route: AnnounceRoute(...))` is `announce()`, and re-pricing is `setCost(cost: ...)`; `unannounce()` is `withdraw()`. +- `OriginRequests.requestedBroadcast()` is `requested()`, which returns `null` once the origin closes. +- `BroadcastRequest.prepare()` then `publish()` is `BroadcastRequest.route(options: ...)`: create it hidden to fill it first, then `announce()`. +- `instance()` is the stream's instance, kept across `withdraw()` and `announce()`. + +`AnnounceRoute` is `RouteOptions(hidden:, cost:, instance:, epoch:)`, given at creation. A route is visible at once unless `hidden: true`; pass it and call `announce()` after filling the catalog to keep the old order. Hold the route while the broadcast should stay announced: cancelling or disposing it retracts it, and closing its broadcast ends both. `MoqRoute`, the facts on `Announce.route`, is `RouteInfo` (`MoqRouteInfo`), and the route handle keeps the `Moq` prefix because Flutter owns `Route`. + ### `VideoInit.lower` takes either producer kind ([#7699](https://github.com/moq-dev/moq/pull/7699)) `VideoInit.lower` is a `Producer` (`MoqMediaProducer`) instead of a `TrackProducer`. Pass `TrackMoqMediaProducer(producer: ...)`, or `StreamMoqMediaProducer(producer: ...)` for a byte-stream rendition. diff --git a/dart/moq/README.md b/dart/moq/README.md index cff7d70ce40..7bbb294e03a 100644 --- a/dart/moq/README.md +++ b/dart/moq/README.md @@ -34,12 +34,12 @@ final server = await Server.listen( tlsGenerate: ['localhost'], ), ); -final publication = server.createBroadcast('live'); -publication.announce(route: AnnounceRoute()); // unannounced broadcasts are invisible +final route = server.route('live'); // hold it: disposing the route retracts it await for (final request in server.requests()) { final session = await request.accept(); print(session.state().connects); } +route.dispose(); // retracts the route ``` The package uses `Future` for asynchronous operations and `Stream` for diff --git a/dart/moq/bench/ffi.dart b/dart/moq/bench/ffi.dart index a4defdca85c..e1626e44531 100644 --- a/dart/moq/bench/ffi.dart +++ b/dart/moq/bench/ffi.dart @@ -41,8 +41,11 @@ Future throughput( final origin = OriginProducer( config: OriginConfig(cacheCapacityBytes: 64 << 20), ); - final publication = origin.createBroadcast(path: 'bench'); - final broadcast = publication.broadcast(); + final route = origin.route( + path: 'bench', + options: RouteOptions(hidden: true), + ); + final broadcast = route.broadcast(); final tracks = List.generate( c.publishers, (p) => @@ -124,7 +127,7 @@ Future throughput( track.dispose(); } broadcast.dispose(); - publication.dispose(); + route.dispose(); origin.dispose(); } } diff --git a/dart/moq/lib/src/aliases.dart b/dart/moq/lib/src/aliases.dart index f97c5c56074..6922188a66e 100644 --- a/dart/moq/lib/src/aliases.dart +++ b/dart/moq/lib/src/aliases.dart @@ -13,7 +13,8 @@ import 'package:moq_ffi/moq_ffi.dart'; // // * `MoqServer` - `Server` is the listen facade in server.dart. // * `MoqContainer` / `MoqRoute` - `Container` and `Route` are Flutter's, and -// an ambiguous import would break every Flutter app that uses them. +// an ambiguous import would break every Flutter app that uses them. Its +// options and facts are still [RouteOptions] and [RouteInfo]. // * `MoqException` - `Exception` is in `dart:core`. /// A MoQ client: configure the TLS/bind knobs, then connect to a relay. @@ -37,7 +38,7 @@ typedef CongestionControl = MoqCongestionControl; /// Certificate trust and the mTLS identity for `ConnectOptions.tls`. typedef ClientTls = MoqClientTls; -/// The publish side of an origin: create broadcasts so subscribers can discover them. +/// The publish side of an origin: create routes so subscribers can discover their broadcasts. typedef OriginProducer = MoqOriginProducer; /// Config for creating an origin, such as its total cache budget. @@ -46,17 +47,11 @@ typedef OriginConfig = MoqOriginConfig; /// The subscribe side of an origin: discover and request published broadcasts. typedef OriginConsumer = MoqOriginConsumer; -/// A served route: advertises a path prefix and yields broadcast requests beneath it. -typedef OriginRequests = MoqOriginRequests; - -/// A requested broadcast not yet accepted: fulfill it with a producer or reject it. +/// A requested broadcast not yet answered: serve a held broadcast, route a new one, or reject it. typedef BroadcastRequest = MoqBroadcastRequest; -/// A claim answer being filled before its exact route is announced. -typedef BroadcastPrepared = MoqBroadcastPrepared; - -/// A broadcast published on an origin: the broadcast to fill and its announcement. -typedef Publication = MoqPublication; +/// How a route advertises itself: hidden until announced, its static cost, and a stable instance. +typedef RouteOptions = MoqRouteOptions; /// A stream of announce events under a prefix. typedef AnnounceConsumer = MoqAnnounceConsumer; @@ -67,8 +62,8 @@ typedef AnnounceConfig = MoqAnnounceConfig; /// Follows a specific broadcast path across the publisher instances that serve it. typedef Following = MoqFollowing; -/// How a broadcast advertises its exact path: its static production cost and stream instance. -typedef AnnounceRoute = MoqAnnounceRoute; +/// The read-only facts on a received route: hops, a static cost, and the stream's instance. +typedef RouteInfo = MoqRouteInfo; /// A route over a prefix: its origin-relative path, required wildcard captures (empty without wildcards), and route metadata. typedef Announce = MoqAnnounce; diff --git a/dart/moq/lib/src/client.dart b/dart/moq/lib/src/client.dart index 267834ddf62..d54ea0c31a0 100644 --- a/dart/moq/lib/src/client.dart +++ b/dart/moq/lib/src/client.dart @@ -213,13 +213,14 @@ final class Moq { } } - /// Create an unannounced broadcast at [path], invisible to everyone until announced. + /// Create a route at exactly [path], owning a new broadcast to fill. /// - /// Populate its `broadcast`, calling `requests` first if tracks are served - /// on demand, then advertise it with `announce`. Disposing the publication - /// keeps the route; closing the broadcast ends it. - Publication createBroadcast(String path) => - session.publish().createBroadcast(path: path); + /// Visible at once unless [options] is hidden: create it hidden to populate + /// its `broadcast()` first (calling `requests` if tracks are served on + /// demand), then `announce()` it. Hold the route: cancelling or disposing it + /// retracts it, and closing the broadcast ends both. + MoqRoute route(String path, {RouteOptions? options}) => + session.publish().route(path: path, options: options ?? RouteOptions()); /// Discover routes matching [options]; prefixes stay relative to the origin. /// diff --git a/dart/moq/lib/src/server.dart b/dart/moq/lib/src/server.dart index 1a127b4e4aa..81acee86a89 100644 --- a/dart/moq/lib/src/server.dart +++ b/dart/moq/lib/src/server.dart @@ -53,7 +53,7 @@ final class ListenOptions { /// A listening MoQ server with publishing and subscription conveniences. /// -/// Build one with [Server.listen]. Broadcasts created via [createBroadcast] are +/// Build one with [Server.listen]. Broadcasts of routes created via [route] are /// served to incoming sessions, and [requests] streams each incoming [Request] /// for the caller to accept or reject. [close] stops accepting new sessions and /// releases the listening socket before it returns; in-flight sessions stay @@ -111,15 +111,16 @@ final class Server { } } - /// Create a broadcast at [path], served to incoming sessions. + /// Create a route at exactly [path], owning a broadcast served to incoming sessions. /// - /// Advertise it with `announce` after populating its `broadcast`. Throws - /// when [listen] was given a [ListenOptions.consume] origin but no - /// [ListenOptions.publish] one, since there is then nothing to serve from. - Publication createBroadcast(String path) { + /// Visible at once unless [options] is hidden; hold the route, since + /// cancelling or disposing it retracts it. Throws when [listen] was given a + /// [ListenOptions.consume] origin but no [ListenOptions.publish] one, since + /// there is then nothing to serve from. + MoqRoute route(String path, {RouteOptions? options}) { final origin = _publishOrigin; if (origin == null) throw StateError('no publish origin configured'); - return origin.createBroadcast(path: path); + return origin.route(path: path, options: options ?? RouteOptions()); } /// SHA-256 fingerprints of the configured TLS certificates, hex-encoded. diff --git a/dart/moq/test/moq_test.dart b/dart/moq/test/moq_test.dart index 0098a57d29c..cde2eea5daf 100644 --- a/dart/moq/test/moq_test.dart +++ b/dart/moq/test/moq_test.dart @@ -224,12 +224,15 @@ void main() { final announcement = client.announced().updates().firstWhere( (event) => event is AnnounceEventStart, ); - final publication = relay.createBroadcast(path: 'live'); - final track = publication.broadcast().publishTrack( + final route = relay.route( + path: 'live', + options: RouteOptions(hidden: true), + ); + final track = route.broadcast().publishTrack( name: 'events', info: TrackInfo(timescale: 1000000), ); - publication.announce(route: AnnounceRoute()); + route.announce(); final announced = (await announcement.timeout(timeout) as AnnounceEventStart).announce; expect(announced.prefix, 'live'); @@ -313,10 +316,10 @@ void main() { final announcement = client.announced().updates().firstWhere( (event) => event is AnnounceEventStart, ); - final publication = server.createBroadcast('live'); - final broadcast = publication.broadcast(); + final route = server.route('live', options: RouteOptions(hidden: true)); + final broadcast = route.broadcast(); final track = broadcast.publishTrack(name: 'events', info: null); - publication.announce(route: AnnounceRoute()); + route.announce(); final announced = (await announcement.timeout(timeout) as AnnounceEventStart).announce; expect(announced.prefix, 'live'); @@ -326,6 +329,7 @@ void main() { track.finish(); broadcast.close(); broadcast.close(); // a second close is a no-op + route.dispose(); server.close(); }); @@ -469,8 +473,11 @@ void main() { test('a broadcast is reachable only while announced', () async { final origin = MoqOriginProducer(config: MoqOriginConfig()); - final publication = origin.createBroadcast(path: 'live'); - final broadcast = publication.broadcast(); + final route = origin.route( + path: 'live', + options: RouteOptions(hidden: true), + ); + final broadcast = route.broadcast(); broadcast.publishTrack(name: 'events', info: null); final consumer = origin.consume(); await expectLater( @@ -478,13 +485,14 @@ void main() { throwsA(anything), ); - publication.announce(route: AnnounceRoute()); + route.announce(); final announced = consumer.announced(config: MoqAnnounceConfig()); final first = await nextRoute(announced); expect(first, isA()); expect((first as AnnounceEventStart).announce.prefix, 'live'); + expect(first.announce.route.instance, route.instance()); - publication.unannounce(); + route.withdraw(); final retracted = await nextRoute(announced); expect(retracted, isA()); expect((retracted as AnnounceEventEnd).announce.prefix, 'live'); @@ -493,83 +501,125 @@ void main() { throwsA(anything), ); - publication.announce(route: AnnounceRoute()); - expect(await nextRoute(announced), isA()); + // Announcing again continues the same stream. + route.announce(); + final again = await nextRoute(announced) as AnnounceEventStart; + expect(again.announce.route.instance, route.instance()); await consumer.request(path: 'live').timeout(timeout); - // Disposing the publication keeps the route; closing the broadcast ends it. - publication.dispose(); + // Disposing the broadcast handle keeps the route; cancelling the route retracts it, + // and its broadcast lives on. + broadcast.dispose(); await consumer.request(path: 'live').timeout(timeout); - broadcast.close(); + final kept = route.broadcast(); + route.cancel(); expect(await nextRoute(announced), isA()); + expect(() => route.announce(), throwsA(isA())); + kept.publishTrack(name: 'after', info: null); + kept.close(); + route.dispose(); announced.cancel(); announced.dispose(); }); - test('a stale publication leaves its replacement alone', () async { + test('closing the broadcast retracts its route', () async { final origin = MoqOriginProducer(config: MoqOriginConfig()); - final stale = origin.createBroadcast(path: 'live'); - stale.announce(route: AnnounceRoute()); + final announced = origin.consume().announced(config: MoqAnnounceConfig()); + final route = origin.route(path: 'live', options: RouteOptions()); + expect(await nextRoute(announced), isA()); + route.broadcast().close(); + expect(await nextRoute(announced), isA()); + expect(() => route.announce(), throwsA(isA())); + route.dispose(); + announced.cancel(); + announced.dispose(); + }); + + test('a closed route leaves its replacement alone', () async { + final origin = MoqOriginProducer(config: MoqOriginConfig()); + final stale = origin.route(path: 'live', options: RouteOptions()); stale.broadcast().close(); - final replacement = origin.createBroadcast(path: 'live'); - replacement.announce(route: AnnounceRoute()); - expect( - () => stale.announce(route: AnnounceRoute()), - throwsA(isA()), - ); - expect(() => stale.unannounce(), throwsA(isA())); + final replacement = origin.route(path: 'live', options: RouteOptions()); + expect(() => stale.announce(), throwsA(isA())); + expect(() => stale.setCost(cost: 1), throwsA(isA())); + stale.withdraw(); await origin.consume().request(path: 'live').timeout(timeout); replacement.broadcast().close(); + stale.dispose(); + replacement.dispose(); }); - test('a new instance restarts announce consumers', () async { - final origin = MoqOriginProducer(config: MoqOriginConfig()); - final announced = origin.consume().announced(config: MoqAnnounceConfig()); - final publication = origin.createBroadcast(path: 'instance'); + test( + 'a new route under another instance restarts announce consumers', + () async { + final origin = MoqOriginProducer(config: MoqOriginConfig()); + final announced = origin.consume().announced(config: MoqAnnounceConfig()); + final first = origin.route(path: 'instance', options: RouteOptions()); - publication.announce(route: AnnounceRoute()); - final start = await nextRoute(announced) as AnnounceEventStart; - expect(start.announce.route.instance, isNotEmpty); + final start = await nextRoute(announced) as AnnounceEventStart; + expect(start.announce.route.instance, first.instance()); - publication.announce(route: AnnounceRoute(instance: 'camera', epoch: 1)); - final restart = await nextRoute(announced) as AnnounceEventRestart; - expect(restart.announce.route.instance, 'camera'); + final second = origin.route( + path: 'instance', + options: RouteOptions(instance: 'camera', epoch: 1), + ); + expect(second.instance(), 'camera'); + final restart = await nextRoute(announced) as AnnounceEventRestart; + expect(restart.announce.route.instance, 'camera'); - expect( - () => publication.announce(route: AnnounceRoute(instance: '')), - throwsA(isA()), - ); - announced.cancel(); - announced.dispose(); - }); + expect( + () => origin.route( + path: 'refused', + options: RouteOptions(instance: ''), + ), + throwsA(isA()), + ); + first.cancel(); + second.cancel(); + first.dispose(); + second.dispose(); + announced.cancel(); + announced.dispose(); + }, + ); test('announced pattern reports captures', () async { final origin = MoqOriginProducer(config: MoqOriginConfig()); final announced = origin.consume().announced( config: MoqAnnounceConfig(prefix: 'room', filter: '*/chat'), ); - final publication = origin.createBroadcast(path: 'room/alice/chat'); - publication.announce(route: AnnounceRoute()); + final route = origin.route( + path: 'room/alice/chat', + options: RouteOptions(), + ); final update = await nextRoute(announced) as AnnounceEventStart; expect(update.announce.prefix, 'room/alice/chat'); expect(update.announce.captures, ['alice']); + route.dispose(); }); test('dynamic serves a request under a prefix', () async { final origin = MoqOriginProducer(config: MoqOriginConfig()); - final dynamic = origin.requests(prefix: 'live'); + final dynamic = origin.routePrefix(prefix: 'live', options: RouteOptions()); final pending = origin.consume().request(path: 'live/cam'); - final request = await dynamic.requestedBroadcast().timeout(timeout); + final request = (await dynamic.requested().timeout(timeout))!; expect(request.path(), 'live/cam'); - final prepared = request.prepare(); - final served = prepared.publish(); + // A hidden job route answers nobody until it announces. + final served = request.route(options: RouteOptions(hidden: true)); + expect(served.instance(), isNot(dynamic.instance())); + served.announce(); await pending.timeout(timeout); - // The publication controls the prepared fill: closing that ends its announcement. - prepared.broadcast().close(); - expect(() => served.unannounce(), throwsA(isA())); + // Closing the job's broadcast ends its route. + served.broadcast().close(); + expect(() => served.announce(), throwsA(isA())); + expect(() => dynamic.broadcast(), throwsA(isA())); dynamic.cancel(); + await expectLater( + dynamic.requested(), + throwsA(isA()), + ); dynamic.dispose(); served.dispose(); }); diff --git a/dart/moq_ffi/lib/src/moq.dart b/dart/moq_ffi/lib/src/moq.dart index 9b1653add91..4774003d61e 100644 --- a/dart/moq_ffi/lib/src/moq.dart +++ b/dart/moq_ffi/lib/src/moq.dart @@ -2728,7 +2728,7 @@ class FfiConverterMoqVideoProperties { class MoqAnnounce { final String prefix; final List captures; - final MoqRoute route; + final MoqRouteInfo route; MoqAnnounce({ required this.prefix, required this.captures, @@ -2753,7 +2753,7 @@ class FfiConverterMoqAnnounce { ); final captures = captures_lifted.value; new_offset += captures_lifted.bytesRead; - final route_lifted = FfiConverterMoqRoute.read( + final route_lifted = FfiConverterMoqRouteInfo.read( Uint8List.view(buf.buffer, new_offset), ); final route = route_lifted.value; @@ -2768,7 +2768,7 @@ class FfiConverterMoqAnnounce { final total_length = FfiConverterString.allocationSize(value.prefix) + FfiConverterSequenceString.allocationSize(value.captures) + - FfiConverterMoqRoute.allocationSize(value.route) + + FfiConverterMoqRouteInfo.allocationSize(value.route) + 0; final buf = Uint8List(total_length); write(value, buf); @@ -2785,7 +2785,7 @@ class FfiConverterMoqAnnounce { value.captures, Uint8List.view(buf.buffer, new_offset), ); - new_offset += FfiConverterMoqRoute.write( + new_offset += FfiConverterMoqRouteInfo.write( value.route, Uint8List.view(buf.buffer, new_offset), ); @@ -2795,7 +2795,7 @@ class FfiConverterMoqAnnounce { static int allocationSize(MoqAnnounce value) { return FfiConverterString.allocationSize(value.prefix) + FfiConverterSequenceString.allocationSize(value.captures) + - FfiConverterMoqRoute.allocationSize(value.route) + + FfiConverterMoqRouteInfo.allocationSize(value.route) + 0; } } @@ -2875,77 +2875,6 @@ class FfiConverterMoqAnnounceConfig { } } -class MoqAnnounceRoute { - final int cost; - final String? instance; - final int epoch; - MoqAnnounceRoute({this.cost = 0, this.instance = null, this.epoch = 0}); -} - -class FfiConverterMoqAnnounceRoute { - static MoqAnnounceRoute lift(RustBuffer buf) { - return FfiConverterMoqAnnounceRoute.read(buf.asUint8List()).value; - } - - static LiftRetVal read(Uint8List buf) { - int new_offset = buf.offsetInBytes; - final cost_lifted = FfiConverterUInt64.read( - Uint8List.view(buf.buffer, new_offset), - ); - final cost = cost_lifted.value; - new_offset += cost_lifted.bytesRead; - final instance_lifted = FfiConverterOptionalString.read( - Uint8List.view(buf.buffer, new_offset), - ); - final instance = instance_lifted.value; - new_offset += instance_lifted.bytesRead; - final epoch_lifted = FfiConverterUInt64.read( - Uint8List.view(buf.buffer, new_offset), - ); - final epoch = epoch_lifted.value; - new_offset += epoch_lifted.bytesRead; - return LiftRetVal( - MoqAnnounceRoute(cost: cost, instance: instance, epoch: epoch), - new_offset - buf.offsetInBytes, - ); - } - - static RustBuffer lower(MoqAnnounceRoute value) { - final total_length = - FfiConverterUInt64.allocationSize(value.cost) + - FfiConverterOptionalString.allocationSize(value.instance) + - FfiConverterUInt64.allocationSize(value.epoch) + - 0; - final buf = Uint8List(total_length); - write(value, buf); - return toRustBuffer(buf); - } - - static int write(MoqAnnounceRoute value, Uint8List buf) { - int new_offset = buf.offsetInBytes; - new_offset += FfiConverterUInt64.write( - value.cost, - Uint8List.view(buf.buffer, new_offset), - ); - new_offset += FfiConverterOptionalString.write( - value.instance, - Uint8List.view(buf.buffer, new_offset), - ); - new_offset += FfiConverterUInt64.write( - value.epoch, - Uint8List.view(buf.buffer, new_offset), - ); - return new_offset - buf.offsetInBytes; - } - - static int allocationSize(MoqAnnounceRoute value) { - return FfiConverterUInt64.allocationSize(value.cost) + - FfiConverterOptionalString.allocationSize(value.instance) + - FfiConverterUInt64.allocationSize(value.epoch) + - 0; - } -} - class MoqOriginConfig { final int? cacheCapacityBytes; MoqOriginConfig({this.cacheCapacityBytes = null}); @@ -2992,12 +2921,12 @@ class FfiConverterMoqOriginConfig { } } -class MoqRoute { +class MoqRouteInfo { final List hops; final int cost; final bool anonymous; final String instance; - MoqRoute({ + MoqRouteInfo({ required this.hops, required this.cost, required this.anonymous, @@ -3005,12 +2934,12 @@ class MoqRoute { }); } -class FfiConverterMoqRoute { - static MoqRoute lift(RustBuffer buf) { - return FfiConverterMoqRoute.read(buf.asUint8List()).value; +class FfiConverterMoqRouteInfo { + static MoqRouteInfo lift(RustBuffer buf) { + return FfiConverterMoqRouteInfo.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { int new_offset = buf.offsetInBytes; final hops_lifted = FfiConverterSequenceUInt64.read( Uint8List.view(buf.buffer, new_offset), @@ -3033,7 +2962,7 @@ class FfiConverterMoqRoute { final instance = instance_lifted.value; new_offset += instance_lifted.bytesRead; return LiftRetVal( - MoqRoute( + MoqRouteInfo( hops: hops, cost: cost, anonymous: anonymous, @@ -3043,7 +2972,7 @@ class FfiConverterMoqRoute { ); } - static RustBuffer lower(MoqRoute value) { + static RustBuffer lower(MoqRouteInfo value) { final total_length = FfiConverterSequenceUInt64.allocationSize(value.hops) + FfiConverterUInt64.allocationSize(value.cost) + @@ -3055,7 +2984,7 @@ class FfiConverterMoqRoute { return toRustBuffer(buf); } - static int write(MoqRoute value, Uint8List buf) { + static int write(MoqRouteInfo value, Uint8List buf) { int new_offset = buf.offsetInBytes; new_offset += FfiConverterSequenceUInt64.write( value.hops, @@ -3076,7 +3005,7 @@ class FfiConverterMoqRoute { return new_offset - buf.offsetInBytes; } - static int allocationSize(MoqRoute value) { + static int allocationSize(MoqRouteInfo value) { return FfiConverterSequenceUInt64.allocationSize(value.hops) + FfiConverterUInt64.allocationSize(value.cost) + FfiConverterBool.allocationSize(value.anonymous) + @@ -3085,6 +3014,99 @@ class FfiConverterMoqRoute { } } +class MoqRouteOptions { + final bool hidden; + final int cost; + final String? instance; + final int epoch; + MoqRouteOptions({ + this.hidden = false, + this.cost = 0, + this.instance = null, + this.epoch = 0, + }); +} + +class FfiConverterMoqRouteOptions { + static MoqRouteOptions lift(RustBuffer buf) { + return FfiConverterMoqRouteOptions.read(buf.asUint8List()).value; + } + + static LiftRetVal read(Uint8List buf) { + int new_offset = buf.offsetInBytes; + final hidden_lifted = FfiConverterBool.read( + Uint8List.view(buf.buffer, new_offset), + ); + final hidden = hidden_lifted.value; + new_offset += hidden_lifted.bytesRead; + final cost_lifted = FfiConverterUInt64.read( + Uint8List.view(buf.buffer, new_offset), + ); + final cost = cost_lifted.value; + new_offset += cost_lifted.bytesRead; + final instance_lifted = FfiConverterOptionalString.read( + Uint8List.view(buf.buffer, new_offset), + ); + final instance = instance_lifted.value; + new_offset += instance_lifted.bytesRead; + final epoch_lifted = FfiConverterUInt64.read( + Uint8List.view(buf.buffer, new_offset), + ); + final epoch = epoch_lifted.value; + new_offset += epoch_lifted.bytesRead; + return LiftRetVal( + MoqRouteOptions( + hidden: hidden, + cost: cost, + instance: instance, + epoch: epoch, + ), + new_offset - buf.offsetInBytes, + ); + } + + static RustBuffer lower(MoqRouteOptions value) { + final total_length = + FfiConverterBool.allocationSize(value.hidden) + + FfiConverterUInt64.allocationSize(value.cost) + + FfiConverterOptionalString.allocationSize(value.instance) + + FfiConverterUInt64.allocationSize(value.epoch) + + 0; + final buf = Uint8List(total_length); + write(value, buf); + return toRustBuffer(buf); + } + + static int write(MoqRouteOptions value, Uint8List buf) { + int new_offset = buf.offsetInBytes; + new_offset += FfiConverterBool.write( + value.hidden, + Uint8List.view(buf.buffer, new_offset), + ); + new_offset += FfiConverterUInt64.write( + value.cost, + Uint8List.view(buf.buffer, new_offset), + ); + new_offset += FfiConverterOptionalString.write( + value.instance, + Uint8List.view(buf.buffer, new_offset), + ); + new_offset += FfiConverterUInt64.write( + value.epoch, + Uint8List.view(buf.buffer, new_offset), + ); + return new_offset - buf.offsetInBytes; + } + + static int allocationSize(MoqRouteOptions value) { + return FfiConverterBool.allocationSize(value.hidden) + + FfiConverterUInt64.allocationSize(value.cost) + + FfiConverterOptionalString.allocationSize(value.instance) + + FfiConverterUInt64.allocationSize(value.epoch) + + 0; + } +} + class MoqPosition { final int group; final int frame; @@ -12526,103 +12548,10 @@ class FfiConverterMoqAnnounceConsumer { } } -abstract class MoqBroadcastPreparedInterface { - MoqBroadcastProducer broadcast(); - MoqPublication publish(); -} - -final _MoqBroadcastPreparedFinalizer = Finalizer>((ptr) { - rustCall( - (status) => uniffi_moq_ffi_fn_free_moqbroadcastprepared(ptr, status), - ); -}); - -class MoqBroadcastPrepared implements MoqBroadcastPreparedInterface { - late final Pointer _ptr; - bool _isDisposed = false; - MoqBroadcastPrepared._(this._ptr) { - _MoqBroadcastPreparedFinalizer.attach(this, _ptr, detach: this); - } - factory MoqBroadcastPrepared.lift(Pointer ptr) { - return MoqBroadcastPrepared._(ptr); - } - Pointer uniffiClonePointer() { - if (_isDisposed) { - throw StateError("Object has already been disposed"); - } - return rustCall( - (status) => uniffi_moq_ffi_fn_clone_moqbroadcastprepared(_ptr, status), - ); - } - - void dispose() { - if (_isDisposed) { - return; - } - final status = calloc(); - _isDisposed = true; - _MoqBroadcastPreparedFinalizer.detach(this); - try { - uniffi_moq_ffi_fn_free_moqbroadcastprepared(_ptr, status); - checkCallStatus(NullRustCallStatusErrorHandler(), status); - } finally { - calloc.free(status); - } - } - - MoqBroadcastProducer broadcast() { - return rustCallWithLifter( - (status) => uniffi_moq_ffi_fn_method_moqbroadcastprepared_broadcast( - uniffiClonePointer(), - status, - ), - FfiConverterMoqBroadcastProducer.lift, - null, - ); - } - - MoqPublication publish() { - return rustCallWithLifter( - (status) => uniffi_moq_ffi_fn_method_moqbroadcastprepared_publish( - uniffiClonePointer(), - status, - ), - FfiConverterMoqPublication.lift, - moqExceptionErrorHandler, - ); - } -} - -class FfiConverterMoqBroadcastPrepared { - static MoqBroadcastPrepared lift(Pointer ptr) { - return MoqBroadcastPrepared.lift(ptr); - } - - static Pointer lower(MoqBroadcastPrepared value) { - return value.uniffiClonePointer(); - } - - static int allocationSize(MoqBroadcastPrepared value) { - return 8; - } - - static LiftRetVal read(Uint8List buf) { - final handle = buf.buffer.asByteData(buf.offsetInBytes).getInt64(0); - final pointer = Pointer.fromAddress(handle); - return LiftRetVal(MoqBroadcastPrepared.lift(pointer), 8); - } - - static int write(MoqBroadcastPrepared value, Uint8List buf) { - final handle = lower(value); - buf.buffer.asByteData(buf.offsetInBytes).setInt64(0, handle.address); - return 8; - } -} - abstract class MoqBroadcastRequestInterface { String path(); - MoqBroadcastPrepared prepare(); void reject({required int errorCode}); + MoqRoute route({required MoqRouteOptions options}); void serve({required MoqBroadcastConsumer broadcast}); } @@ -12674,17 +12603,6 @@ class MoqBroadcastRequest implements MoqBroadcastRequestInterface { ); } - MoqBroadcastPrepared prepare() { - return rustCallWithLifter( - (status) => uniffi_moq_ffi_fn_method_moqbroadcastrequest_prepare( - uniffiClonePointer(), - status, - ), - FfiConverterMoqBroadcastPrepared.lift, - moqExceptionErrorHandler, - ); - } - void reject({required int errorCode}) { return rustCall((status) { uniffi_moq_ffi_fn_method_moqbroadcastrequest_reject( @@ -12695,6 +12613,18 @@ class MoqBroadcastRequest implements MoqBroadcastRequestInterface { }, moqExceptionErrorHandler); } + MoqRoute route({required MoqRouteOptions options}) { + return rustCallWithLifter( + (status) => uniffi_moq_ffi_fn_method_moqbroadcastrequest_route( + uniffiClonePointer(), + FfiConverterMoqRouteOptions.lower(options), + status, + ), + FfiConverterMoqRoute.lift, + moqExceptionErrorHandler, + ); + } + void serve({required MoqBroadcastConsumer broadcast}) { return rustCall((status) { uniffi_moq_ffi_fn_method_moqbroadcastrequest_serve( @@ -12944,8 +12874,11 @@ class FfiConverterMoqOriginConsumer { abstract class MoqOriginProducerInterface { MoqOriginConsumer consume(); - MoqPublication createBroadcast({required String path}); - MoqOriginRequests requests({required String prefix}); + MoqRoute route({required String path, required MoqRouteOptions options}); + MoqRoute routePrefix({ + required String prefix, + required MoqRouteOptions options, + }); } final _MoqOriginProducerFinalizer = Finalizer>((ptr) { @@ -13006,26 +12939,31 @@ class MoqOriginProducer implements MoqOriginProducerInterface { ); } - MoqPublication createBroadcast({required String path}) { + MoqRoute route({required String path, required MoqRouteOptions options}) { return rustCallWithLifter( - (status) => uniffi_moq_ffi_fn_method_moqoriginproducer_create_broadcast( + (status) => uniffi_moq_ffi_fn_method_moqoriginproducer_route( uniffiClonePointer(), FfiConverterString.lower(path), + FfiConverterMoqRouteOptions.lower(options), status, ), - FfiConverterMoqPublication.lift, + FfiConverterMoqRoute.lift, moqExceptionErrorHandler, ); } - MoqOriginRequests requests({required String prefix}) { + MoqRoute routePrefix({ + required String prefix, + required MoqRouteOptions options, + }) { return rustCallWithLifter( - (status) => uniffi_moq_ffi_fn_method_moqoriginproducer_requests( + (status) => uniffi_moq_ffi_fn_method_moqoriginproducer_route_prefix( uniffiClonePointer(), FfiConverterString.lower(prefix), + FfiConverterMoqRouteOptions.lower(options), status, ), - FfiConverterMoqOriginRequests.lift, + FfiConverterMoqRoute.lift, moqExceptionErrorHandler, ); } @@ -13057,31 +12995,34 @@ class FfiConverterMoqOriginProducer { } } -abstract class MoqOriginRequestsInterface { +abstract class MoqRouteInterface { + void announce(); + MoqBroadcastProducer broadcast(); void cancel(); - UniffiRustFuture requestedBroadcast(); + String instance(); + UniffiRustFuture requested(); + void setCost({required int cost}); + void withdraw(); } -final _MoqOriginRequestsFinalizer = Finalizer>((ptr) { - rustCall((status) => uniffi_moq_ffi_fn_free_moqoriginrequests(ptr, status)); +final _MoqRouteFinalizer = Finalizer>((ptr) { + rustCall((status) => uniffi_moq_ffi_fn_free_moqroute(ptr, status)); }); -class MoqOriginRequests implements MoqOriginRequestsInterface { +class MoqRoute implements MoqRouteInterface { late final Pointer _ptr; bool _isDisposed = false; - MoqOriginRequests._(this._ptr) { - _MoqOriginRequestsFinalizer.attach(this, _ptr, detach: this); + MoqRoute._(this._ptr) { + _MoqRouteFinalizer.attach(this, _ptr, detach: this); } - factory MoqOriginRequests.lift(Pointer ptr) { - return MoqOriginRequests._(ptr); + factory MoqRoute.lift(Pointer ptr) { + return MoqRoute._(ptr); } Pointer uniffiClonePointer() { if (_isDisposed) { throw StateError("Object has already been disposed"); } - return rustCall( - (status) => uniffi_moq_ffi_fn_clone_moqoriginrequests(_ptr, status), - ); + return rustCall((status) => uniffi_moq_ffi_fn_clone_moqroute(_ptr, status)); } void dispose() { @@ -13090,160 +13031,98 @@ class MoqOriginRequests implements MoqOriginRequestsInterface { } final status = calloc(); _isDisposed = true; - _MoqOriginRequestsFinalizer.detach(this); + _MoqRouteFinalizer.detach(this); try { - uniffi_moq_ffi_fn_free_moqoriginrequests(_ptr, status); + uniffi_moq_ffi_fn_free_moqroute(_ptr, status); checkCallStatus(NullRustCallStatusErrorHandler(), status); } finally { calloc.free(status); } } - void cancel() { + void announce() { return rustCall((status) { - uniffi_moq_ffi_fn_method_moqoriginrequests_cancel( - uniffiClonePointer(), - status, - ); - }, null); + uniffi_moq_ffi_fn_method_moqroute_announce(uniffiClonePointer(), status); + }, moqExceptionErrorHandler); } - UniffiRustFuture requestedBroadcast() { - return uniffiRustCallAsync( - () => uniffi_moq_ffi_fn_method_moqoriginrequests_requested_broadcast( + MoqBroadcastProducer broadcast() { + return rustCallWithLifter( + (status) => uniffi_moq_ffi_fn_method_moqroute_broadcast( uniffiClonePointer(), + status, ), - ffi_moq_ffi_rust_future_poll_u64, - ffi_moq_ffi_rust_future_complete_u64, - ffi_moq_ffi_rust_future_cancel_u64, - ffi_moq_ffi_rust_future_free_u64, - (ptr) => - FfiConverterMoqBroadcastRequest.lift(Pointer.fromAddress(ptr)), + FfiConverterMoqBroadcastProducer.lift, moqExceptionErrorHandler, ); } -} - -class FfiConverterMoqOriginRequests { - static MoqOriginRequests lift(Pointer ptr) { - return MoqOriginRequests.lift(ptr); - } - - static Pointer lower(MoqOriginRequests value) { - return value.uniffiClonePointer(); - } - - static int allocationSize(MoqOriginRequests value) { - return 8; - } - - static LiftRetVal read(Uint8List buf) { - final handle = buf.buffer.asByteData(buf.offsetInBytes).getInt64(0); - final pointer = Pointer.fromAddress(handle); - return LiftRetVal(MoqOriginRequests.lift(pointer), 8); - } - - static int write(MoqOriginRequests value, Uint8List buf) { - final handle = lower(value); - buf.buffer.asByteData(buf.offsetInBytes).setInt64(0, handle.address); - return 8; - } -} - -abstract class MoqPublicationInterface { - void announce({required MoqAnnounceRoute route}); - MoqBroadcastProducer broadcast(); - void unannounce(); -} - -final _MoqPublicationFinalizer = Finalizer>((ptr) { - rustCall((status) => uniffi_moq_ffi_fn_free_moqpublication(ptr, status)); -}); - -class MoqPublication implements MoqPublicationInterface { - late final Pointer _ptr; - bool _isDisposed = false; - MoqPublication._(this._ptr) { - _MoqPublicationFinalizer.attach(this, _ptr, detach: this); - } - factory MoqPublication.lift(Pointer ptr) { - return MoqPublication._(ptr); - } - Pointer uniffiClonePointer() { - if (_isDisposed) { - throw StateError("Object has already been disposed"); - } - return rustCall( - (status) => uniffi_moq_ffi_fn_clone_moqpublication(_ptr, status), - ); - } - - void dispose() { - if (_isDisposed) { - return; - } - final status = calloc(); - _isDisposed = true; - _MoqPublicationFinalizer.detach(this); - try { - uniffi_moq_ffi_fn_free_moqpublication(_ptr, status); - checkCallStatus(NullRustCallStatusErrorHandler(), status); - } finally { - calloc.free(status); - } - } - void announce({required MoqAnnounceRoute route}) { + void cancel() { return rustCall((status) { - uniffi_moq_ffi_fn_method_moqpublication_announce( - uniffiClonePointer(), - FfiConverterMoqAnnounceRoute.lower(route), - status, - ); - }, moqExceptionErrorHandler); + uniffi_moq_ffi_fn_method_moqroute_cancel(uniffiClonePointer(), status); + }, null); } - MoqBroadcastProducer broadcast() { + String instance() { return rustCallWithLifter( - (status) => uniffi_moq_ffi_fn_method_moqpublication_broadcast( + (status) => uniffi_moq_ffi_fn_method_moqroute_instance( uniffiClonePointer(), status, ), - FfiConverterMoqBroadcastProducer.lift, + FfiConverterString.lift, null, ); } - void unannounce() { + UniffiRustFuture requested() { + return uniffiRustCallAsync( + () => uniffi_moq_ffi_fn_method_moqroute_requested(uniffiClonePointer()), + ffi_moq_ffi_rust_future_poll_rust_buffer, + ffi_moq_ffi_rust_future_complete_rust_buffer, + ffi_moq_ffi_rust_future_cancel_rust_buffer, + ffi_moq_ffi_rust_future_free_rust_buffer, + FfiConverterOptionalMoqBroadcastRequest.lift, + moqExceptionErrorHandler, + ); + } + + void setCost({required int cost}) { return rustCall((status) { - uniffi_moq_ffi_fn_method_moqpublication_unannounce( + uniffi_moq_ffi_fn_method_moqroute_set_cost( uniffiClonePointer(), + FfiConverterUInt64.lower(cost), status, ); }, moqExceptionErrorHandler); } + + void withdraw() { + return rustCall((status) { + uniffi_moq_ffi_fn_method_moqroute_withdraw(uniffiClonePointer(), status); + }, moqExceptionErrorHandler); + } } -class FfiConverterMoqPublication { - static MoqPublication lift(Pointer ptr) { - return MoqPublication.lift(ptr); +class FfiConverterMoqRoute { + static MoqRoute lift(Pointer ptr) { + return MoqRoute.lift(ptr); } - static Pointer lower(MoqPublication value) { + static Pointer lower(MoqRoute value) { return value.uniffiClonePointer(); } - static int allocationSize(MoqPublication value) { + static int allocationSize(MoqRoute value) { return 8; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { final handle = buf.buffer.asByteData(buf.offsetInBytes).getInt64(0); final pointer = Pointer.fromAddress(handle); - return LiftRetVal(MoqPublication.lift(pointer), 8); + return LiftRetVal(MoqRoute.lift(pointer), 8); } - static int write(MoqPublication value, Uint8List buf) { + static int write(MoqRoute value, Uint8List buf) { final handle = lower(value); buf.buffer.asByteData(buf.offsetInBytes).setInt64(0, handle.address); return 8; @@ -16143,6 +16022,55 @@ class FfiConverterOptionalMoqBandwidthConsumer { } } +class FfiConverterOptionalMoqBroadcastRequest { + static MoqBroadcastRequest? lift(RustBuffer buf) { + return FfiConverterOptionalMoqBroadcastRequest.read( + buf.asUint8List(), + ).value; + } + + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); + } + final result = FfiConverterMoqBroadcastRequest.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); + } + + static int allocationSize([MoqBroadcastRequest? value]) { + if (value == null) { + return 1; + } + return FfiConverterMoqBroadcastRequest.allocationSize(value) + 1; + } + + static RustBuffer lower(MoqBroadcastRequest? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final buf = Uint8List( + FfiConverterOptionalMoqBroadcastRequest.allocationSize(value), + ); + FfiConverterOptionalMoqBroadcastRequest.write(value, buf); + return toRustBuffer(buf); + } + + static int write(MoqBroadcastRequest? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterMoqBroadcastRequest.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; + } +} + class FfiConverterOptionalMoqCatalog { static MoqCatalog? lift(RustBuffer buf) { return FfiConverterOptionalMoqCatalog.read(buf.asUint8List()).value; @@ -19627,38 +19555,6 @@ external Pointer uniffi_moq_ffi_fn_method_moqannounceconsumer_next( Pointer ptr, ); -@Native Function(Pointer, Pointer)>( - assetId: _uniffiAssetId, -) -external Pointer uniffi_moq_ffi_fn_clone_moqbroadcastprepared( - Pointer handle, - Pointer uniffiStatus, -); - -@Native, Pointer)>( - assetId: _uniffiAssetId, -) -external void uniffi_moq_ffi_fn_free_moqbroadcastprepared( - Pointer handle, - Pointer uniffiStatus, -); - -@Native Function(Pointer, Pointer)>( - assetId: _uniffiAssetId, -) -external Pointer uniffi_moq_ffi_fn_method_moqbroadcastprepared_broadcast( - Pointer ptr, - Pointer uniffiStatus, -); - -@Native Function(Pointer, Pointer)>( - assetId: _uniffiAssetId, -) -external Pointer uniffi_moq_ffi_fn_method_moqbroadcastprepared_publish( - Pointer ptr, - Pointer uniffiStatus, -); - @Native Function(Pointer, Pointer)>( assetId: _uniffiAssetId, ) @@ -19683,20 +19579,21 @@ external RustBuffer uniffi_moq_ffi_fn_method_moqbroadcastrequest_path( Pointer uniffiStatus, ); -@Native Function(Pointer, Pointer)>( +@Native, Uint16, Pointer)>( assetId: _uniffiAssetId, ) -external Pointer uniffi_moq_ffi_fn_method_moqbroadcastrequest_prepare( +external void uniffi_moq_ffi_fn_method_moqbroadcastrequest_reject( Pointer ptr, + int error_code, Pointer uniffiStatus, ); -@Native, Uint16, Pointer)>( - assetId: _uniffiAssetId, -) -external void uniffi_moq_ffi_fn_method_moqbroadcastrequest_reject( +@Native< + Pointer Function(Pointer, RustBuffer, Pointer) +>(assetId: _uniffiAssetId) +external Pointer uniffi_moq_ffi_fn_method_moqbroadcastrequest_route( Pointer ptr, - int error_code, + RustBuffer options, Pointer uniffiStatus, ); @@ -19820,28 +19717,39 @@ external Pointer uniffi_moq_ffi_fn_method_moqoriginproducer_consume( ); @Native< - Pointer Function(Pointer, RustBuffer, Pointer) + Pointer Function( + Pointer, + RustBuffer, + RustBuffer, + Pointer, + ) >(assetId: _uniffiAssetId) -external Pointer -uniffi_moq_ffi_fn_method_moqoriginproducer_create_broadcast( +external Pointer uniffi_moq_ffi_fn_method_moqoriginproducer_route( Pointer ptr, RustBuffer path, + RustBuffer options, Pointer uniffiStatus, ); @Native< - Pointer Function(Pointer, RustBuffer, Pointer) + Pointer Function( + Pointer, + RustBuffer, + RustBuffer, + Pointer, + ) >(assetId: _uniffiAssetId) -external Pointer uniffi_moq_ffi_fn_method_moqoriginproducer_requests( +external Pointer uniffi_moq_ffi_fn_method_moqoriginproducer_route_prefix( Pointer ptr, RustBuffer prefix, + RustBuffer options, Pointer uniffiStatus, ); @Native Function(Pointer, Pointer)>( assetId: _uniffiAssetId, ) -external Pointer uniffi_moq_ffi_fn_clone_moqoriginrequests( +external Pointer uniffi_moq_ffi_fn_clone_moqroute( Pointer handle, Pointer uniffiStatus, ); @@ -19849,7 +19757,7 @@ external Pointer uniffi_moq_ffi_fn_clone_moqoriginrequests( @Native, Pointer)>( assetId: _uniffiAssetId, ) -external void uniffi_moq_ffi_fn_free_moqoriginrequests( +external void uniffi_moq_ffi_fn_free_moqroute( Pointer handle, Pointer uniffiStatus, ); @@ -19857,54 +19765,53 @@ external void uniffi_moq_ffi_fn_free_moqoriginrequests( @Native, Pointer)>( assetId: _uniffiAssetId, ) -external void uniffi_moq_ffi_fn_method_moqoriginrequests_cancel( +external void uniffi_moq_ffi_fn_method_moqroute_announce( Pointer ptr, Pointer uniffiStatus, ); -@Native Function(Pointer)>(assetId: _uniffiAssetId) -external Pointer -uniffi_moq_ffi_fn_method_moqoriginrequests_requested_broadcast( - Pointer ptr, -); - @Native Function(Pointer, Pointer)>( assetId: _uniffiAssetId, ) -external Pointer uniffi_moq_ffi_fn_clone_moqpublication( - Pointer handle, +external Pointer uniffi_moq_ffi_fn_method_moqroute_broadcast( + Pointer ptr, Pointer uniffiStatus, ); @Native, Pointer)>( assetId: _uniffiAssetId, ) -external void uniffi_moq_ffi_fn_free_moqpublication( - Pointer handle, +external void uniffi_moq_ffi_fn_method_moqroute_cancel( + Pointer ptr, Pointer uniffiStatus, ); -@Native, RustBuffer, Pointer)>( +@Native, Pointer)>( assetId: _uniffiAssetId, ) -external void uniffi_moq_ffi_fn_method_moqpublication_announce( +external RustBuffer uniffi_moq_ffi_fn_method_moqroute_instance( Pointer ptr, - RustBuffer route, Pointer uniffiStatus, ); -@Native Function(Pointer, Pointer)>( +@Native Function(Pointer)>(assetId: _uniffiAssetId) +external Pointer uniffi_moq_ffi_fn_method_moqroute_requested( + Pointer ptr, +); + +@Native, Uint64, Pointer)>( assetId: _uniffiAssetId, ) -external Pointer uniffi_moq_ffi_fn_method_moqpublication_broadcast( +external void uniffi_moq_ffi_fn_method_moqroute_set_cost( Pointer ptr, + int cost, Pointer uniffiStatus, ); @Native, Pointer)>( assetId: _uniffiAssetId, ) -external void uniffi_moq_ffi_fn_method_moqpublication_unannounce( +external void uniffi_moq_ffi_fn_method_moqroute_withdraw( Pointer ptr, Pointer uniffiStatus, ); @@ -21570,20 +21477,14 @@ external int uniffi_moq_ffi_checksum_method_moqannounceconsumer_cancel(); @Native(assetId: _uniffiAssetId) external int uniffi_moq_ffi_checksum_method_moqannounceconsumer_next(); -@Native(assetId: _uniffiAssetId) -external int uniffi_moq_ffi_checksum_method_moqbroadcastprepared_broadcast(); - -@Native(assetId: _uniffiAssetId) -external int uniffi_moq_ffi_checksum_method_moqbroadcastprepared_publish(); - @Native(assetId: _uniffiAssetId) external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_path(); @Native(assetId: _uniffiAssetId) -external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_prepare(); +external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_reject(); @Native(assetId: _uniffiAssetId) -external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_reject(); +external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_route(); @Native(assetId: _uniffiAssetId) external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_serve(); @@ -21607,27 +21508,31 @@ external int uniffi_moq_ffi_checksum_method_moqoriginconsumer_request(); external int uniffi_moq_ffi_checksum_method_moqoriginproducer_consume(); @Native(assetId: _uniffiAssetId) -external int -uniffi_moq_ffi_checksum_method_moqoriginproducer_create_broadcast(); +external int uniffi_moq_ffi_checksum_method_moqoriginproducer_route(); @Native(assetId: _uniffiAssetId) -external int uniffi_moq_ffi_checksum_method_moqoriginproducer_requests(); +external int uniffi_moq_ffi_checksum_method_moqoriginproducer_route_prefix(); @Native(assetId: _uniffiAssetId) -external int uniffi_moq_ffi_checksum_method_moqoriginrequests_cancel(); +external int uniffi_moq_ffi_checksum_method_moqroute_announce(); @Native(assetId: _uniffiAssetId) -external int -uniffi_moq_ffi_checksum_method_moqoriginrequests_requested_broadcast(); +external int uniffi_moq_ffi_checksum_method_moqroute_broadcast(); @Native(assetId: _uniffiAssetId) -external int uniffi_moq_ffi_checksum_method_moqpublication_announce(); +external int uniffi_moq_ffi_checksum_method_moqroute_cancel(); @Native(assetId: _uniffiAssetId) -external int uniffi_moq_ffi_checksum_method_moqpublication_broadcast(); +external int uniffi_moq_ffi_checksum_method_moqroute_instance(); @Native(assetId: _uniffiAssetId) -external int uniffi_moq_ffi_checksum_method_moqpublication_unannounce(); +external int uniffi_moq_ffi_checksum_method_moqroute_requested(); + +@Native(assetId: _uniffiAssetId) +external int uniffi_moq_ffi_checksum_method_moqroute_set_cost(); + +@Native(assetId: _uniffiAssetId) +external int uniffi_moq_ffi_checksum_method_moqroute_withdraw(); @Native(assetId: _uniffiAssetId) external int uniffi_moq_ffi_checksum_method_moqbroadcastproducer_close(); @@ -22302,23 +22207,16 @@ void _checkApiChecksums() { if (uniffi_moq_ffi_checksum_method_moqannounceconsumer_next() != 38311) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqbroadcastprepared_broadcast() != - 42363) { - throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); - } - if (uniffi_moq_ffi_checksum_method_moqbroadcastprepared_publish() != 60136) { - throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); - } if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_path() != 6534) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_prepare() != 45877) { + if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_reject() != 9727) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_reject() != 9727) { + if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_route() != 16046) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_serve() != 16802) { + if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_serve() != 2580) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } if (uniffi_moq_ffi_checksum_method_moqfollowing_available() != 39867) { @@ -22339,27 +22237,31 @@ void _checkApiChecksums() { if (uniffi_moq_ffi_checksum_method_moqoriginproducer_consume() != 52357) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqoriginproducer_create_broadcast() != - 43708) { + if (uniffi_moq_ffi_checksum_method_moqoriginproducer_route() != 27041) { + throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); + } + if (uniffi_moq_ffi_checksum_method_moqoriginproducer_route_prefix() != 3472) { + throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); + } + if (uniffi_moq_ffi_checksum_method_moqroute_announce() != 46977) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqoriginproducer_requests() != 8499) { + if (uniffi_moq_ffi_checksum_method_moqroute_broadcast() != 31588) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqoriginrequests_cancel() != 18954) { + if (uniffi_moq_ffi_checksum_method_moqroute_cancel() != 41411) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqoriginrequests_requested_broadcast() != - 47029) { + if (uniffi_moq_ffi_checksum_method_moqroute_instance() != 47971) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqpublication_announce() != 60624) { + if (uniffi_moq_ffi_checksum_method_moqroute_requested() != 49558) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqpublication_broadcast() != 38236) { + if (uniffi_moq_ffi_checksum_method_moqroute_set_cost() != 30911) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_method_moqpublication_unannounce() != 21154) { + if (uniffi_moq_ffi_checksum_method_moqroute_withdraw() != 4611) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } if (uniffi_moq_ffi_checksum_method_moqbroadcastproducer_close() != 21298) { @@ -22716,7 +22618,7 @@ void _checkApiChecksums() { if (uniffi_moq_ffi_checksum_constructor_moqoriginproducer_new() != 48126) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } - if (uniffi_moq_ffi_checksum_constructor_moqbroadcastproducer_new() != 12099) { + if (uniffi_moq_ffi_checksum_constructor_moqbroadcastproducer_new() != 2448) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } if (uniffi_moq_ffi_checksum_constructor_moqserver_new() != 49910) { diff --git a/dart/moq_ffi/test/future_test.dart b/dart/moq_ffi/test/future_test.dart index f671129d350..adb6a769ead 100644 --- a/dart/moq_ffi/test/future_test.dart +++ b/dart/moq_ffi/test/future_test.dart @@ -137,12 +137,15 @@ void main() { await pending.cancel(); await error; final next = cursor.next(); - final publication = origin.createBroadcast(path: 'still-listening'); + final route = origin.route( + path: 'still-listening', + options: MoqRouteOptions(), + ); try { - publication.announce(route: MoqAnnounceRoute()); expect(await next, isA()); } finally { - publication.broadcast().close(); + route.broadcast().close(); + route.dispose(); } } finally { cursor.cancel(); diff --git a/demo/carla/sim/moq_carla_sim/main.py b/demo/carla/sim/moq_carla_sim/main.py index 91e2ce38fa1..88585fb09d0 100644 --- a/demo/carla/sim/moq_carla_sim/main.py +++ b/demo/carla/sim/moq_carla_sim/main.py @@ -241,11 +241,11 @@ async def run(args: argparse.Namespace) -> None: async with moq.connect(args.url) as client: try: for truck in world.trucks: - publication = client.create_broadcast(broadcast_path(truck.name, args.camera)) + route = client.route(broadcast_path(truck.name, args.camera), hidden=True) video = await bridge.open( - bridge_stream(truck.name, args.camera), renditions(camera), publication.broadcast + bridge_stream(truck.name, args.camera), renditions(camera), route.broadcast ) - session = TruckSession(truck, publication, video, args.location, map_name, world.clock) + session = TruckSession(truck, route, video, args.location, map_name, world.clock) sessions.append(session) log.info( "publishing %s, consuming %s/*", diff --git a/demo/carla/sim/moq_carla_sim/runtime.py b/demo/carla/sim/moq_carla_sim/runtime.py index 149d46ba746..c68b85e86b8 100644 --- a/demo/carla/sim/moq_carla_sim/runtime.py +++ b/demo/carla/sim/moq_carla_sim/runtime.py @@ -93,19 +93,21 @@ class TruckSession: def __init__( self, truck: Truck, - publication: moq.Publication, + route: moq.Route, video: BridgeStream, location: str | None, map_name: str | None, clock: Clock, ) -> None: self._truck = truck + # Held for the session's lifetime: dropping the route retracts the broadcast. + self._route = route self._video = video self._clock = clock self._location = location self._map_name = map_name self._drive = Drive() - self._status = StatusPublisher(publication.broadcast) + self._status = StatusPublisher(route.broadcast) # Bounded: drivers are untrusted publishers, so an unbounded queue is a # memory-growth path under one that floods; a full queue instead blocks # that driver's own task. @@ -113,12 +115,12 @@ def __init__( self._media_pipeline: dict[str, list[dict[str, Any]]] = {} self._deadline: float | None = None self._stuck = StuckDetector() - # A broadcast starts unadvertised; the player discovers trucks by - # announcement, so advertise once the status and video tracks exist. - # The stream's are there already: opening it advertised them. The - # broadcast mints a fresh instance, so viewers see a restarted worker - # as a restart rather than a stalled broadcast. - publication.announce() + # The route starts hidden; the player discovers trucks by announcement, + # so advertise once the status and video tracks exist. The stream's are + # there already: opening it advertised them. The route mints a fresh + # instance, so viewers see a restarted worker as a restart rather than + # a stalled broadcast. + route.announce() def stop_video(self) -> None: """End the video tracks cleanly and stop the bridge encoding them.""" diff --git a/demo/carla/sim/tests/test_runtime.py b/demo/carla/sim/tests/test_runtime.py index 1cb2d4bd707..420fae4d4c6 100644 --- a/demo/carla/sim/tests/test_runtime.py +++ b/demo/carla/sim/tests/test_runtime.py @@ -366,10 +366,10 @@ async def sleep(delay: float) -> None: def test_session_announces_after_populating_tracks() -> None: - """The player lists trucks from announcements, and a broadcast starts - unadvertised, so a session that never announces is invisible.""" + """The player lists trucks from announcements, and the route starts hidden, + so a session that never announces is invisible.""" calls: list[object] = [] - publication = SimpleNamespace( + route = SimpleNamespace( broadcast=SimpleNamespace( publish_track=lambda name, info=None: calls.append(name) or SimpleNamespace(demand=SimpleNamespace) ), @@ -377,7 +377,7 @@ def test_session_announces_after_populating_tracks() -> None: ) # The video tracks were advertised when the bridge stream opened. - runtime.TruckSession(SimpleNamespace(name="truck1"), publication, SimpleNamespace(), None, None, FakeClock()) + runtime.TruckSession(SimpleNamespace(name="truck1"), route, SimpleNamespace(), None, None, FakeClock()) assert calls == ["status", "announce"] diff --git a/doc/bin/obs.md b/doc/bin/obs.md index b91e8ea8992..c8764b284c0 100644 --- a/doc/bin/obs.md +++ b/doc/bin/obs.md @@ -12,7 +12,7 @@ OBS Studio install. - **Subscribe**: add a "MoQ Source", enter the relay URL and broadcast path, and the stream appears in the scene. - **Dock**: a **MoQ** dock with Go Live, encoding that uses the OBS Output settings or custom settings for this stream only, and live stats (protocol, RTT, bandwidth, loss), and the reason while a stream connects or reconnects. -Each Start Streaming publishes under a fresh instance. The client's automatic +Each Start Streaming publishes under a fresh instance, which the dock shows. The client's automatic reconnects keep the same instance. A stop/start, or an OBS auto-reconnect after the client gives up, republishes the broadcast under a new instance, which viewers see as a new stream. diff --git a/doc/lib/c/index.md b/doc/lib/c/index.md index 46017ac2560..e25f8ef14e8 100644 --- a/doc/lib/c/index.md +++ b/doc/lib/c/index.md @@ -68,25 +68,29 @@ if (session < 0) ```c const char *path = "my-stream.hang"; -uint32_t broadcast; -int publication = moq_origin_create_broadcast(origin, path, strlen(path), &broadcast); -if (publication < 0) +moq_route_options options; +memset(&options, 0, sizeof(options)); // zeroed means visible, cost 0, a fresh instance +options.hidden = true; // fill the catalog before anyone finds it +int route = moq_origin_route(origin, path, strlen(path), &options); +if (route < 0) return fail(moq_error()); -// Fill tracks on broadcast here; announce on the publication. - -moq_announce_route route; -memset(&route, 0, sizeof(route)); // zeroed means cost 0 and the minted instance -if (moq_publication_announce((uint32_t)publication, &route) < 0) +int broadcast = moq_route_broadcast((uint32_t)route); +// Fill tracks on broadcast here, then make the route visible. +if (moq_route_announce((uint32_t)route) < 0) return fail(moq_error()); ``` -A route carries only a cost and the stream's instance; relays add the hops. Each -publication mints a fresh instance and keeps it across re-announcing, so a restarted -publisher is a new stream viewers restart onto (`MOQ_ANNOUNCE_KIND_RESTART`) instead of a +The route keeps the broadcast announced: `moq_route_free()` retracts it, and +`moq_publish_close()` ends both. A route carries only a cost and the stream's instance; +relays add the hops. Each route mints a fresh instance (`moq_route_instance()`) and keeps it +across `moq_route_withdraw()` and `moq_route_announce()`, so a restarted publisher, being a +new route, is a new stream viewers restart onto (`MOQ_ANNOUNCE_KIND_RESTART`) instead of a stalled broadcast. Set `instance` only for a publisher that continues its group sequences across restarts, and raise `epoch` on each: readers stitch every route of one instance together, so restarting the sequences under an old instance splices unrelated groups into -their tracks. +their tracks. To serve paths on demand, `moq_origin_route_prefix()` delivers each request to +answer with `moq_broadcast_request_serve()`, `moq_broadcast_request_route()`, or +`moq_broadcast_request_reject()`. Raw video encoders take an exact numerator/denominator frame rate, such as 30000/1001. Publication track names stay separate from codec settings. For simulcast, give each rendition the next one down as the `lower` handle in its `moq_video_encode_options`: it stops encoding, advertised as disabled, while its bandwidth grant cannot fund it, and resumes once the grant recovers. A rung only disables while the session probes for bandwidth, which on native transports takes moq-quic with BBR3. @@ -108,7 +112,7 @@ inside. The header is the reference: each function carries a doc comment. - **Audio needs cuts.** Video groups at its keyframes, but audio forms a group only where you call `moq_publish_media_cut`: after every frame, or at a segment cadence to align with video. Pass that cadence as `moq_audio_init.hint.group_duration_us`. - **Catalog hints.** Give the catalog what the encoder knows instead of having it estimated: `moq_video_init.hint` (coded size, bitrate, frame rate, group duration) and `moq_audio_init.hint` (bitrate, group duration). A supplied bitrate is never re-estimated. `group_duration_us` is the longest span between two group starts: the GOP, or your cut cadence. Leave a field's `has_*` flag false to have it measured. A bitrate or `group_duration_us` flag set with a 0 value returns `MOQ_ERROR_INVALID_CONFIG`. - **Discovery.** Announcement captures are always a list of wildcard matches, empty when the filter has no wildcards. -- **Ending cleanly.** When the input ends, finish every track, then call `moq_publish_catalog_finish()` to finish the catalog, which ends the content. The broadcast stays announced and keeps serving the finished tracks, so a subscriber still catching up can drain them, until `moq_publish_close()` takes it offline. How long to keep it up is yours to decide. A track still open at the close ends with `UNROUTABLE` (an internal error over moq-transport, which has no such code), and its handle is released. Readers follow a publisher's runs by announcement, not by that error: see [identity and recovery](/concept/identity). +- **Ending cleanly.** When the input ends, finish every track, then call `moq_publish_catalog_finish()` to finish the catalog, which ends the content. The broadcast stays announced and keeps serving the finished tracks, so a subscriber still catching up can drain them, until `moq_publish_close()` or `moq_route_free()` takes it offline. How long to keep it up is yours to decide. A track still open at the close ends with `UNROUTABLE` (an internal error over moq-transport, which has no such code), and its handle is released. Readers follow a publisher's runs by announcement, not by that error: see [identity and recovery](/concept/identity). - **Timeline breaks.** On a seek or pause, call `moq_publish_media_discontinuity`, then keep timestamps moving forward and resume video on a keyframe. - **Timestamps.** A `moq_timestamp` is exact: `value` units at `scale` units per second, so a 90 kHz tick survives a read and republish. Frames, datagrams, and JSON values point `timestamp` at theirs, NULL on an untimed track and valid as long as the payload. Tracks moq-c creates are timed, so their raw writes need one. Stamp media frames and JSON writes from `moq_publish_catalog_now()`, the broadcast clock every track in the broadcast shares; media on a timeline of its own advertises the gap to the JSON tracks as catalog `delay`. JSON writes are converted to their track's milliseconds. A NULL timestamp on any JSON write (snapshot update, stream append, window push or pop) fails with `MOQ_ERROR_INVALID_POINTER` and publishes nothing. A zero scale or an out-of-range value fails with `MOQ_ERROR_TIMESTAMP_OVERFLOW`. - **JSON values.** `moq_consume_json_value` fills `moq_json_value` with the document and its frame's timestamp. A snapshot consumer's callback fires for each state in order, but a group superseded before it is read is skipped. diff --git a/doc/lib/cpp/index.md b/doc/lib/cpp/index.md index 7ca3caf14e1..e9653beb0c3 100644 --- a/doc/lib/cpp/index.md +++ b/doc/lib/cpp/index.md @@ -136,8 +136,10 @@ A raw `moq::Frame` with `std::nullopt` is untimed. // Publish encoded frames, or raw pixels with the codec inside the binding. // session is connected as above; opus_init, packet, and rgba come from your // encoder or capture source. -auto publication = ok(session->publish()->create_broadcast("my-stream.hang")); -auto broadcast = publication->broadcast(); // fill tracks here; announce on the publication +moq::RouteOptions options; +options.hidden = true; // fill tracks before anyone finds it; hold the route to stay announced +auto route = ok(session->publish()->route("my-stream.hang", options)); +auto broadcast = ok(route->broadcast()); auto audio = ok(moq::MediaTrackProducer::audio(broadcast, moq::MediaTarget::kNamed{}, {moq::AudioFormat::kOpus, opus_init})); ok(audio->write_frame({packet, moq::Timestamp{960, 48'000}})); // 20 ms @@ -145,8 +147,8 @@ moq::VideoEncoderOutput output{moq::VideoCodec::kH264, std::nullopt, std::nullop auto catalog = ok(moq::MediaCatalogProducer::init(broadcast)); auto video = ok(moq::VideoProducer::init(catalog, {{moq::VideoPixelFormat::kRgba, 1280, 720, {30000, 1001}}, output, "camera", nullptr})); ok(video->write({{0, 30'000}, rgba})); -ok(publication->announce({})); // each broadcast mints a fresh instance -ok(broadcast->close()); // keep the producer alive while publishing, then close explicitly +ok(route->announce()); // each route mints a fresh instance, route->instance() +ok(broadcast->close()); // keep the producer alive while publishing, then close explicitly ``` Raw video encoders take an exact numerator/denominator frame rate, such as 30000/1001. Producer options hold input, codec settings, track naming, and optional session bandwidth ownership; standalone encoders take only codec settings. For simulcast, give each rendition the next one down as `lower`: it stops encoding, advertised as disabled, while its bandwidth grant cannot fund it, and resumes once the grant recovers. A rung only disables while the session probes for bandwidth, which on native transports takes moq-quic with BBR3. A pre-encoded video track takes `lower` in its `VideoInit` too, as a `moq::MediaProducer::kTrack` or `kStream`, which only places it one priority below; follow its reservation with `RateControl`, and while it reports disabled, drop the frames, call `set_enabled(false)` after a `discontinuity()`, and `set_enabled(true)` on the keyframe that resumes it. A `MediaTrackStreamProducer` finds its own frames: `set_enabled(false)` drops what is written to it, and after `set_enabled(true)` it resumes at the stream's next keyframe. diff --git a/doc/lib/dart/index.md b/doc/lib/dart/index.md index 1eeca556ee1..42df877e038 100644 --- a/doc/lib/dart/index.md +++ b/doc/lib/dart/index.md @@ -82,7 +82,8 @@ print(await catalog.next()); // Publish raw pixels; the binding encodes them. rgba and pts come from your capture source. import 'package:moq/video.dart' as video; -final camera = moq.createBroadcast('live/camera'); +// Hidden until announced, so the catalog is filled before anyone finds it. +final camera = moq.route('live/camera', options: RouteOptions(hidden: true)); final encoder = video.Producer( catalog: media.CatalogProducer(broadcast: camera.broadcast()), options: video.ProducerOptions( @@ -100,7 +101,7 @@ final encoder = video.Producer( ), ); encoder.write(frame: video.Frame(timestamp: pts, data: rgba)); -camera.announce(route: AnnounceRoute()); +camera.announce(); encoder.finish(); ``` @@ -127,15 +128,15 @@ if (read is video.ReadFrame) { ```dart // Publish already-encoded frames. bytes comes from your encoder or application source. -final publication = moq.createBroadcast('live/camera'); -final mine = publication.broadcast(); +final route = moq.route('live/camera'); // visible at once, under a fresh instance +print(route.instance()); +final mine = route.broadcast(); final track = mine.publishTrack(name: 'video', info: null); final group = track.appendGroup(); group.writeFrame(frame: Frame(payload: bytes, timestamp: null)); group.finish(); -publication.announce(route: AnnounceRoute()); // the broadcast mints its own instance track.finish(); -mine.close(); +mine.close(); // ends the route too await moq.close(); ``` @@ -148,13 +149,14 @@ The rest of the [shared feature list](/lib/#what-every-binding-can-do) maps one to one; the API reference has the names, and [Layers](/lib/layers) shows which module holds each. -- **Names.** Types drop the `Moq` prefix (`Session`, `BroadcastProducer`) as aliases, so the generated names still work. `Container`, `Route`, and the exceptions keep it, since Flutter owns those names. +- **Names.** Types drop the `Moq` prefix (`Session`, `BroadcastProducer`, `RouteOptions`) as aliases, so the generated names still work. `MoqContainer`, `MoqRoute`, and the exceptions keep it, since Flutter owns those names. +- **Routes.** `route(path)` publishes a broadcast and `routePrefix(prefix)` answers requests beneath a prefix, each returning a `MoqRoute`. Hold it: cancelling or disposing it retracts the route, while a broadcast handle alone does not keep it announced. It keeps its instance across `withdraw()` and `announce()`, so a new run is a new route. - **Audio needs cuts.** Video groups at its keyframes, but audio forms a group only where you call `cut()`: after every frame, or at a segment cadence to align with video. - **Timeline breaks.** On a seek or pause, call `discontinuity()`, then keep timestamps moving forward and resume video on a keyframe. - **Media reads.** `media.TrackConsumer`, `audio.Consumer`, and `video.Consumer` return a `Read` in order: a `ReadFrame`, a `ReadGap` where media was lost, or a `ReadEnd` where the publisher stopped its encoder. A gap breaks continuity. An encoder end is not stream EOF: following frames before its endpoint are the old encoder's drain; the first at or past it starts fresh. A decoder reads everything the track still holds unless a live player sets `start: media.DecodeStart.latest` in its decoder output, which joins at the newest group and skips the cached backlog. - **Decoded frames hold decoder buffers.** `dispose()` each frame from a `video.Consumer` promptly rather than waiting for the garbage collector, or the decoder stalls. `resize` is best effort, so read each frame's `width()` and `height()`. - **Closing.** `await moq.close()` drains for up to one second and reports its result. `session.shutdown()` requests the drain synchronously; `await session.closed()` waits for its result. `session.cancel(code: 0)` closes at once. Finish or abort live tracks first. Awaiting cancellation of an announcement, grant, or request subscription releases its pending native read. Announcements and grants also release their consumer; server listeners leave their shared server usable. moq-lite-05 and newer wait for the peer to receive finished tails; older Lite versions and IETF wait only for transport ACKs. -- **Ending cleanly.** When the input ends, finish every track, then call `finish()` on its `CatalogProducer` to finish the catalog, which ends the content. The broadcast stays announced and keeps serving the finished tracks, so a subscriber still catching up can drain them, until `broadcast.close()` takes it offline; disposing its `Publication` does not. How long to keep it up is yours to decide. A track still open at the close, or released without a finish, ends with `Unroutable` (`Internal` over moq-transport, which has no such code). Readers follow a publisher's runs by announcement, not by that error: see [identity and recovery](/concept/identity). +- **Ending cleanly.** When the input ends, finish every track, then call `finish()` on its `CatalogProducer` to finish the catalog, which ends the content. The broadcast stays announced and keeps serving the finished tracks, so a subscriber still catching up can drain them, until `broadcast.close()` or disposing its `MoqRoute` takes it offline. How long to keep it up is yours to decide. A track still open at the close, or released without a finish, ends with `Unroutable` (`Internal` over moq-transport, which has no such code). Readers follow a publisher's runs by announcement, not by that error: see [identity and recovery](/concept/identity). - **Stats.** `session.stats()` reports `rtt`, `estimatedSendRateBps`, and the byte and packet counters (`bytesSent`, `bytesReceived`, `bytesLost`, `packetsSent`, `packetsReceived`, `packetsLost`). A field is `null` when the transport does not report it, which is not the same as zero. `version` names the negotiated protocol. Connect returns a connecting session; read its coherent `state()` snapshot and wait with that snapshot's revision to observe first-dial failures and reconnects. Each watcher keeps its own revision. Hold the owned `BandwidthConsumer` returned by `session.recvBandwidth()` to receive bandwidth estimates. `rate()` reads the current estimate in bits per second and `rateChanged()` waits for a new one. Release the consumer or call `cancel()` when finished; releasing the last consumer stops PROBE; the session and stats snapshots do not request it. Client consumers survive reconnects and report no estimate while disconnected. - **Authorization.** On `moq-lite-07-wip` (opt in with `ConnectOptions(versions: ...)`) and on moq-transport draft-18+ with the [MoQ Auth extension](/draft/moq-auth), listen to `moq.grants().updates()` for the `Grant` the relay sent back and each change, `null` until it answers and while a client session reconnects. - **Tokens.** Pass `ConnectOptions(tokens: [...])` instead of putting the credential in the URL. The first is the connection credential, sent in SETUP and, while an offered version can't carry it there (lite before 07), as the URL's `?jwt=`; each other token widens the grant over AUTH. `moq.tokens().set_(tokens: [...])` replaces them before they expire: the next dial presents them, a live AUTH session at once, and after an authorization refusal the session redials only if they changed. `await tokens().answered()` returns once the relay accepts them and throws its refusal with the relay's code. A `?jwt=` already in the URL stays the connection credential, which is how to reach a relay older than this release. diff --git a/doc/lib/go/index.md b/doc/lib/go/index.md index ba330f0ee0c..c5ce88292aa 100644 --- a/doc/lib/go/index.md +++ b/doc/lib/go/index.md @@ -98,8 +98,9 @@ import ( // Publish encoded frames, or raw pixels with the codec inside the binding. // opusInit, packet, pts (90 kHz ticks), and rgba come from your encoder or capture source. -publication, _ := client.CreateBroadcast("my-stream.hang") -broadcast := publication.Broadcast() +// Hidden until the catalog is filled; keep the route reachable while publishing. +route, _ := client.Route("my-stream.hang", moq.RouteOptions{Hidden: true}) +broadcast, _ := route.Broadcast() audio, _ := moqmedia.NewAudioTrackProducer(broadcast, moqmedia.Named{}, moqmedia.AudioInit{Format: moqmedia.AudioFormatOpus, Data: opusInit}) timestamp := moq.Timestamp{Value: 960, Scale: 48_000} // 20 ms on the Opus sample clock _ = audio.WriteFrame(moq.Frame{Payload: packet, Timestamp: ×tamp}) @@ -113,7 +114,7 @@ video, _ := moqvideo.NewProducer(catalogProducer, moqvideo.ProducerOptions{ Track: &track, }) _ = video.Write(moqvideo.Frame{Timestamp: moq.Timestamp{Value: pts, Scale: 90_000}, Data: rgba}) -_ = publication.Announce(moq.AnnounceRoute{}) // each broadcast mints a fresh instance +_ = route.Announce() // each route mints a fresh instance (route.Instance()) _ = audio.Finish() _ = video.Finish() broadcast.Close() // keep the producer reachable while publishing, then close explicitly @@ -128,7 +129,7 @@ one to one; the API reference has the names, and [Layers](/lib/layers) shows which module holds each. - **Context cancellation.** Every call that can block takes a `context.Context` first, and cancelling it tears down the native work, not just your wait. A one-shot call (`Request`, `FetchGroup`, `Server.Accept`) aborts alone; a stream read (`Next`, `ReadFrame`, and the iterators over them) cancels the stream it reads. -- **Keep owners reachable.** An origin from `moq.NewOriginProducer` has no `Close`. It ends when the garbage collector reaches its last owner (each producer, published broadcast, and `OriginRequests`), and its consumers then fail with `moq.ErrClosed`. +- **Keep owners reachable.** An origin from `moq.NewOriginProducer` has no `Close`. It ends when the garbage collector reaches its last owner (each producer and `Route`), and its consumers then fail with `moq.ErrClosed`. A `Route` the collector reclaims is retracted, so keep it reachable while it should stay announced, or end it with `Cancel()`. - **Bandwidth ownership.** An encoder you manage can reserve a share of the session's bandwidth. Reuse its reservation when the ceiling changes; before abandoning or replacing it, call `Update(0)` to return its share and automatic probe ceiling without waiting for garbage collection. The track can stay subscribed and the reservation can be reused. - **Audio needs cuts.** Video groups at its keyframes, but audio forms a group only where you call `Cut()`: after every frame, or at a segment cadence to align with video. - **Timeline breaks.** On a seek or pause, call `Discontinuity()`, then keep timestamps moving forward and resume video on a keyframe. diff --git a/doc/lib/kt/index.md b/doc/lib/kt/index.md index 627039d98da..25bbcd6a561 100644 --- a/doc/lib/kt/index.md +++ b/doc/lib/kt/index.md @@ -74,8 +74,9 @@ Moq.connect("https://relay.example.com", ClientConfig(tls = ClientTls(roots = li // Publish encoded frames, or raw pixels with the codec inside the binding. // opusInit, packet, pts, and rgba come from your encoder or capture source. Moq.connect("https://relay.example.com").use { moq -> - val publication = moq.createBroadcast("my-stream.hang") - val broadcast = publication.broadcast() + // Hidden until the catalog is filled; hold the route while it should stay announced. + val route = moq.route("my-stream.hang", RouteOptions(hidden = true)) + val broadcast = route.broadcast() val audio = dev.moq.media.TrackProducer.audio(broadcast, Named(null), AudioInit(format = AudioFormat.OPUS, data = opusInit)) audio.writeFrame(Frame(payload = packet, timestamp = Timestamp(960u, 48_000u))) audio.cut() // audio has no keyframes, so this is what gives it groups @@ -86,7 +87,7 @@ Moq.connect("https://relay.example.com").use { moq -> output = VideoEncoderOutput(codec = VideoCodec.H264, bitrate = null, gop = null, kind = autoEncoder), track = "camera"), ) video.write(VideoFrame(timestamp = pts, data = rgba)) - publication.announce(AnnounceRoute()) // the broadcast mints its own instance + route.announce() // the route mints its own instance: route.instance() audio.finish() video.finish() broadcast.end() @@ -103,7 +104,7 @@ The rest of the [shared feature list](/lib/#what-every-binding-can-do) maps one to one; the API reference has the names, and [Layers](/lib/layers) shows which module holds each. -- **`end`, not `close`.** `broadcast.end()` ends a broadcast for good. `close()`, or leaving `use { }`, releases the handle, which ends the broadcast only once no other handle to it remains, such as its publication or a `requests()` handle. +- **`end`, not `close`.** `broadcast.end()` ends a broadcast for good, retracting its route. `close()`, or leaving `use { }`, releases the handle, which ends the broadcast only once no other handle to it remains, such as its route or a `requests()` handle. A route is the opposite: closing it retracts it at once, so hold it while the broadcast should stay announced. - **Audio needs cuts.** Video groups at its keyframes, but audio forms a group only where you call `cut()`: after every frame, or at a segment cadence to align with video. - **Timeline breaks.** On a seek or pause, call `discontinuity()`, then keep timestamps moving forward and resume video on a keyframe. - **Media reads.** `dev.moq.media.TrackConsumer`, `dev.moq.audio.Consumer`, and `dev.moq.video.Consumer` return a `Read` in order: `ReadFrame`, a `ReadGap` where media was lost, or a `ReadEnd` where the publisher stopped its encoder. A gap breaks continuity. An encoder end is not stream EOF: following frames before its endpoint are the old encoder's drain; the first at or past it starts fresh. A decoder reads everything the track still holds unless a live player sets `start = DecodeStart.LATEST` in its decoder output, which joins at the newest group and skips the cached backlog. diff --git a/doc/lib/py/index.md b/doc/lib/py/index.md index c254b20b60c..05948d53e6c 100644 --- a/doc/lib/py/index.md +++ b/doc/lib/py/index.md @@ -71,8 +71,9 @@ import asyncio, moq async def main(): # opus_init_bytes, payload, pts, and rgba come from your encoder or capture source. async with moq.Client("https://cdn.moq.dev/anon") as client: - publication = client.create_broadcast("my-stream.hang") - broadcast = publication.broadcast + # Hidden until announced, so viewers find a filled catalog. Hold the route: dropping it retracts it. + route = client.route("my-stream.hang", hidden=True) + broadcast = route.broadcast # Already-encoded frames: the catalog is filled from the bitstream audio = moq.media.TrackProducer.audio(broadcast, moq.media.AudioInit(format=moq.media.AudioFormat.OPUS, data=opus_init_bytes)) @@ -99,7 +100,7 @@ async def main(): status = moq.json.SnapshotProducer(broadcast, status_track) status.update({"state": "live", "viewers": 42}, catalog_producer.now()) - publication.announce() # each broadcast mints a fresh instance + route.announce() # each route mints a fresh instance, route.instance audio.finish() video.finish() events.finish() diff --git a/doc/lib/swift/index.md b/doc/lib/swift/index.md index 94086cb8a15..90d0a05025e 100644 --- a/doc/lib/swift/index.md +++ b/doc/lib/swift/index.md @@ -74,8 +74,9 @@ for try await event in try session.consume.announced(prefix: "live/", filter: "* ```swift // Publish encoded frames, or raw pixels with the codec inside the binding (VideoToolbox). // opusInit, packet, pts, and rgba come from your encoder or capture source. -let publication = try session.publish.createBroadcast(path: "my-stream.hang") -let broadcast = publication.broadcast +// Hidden until the catalog is filled; hold the route while it should stay announced. +let route = try session.publish.route(path: "my-stream.hang", hidden: true) +let broadcast = try route.broadcast let audio = try Media.TrackProducer.audio(broadcast: broadcast, initData: Media.AudioInit(format: .opus, data: opusInit)) try audio.writeFrame(packet, timestamp: Timestamp(value: 20, scale: 1_000)) try audio.cut() // audio has no keyframes, so this is what gives it groups @@ -87,7 +88,7 @@ let video = try Video.Producer( track: "camera" ) try video.write(VideoFrame(timestamp: pts, data: rgba)) -try publication.announce(route: AnnounceRoute()) // the broadcast mints its own instance +try route.announce() // the route mints its own instance: route.instance try audio.finish() try video.finish() try broadcast.close() @@ -109,7 +110,7 @@ shows which module holds each. - **Media reads.** `Media.TrackConsumer`, `Audio.Consumer`, and `Video.Consumer` yield `Read` cases in order: `.frame`, a `.gap` where media was lost, or an `.end` where the publisher stopped its encoder. A gap breaks continuity. An encoder end is not stream EOF: following frames before its endpoint are the old encoder's drain; the first at or past it starts fresh. A decoder reads everything the track still holds unless a live player sets `start: .latest` in its decoder output, which joins at the newest group and skips the cached backlog. - **Decoded frames hold decoder buffers.** Release each frame from a `Video.Consumer` promptly, or the decoder stalls. `resize` is best effort, so read each frame's `width()` and `height()`. - **Closing.** `session.shutdown()` requests a drain immediately; `try await session.closed()` waits up to one second and reports its result. `session.cancel(code:)` closes at once. Finish or abort live tracks first. moq-lite-05 and newer wait for the peer to receive finished tails; older Lite versions and IETF wait only for transport ACKs. -- **Ending cleanly.** When the input ends, finish every track, then call `try finish()` on its `Media.CatalogProducer` to finish the catalog, which ends the content. The broadcast stays announced and keeps serving the finished tracks, so a subscriber still catching up can drain them, until `broadcast.close()` takes it offline. How long to keep it up is yours to decide. A track still open at the close, or released without a finish, ends with `Unroutable` (`Internal` over moq-transport, which has no such code). Readers follow a publisher's runs by announcement, not by that error: see [identity and recovery](/concept/identity). +- **Ending cleanly.** When the input ends, finish every track, then call `try finish()` on its `Media.CatalogProducer` to finish the catalog, which ends the content. The broadcast stays announced and keeps serving the finished tracks, so a subscriber still catching up can drain them, until `broadcast.close()`, or releasing its route, takes it offline. How long to keep it up is yours to decide. A track still open at the close, or released without a finish, ends with `Unroutable` (`Internal` over moq-transport, which has no such code). Readers follow a publisher's runs by announcement, not by that error: see [identity and recovery](/concept/identity). - **Stats.** `session.stats()` reports `rtt`, `estimatedSendRateBps`, and the byte and packet counters (`bytesSent`, `bytesReceived`, `bytesLost`, `packetsSent`, `packetsReceived`, `packetsLost`). A field is `nil` when the transport does not report it, which is not the same as zero. `version` names the negotiated protocol. Connect returns a connecting session; read its coherent `state()` snapshot and wait with that snapshot's revision to observe first-dial failures and reconnects. Each watcher keeps its own revision. Hold the owned `BandwidthConsumer` returned by `session.recvBandwidth()` to receive bandwidth estimates. `rate()` reads the current estimate in bits per second and `rateChanged()` waits for a new one. Release the consumer or call `cancel()` when finished; releasing the last consumer stops PROBE; the session and stats snapshots do not request it. Client consumers survive reconnects and report no estimate while disconnected. - **Authorization.** On `moq-lite-07-wip` (opt in with `Client(versions:)`) and on moq-transport draft-18+ with the [MoQ Auth extension](/draft/moq-auth), `for try await grant in session.grants()` yields the `Grant` the relay sent back and each change, `nil` until it answers and while a client session reconnects. Cancelling the iterating task cancels the native wait. - **Tokens.** Pass `Client(tokens: [...])` instead of putting the credential in the URL. The first is the connection credential, sent in SETUP and, while an offered version can't carry it there (lite before 07), as the URL's `?jwt=`; each other token widens the grant over AUTH. `try session.tokens()?.set([...])` replaces them before they expire: the next dial presents them, a live AUTH session at once, and after an authorization refusal the session redials only if they changed. `try await tokens.answered()` returns once the relay accepts them and throws its refusal with the relay's code. A `?jwt=` already in the URL stays the connection credential, which is how to reach a relay older than this release. diff --git a/go/wrapper/MIGRATE.md b/go/wrapper/MIGRATE.md index 86416d17b97..55b8ead817a 100644 --- a/go/wrapper/MIGRATE.md +++ b/go/wrapper/MIGRATE.md @@ -4,6 +4,22 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Publishing goes through one `Route` + +`OriginProducer.CreateBroadcast(path)`, `Client.CreateBroadcast`, and `Server.CreateBroadcast` are `Route(path, moq.RouteOptions{})`, and `OriginProducer.Requests(prefix)` is `RoutePrefix(prefix, moq.RouteOptions{})`. Both return a `*Route`, which replaces `*Publication`, `*OriginRequests`, and `*BroadcastPrepared`: + +- `Publication.Broadcast()` is `Route.Broadcast()`, which now also returns an error, on a prefix route. +- `Publication.Announce(moq.AnnounceRoute{...})` is `Announce()`, and re-pricing is `SetCost(cost)`. `Unannounce()` is `Withdraw()`. +- `OriginRequests.RequestedBroadcast(ctx)` is `Route.Requested(ctx)`, which returns `(nil, nil)` once the origin closes; `All(ctx)` and `Cancel()` keep their names. Cancelling ctx no longer retracts the route, only the wait. +- `BroadcastRequest.Prepare()` then `BroadcastPrepared.Publish()` is `BroadcastRequest.Route(options)`: create it hidden to fill it first, then `Announce()`. `BroadcastPrepared.Close()` is `Route.Cancel()`. +- `Route.Instance()` is the stream's instance, minted at creation and kept across `Withdraw` and `Announce`. + +`moq.AnnounceRoute` is `moq.RouteOptions{Hidden, Cost, Instance, Epoch}`, given once at creation. A route is visible at once unless `Hidden`; set it and call `Announce()` after filling the catalog to keep the old create-then-announce order. A stable `Instance` is fixed for the route's lifetime: announcing another one is a new route. + +Keep the `*Route` reachable for as long as the broadcast should stay announced: the collector reclaiming it, or `Cancel()`, retracts it, while `BroadcastProducer.Close()` still ends both. A `*BroadcastProducer` alone no longer keeps it announced. + +`moq.Route`, the received facts in `Announce.Route`, is renamed `moq.RouteInfo`; its fields are unchanged. + ### `media.VideoInit.Lower` is a `media.Producer` ([#7699](https://github.com/moq-dev/moq/pull/7699)) `Lower` is the `media.Producer` interface instead of `*media.TrackProducer`, so a `*media.TrackStreamProducer` fits too. Assigning a `*media.TrackProducer`, nil included, compiles unchanged; code that reads `Lower` back type-asserts it. diff --git a/go/wrapper/README.md b/go/wrapper/README.md index 4ef501f19bc..fb602f5f56a 100644 --- a/go/wrapper/README.md +++ b/go/wrapper/README.md @@ -125,8 +125,8 @@ import ( moqmedia "moq.dev/moq/media" ) -publication, _ := client.CreateBroadcast("room") -broadcast := publication.Broadcast() +route, _ := client.Route("room", moq.RouteOptions{Hidden: true}) +broadcast, _ := route.Broadcast() // Every JSON write is stamped, so the track is timed. JSON is small and repetitive, so // compress it on the wire. scale := uint64(1_000) @@ -135,7 +135,7 @@ status, _ := moqjson.NewSnapshotProducer(broadcast, track, moqjson.SnapshotOptio catalog, _ := moqmedia.NewCatalogProducer(broadcast) now, _ := catalog.Now() _ = status.Update(map[string]any{"viewers": 42}, now) -_ = publication.Announce(moq.AnnounceRoute{}) +_ = route.Announce() ``` Snapshot and window producers take `SnapshotOptions` or `WindowOptions`; the stream producer and diff --git a/go/wrapper/client.go b/go/wrapper/client.go index 87f37134d71..990542c2366 100644 --- a/go/wrapper/client.go +++ b/go/wrapper/client.go @@ -300,11 +300,11 @@ func Dial(ctx context.Context, url string, config ClientConfig) (*Client, error) return c, nil } -// CreateBroadcast creates an unannounced broadcast at path, invisible to everyone until announced. Announce it after populating tracks. +// Route creates a route at exactly path on the publish origin, owning a new broadcast to fill. // -// See [OriginProducer.CreateBroadcast]. -func (c *Client) CreateBroadcast(path string) (*Publication, error) { - return c.publisher.CreateBroadcast(path) +// See [OriginProducer.Route]. +func (c *Client) Route(path string, options RouteOptions) (*Route, error) { + return c.publisher.Route(path, options) } // Announced streams routes announced by the remote under a pattern scope. diff --git a/go/wrapper/example_test.go b/go/wrapper/example_test.go index da49aff1e08..d1bfd03b1e6 100644 --- a/go/wrapper/example_test.go +++ b/go/wrapper/example_test.go @@ -40,7 +40,7 @@ func ExampleClient_Announced() { } // Publish a media track to a relay. -func ExampleClient_CreateBroadcast() { +func ExampleClient_Route() { ctx := context.Background() client, err := moq.Dial(ctx, "https://relay.example.com", moq.ClientConfig{}) @@ -49,17 +49,22 @@ func ExampleClient_CreateBroadcast() { } defer client.Close() - publication, err := client.CreateBroadcast("me/mic") + // Hidden until the catalog is filled; hold the route while it should stay announced. + route, err := client.Route("me/mic", moq.RouteOptions{Hidden: true}) + if err != nil { + log.Fatal(err) + } + defer route.Cancel() + broadcast, err := route.Broadcast() if err != nil { log.Fatal(err) } - broadcast := publication.Broadcast() media, err := moqmedia.NewAudioTrackProducer(broadcast, moqmedia.Named{}, moqmedia.AudioInit{Format: moqmedia.AudioFormatOpus, Data: opusHead()}) if err != nil { log.Fatal(err) } - _ = publication.Announce(moq.AnnounceRoute{}) + _ = route.Announce() // 20 ms in, counted on the Opus 48 kHz sample clock. pts := moq.Timestamp{Value: 960, Scale: 48_000} diff --git a/go/wrapper/moq_test.go b/go/wrapper/moq_test.go index 73942d39b48..50937aea6fb 100644 --- a/go/wrapper/moq_test.go +++ b/go/wrapper/moq_test.go @@ -30,6 +30,22 @@ func newOrigin(t *testing.T) *moq.OriginProducer { return origin } +// newRoute creates an exact route on origin with its broadcast, kept reachable +// until the test ends: the collector reclaiming it would retract the route. +func newRoute(t *testing.T, origin *moq.OriginProducer, path string, options moq.RouteOptions) (*moq.Route, *moq.BroadcastProducer) { + t.Helper() + route, err := origin.Route(path, options) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { runtime.KeepAlive(route) }) + broadcast, err := route.Broadcast() + if err != nil { + t.Fatal(err) + } + return route, broadcast +} + // opusHead builds a valid OpusHead init buffer (RFC 7845): 48 kHz, 2 channels. func opusHead() []byte { buf := []byte("OpusHead") @@ -46,11 +62,14 @@ func TestDynamicBroadcastRequest(t *testing.T) { defer cancel() origin := newOrigin(t) - dynamic, err := origin.Requests("") + dynamic, err := origin.RoutePrefix("", moq.RouteOptions{}) if err != nil { t.Fatal(err) } defer dynamic.Cancel() + if _, err := dynamic.Broadcast(); err == nil { + t.Fatal("a prefix route owns no broadcast") + } type result struct { broadcast *moq.BroadcastConsumer @@ -62,7 +81,7 @@ func TestDynamicBroadcastRequest(t *testing.T) { requested <- result{broadcast: broadcast, err: err} }() - request, err := dynamic.RequestedBroadcast(ctx) + request, err := dynamic.Requested(ctx) if err != nil { t.Fatal(err) } @@ -74,18 +93,26 @@ func TestDynamicBroadcastRequest(t *testing.T) { t.Fatalf("path = %q, want %q", path, "dynamic/broadcast") } - prepared, err := request.Prepare() + served, err := request.Route(moq.RouteOptions{Hidden: true}) if err != nil { t.Fatal(err) } - track, err := prepared.Broadcast().PublishTrack("status", timedInfo()) + defer runtime.KeepAlive(served) + if served.Instance() == dynamic.Instance() { + t.Fatal("a job's route serves a fresh instance") + } + broadcast, err := served.Broadcast() if err != nil { t.Fatal(err) } - served, err := prepared.Publish() + track, err := broadcast.PublishTrack("status", timedInfo()) if err != nil { t.Fatal(err) } + // Only announcing answers the requester. + if err := served.Announce(); err != nil { + t.Fatal(err) + } var res result select { @@ -118,13 +145,20 @@ func TestDynamicBroadcastRequest(t *testing.T) { if err := track.Finish(); err != nil { t.Fatal(err) } - if err := served.Broadcast().Close(); err != nil { + if err := broadcast.Close(); err != nil { t.Fatal(err) } - // The publication fills the prepared broadcast, so closing one closes the other. - if _, err := prepared.Broadcast().PublishTrack("late", nil); !errors.Is(err, moq.ErrClosed) { + // The route hands out one broadcast, so closing it ends the route too. + again, err := served.Broadcast() + if err != nil { + t.Fatal(err) + } + if _, err := again.PublishTrack("late", nil); !errors.Is(err, moq.ErrClosed) { t.Fatalf("PublishTrack after close = %v, want ErrClosed", err) } + if err := served.Announce(); !errors.Is(err, moq.ErrClosed) { + t.Fatalf("Announce after close = %v, want ErrClosed", err) + } } func TestPublishAudioLifecycle(t *testing.T) { @@ -251,11 +285,7 @@ func TestAudioConsumerDelay(t *testing.T) { defer cancel() origin := newOrigin(t) - publication, err := origin.CreateBroadcast("audio-delay") - if err != nil { - t.Fatal(err) - } - broadcast := publication.Broadcast() + route, broadcast := newRoute(t, origin, "audio-delay", moq.RouteOptions{Hidden: true}) track := "mic" catalogProducer, err := moqmedia.NewCatalogProducer(broadcast) if err != nil { @@ -270,7 +300,7 @@ func TestAudioConsumerDelay(t *testing.T) { if err != nil { t.Fatal(err) } - if err := publication.Announce(moq.AnnounceRoute{}); err != nil { + if err := route.Announce(); err != nil { t.Fatal(err) } @@ -417,11 +447,7 @@ func testDecodeVideoFrame(t *testing.T, surface bool) { defer cancel() origin := newOrigin(t) - publication, err := origin.CreateBroadcast("video-decode-frame") - if err != nil { - t.Fatal(err) - } - broadcast := publication.Broadcast() + route, broadcast := newRoute(t, origin, "video-decode-frame", moq.RouteOptions{Hidden: true}) track := "camera" catalogProducer, err := moqmedia.NewCatalogProducer(broadcast) if err != nil { @@ -436,7 +462,7 @@ func testDecodeVideoFrame(t *testing.T, surface bool) { if err != nil { t.Fatal(err) } - if err := publication.Announce(moq.AnnounceRoute{}); err != nil { + if err := route.Announce(); err != nil { t.Fatal(err) } @@ -705,16 +731,12 @@ func TestLocalPublishConsumeAudio(t *testing.T) { defer cancel() origin := newOrigin(t) - publication, err := origin.CreateBroadcast("live") - if err != nil { - t.Fatal(err) - } - broadcast := publication.Broadcast() + route, broadcast := newRoute(t, origin, "live", moq.RouteOptions{Hidden: true}) media, err := moqmedia.NewAudioTrackProducer(broadcast, moqmedia.Named{}, moqmedia.AudioInit{Format: moqmedia.AudioFormatOpus, Data: opusHead()}) if err != nil { t.Fatal(err) } - if err := publication.Announce(moq.AnnounceRoute{}); err != nil { + if err := route.Announce(); err != nil { t.Fatal(err) } @@ -1246,7 +1268,7 @@ func TestConsumerCancelConcurrent(t *testing.T) { // that one request rather than the consumer it was made on. func TestRequestCancelKeepsTheOrigin(t *testing.T) { origin := newOrigin(t) - dynamic, err := origin.Requests("") + dynamic, err := origin.RoutePrefix("", moq.RouteOptions{}) if err != nil { t.Fatal(err) } @@ -1265,7 +1287,7 @@ func TestRequestCancelKeepsTheOrigin(t *testing.T) { // Take the request but never answer it, so the cancel lands on a call that is // genuinely parked rather than one that has not started. - pending, err := dynamic.RequestedBroadcast(waitCtx) + pending, err := dynamic.Requested(waitCtx) if err != nil { t.Fatal(err) } @@ -1289,19 +1311,15 @@ func TestRequestCancelKeepsTheOrigin(t *testing.T) { resolved <- err }() - next, err := dynamic.RequestedBroadcast(waitCtx) + next, err := dynamic.Requested(waitCtx) if err != nil { t.Fatal(err) } - prepared, err := next.Prepare() + served, err := next.Route(moq.RouteOptions{}) if err != nil { t.Fatal(err) } - served, err := prepared.Publish() - if err != nil { - t.Fatal(err) - } - defer served.Broadcast().Close() + defer runtime.KeepAlive(served) select { case err := <-resolved: if err != nil { @@ -1507,11 +1525,7 @@ func TestBroadcastIsReachableOnlyWhileAnnounced(t *testing.T) { defer cancel() origin := newOrigin(t) - publication, err := origin.CreateBroadcast("live") - if err != nil { - t.Fatal(err) - } - broadcast := publication.Broadcast() + route, broadcast := newRoute(t, origin, "live", moq.RouteOptions{Hidden: true}) if _, err := broadcast.PublishTrack("events", nil); err != nil { t.Fatal(err) } @@ -1520,7 +1534,10 @@ func TestBroadcastIsReachableOnlyWhileAnnounced(t *testing.T) { t.Fatal("an unannounced broadcast must be unroutable") } - if err := publication.Announce(moq.AnnounceRoute{Cost: 3}); err != nil { + if err := route.SetCost(3); err != nil { + t.Fatal(err) + } + if err := route.Announce(); err != nil { t.Fatal(err) } announced, err := consumer.Announced(moq.AnnounceOptions{}) @@ -1533,21 +1550,23 @@ func TestBroadcastIsReachableOnlyWhileAnnounced(t *testing.T) { t.Fatalf("announce: ann=%+v", ann) } - if err := publication.Unannounce(); err != nil { + if err := route.Withdraw(); err != nil { t.Fatal(err) } event := nextRoute(t, ctx, announced) if retracted, ok := event.(moq.AnnounceEventEnd); !ok || retracted.Announce.Prefix != "live" { - t.Fatalf("unannounce: event=%+v", event) + t.Fatalf("withdraw: event=%+v", event) } if _, err := consumer.Request(ctx, "live", nil); err == nil { t.Fatal("an unannounced broadcast must be unroutable") } - if err := publication.Announce(moq.AnnounceRoute{}); err != nil { + if err := route.Announce(); err != nil { t.Fatal(err) } - nextAnnounced(t, ctx, announced) + if ann := nextAnnounced(t, ctx, announced); ann.Route.Instance != route.Instance() { + t.Fatalf("reannounce: ann=%+v, want instance %s", ann, route.Instance()) + } if _, err := consumer.Request(ctx, "live", nil); err != nil { t.Fatal(err) } @@ -1556,37 +1575,28 @@ func TestBroadcastIsReachableOnlyWhileAnnounced(t *testing.T) { } } -// A publication outliving its closed broadcast cannot announce or withdraw the -// broadcast that replaced it at the same path. -func TestStalePublicationLeavesItsReplacementAlone(t *testing.T) { +// A route outliving its closed broadcast cannot announce, re-price, or withdraw +// the route that replaced it at the same path. +func TestStaleRouteLeavesItsReplacementAlone(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), testTimeout) defer cancel() origin := newOrigin(t) - stale, err := origin.CreateBroadcast("live") - if err != nil { - t.Fatal(err) - } - if err := stale.Announce(moq.AnnounceRoute{}); err != nil { - t.Fatal(err) - } - if err := stale.Broadcast().Close(); err != nil { + stale, broadcast := newRoute(t, origin, "live", moq.RouteOptions{}) + if err := broadcast.Close(); err != nil { t.Fatal(err) } - replacement, err := origin.CreateBroadcast("live") - if err != nil { - t.Fatal(err) - } - defer replacement.Broadcast().Close() - if err := replacement.Announce(moq.AnnounceRoute{}); err != nil { - t.Fatal(err) - } - if err := stale.Announce(moq.AnnounceRoute{}); !errors.Is(err, moq.ErrClosed) { + _, replacement := newRoute(t, origin, "live", moq.RouteOptions{}) + defer replacement.Close() + if err := stale.Announce(); !errors.Is(err, moq.ErrClosed) { t.Fatalf("stale Announce = %v, want ErrClosed", err) } - if err := stale.Unannounce(); !errors.Is(err, moq.ErrClosed) { - t.Fatalf("stale Unannounce = %v, want ErrClosed", err) + if err := stale.SetCost(1); !errors.Is(err, moq.ErrClosed) { + t.Fatalf("stale SetCost = %v, want ErrClosed", err) + } + if err := stale.Withdraw(); err != nil { + t.Fatalf("stale Withdraw = %v, want a no-op", err) } if _, err := origin.Consume().Request(ctx, "live", nil); err != nil { t.Fatalf("Request = %v, want the replacement", err) @@ -1605,20 +1615,8 @@ func TestAnnouncedPatternCaptures(t *testing.T) { } defer announced.Cancel() - audio, err := origin.CreateBroadcast("room/alice/audio") - if err != nil { - t.Fatal(err) - } - if err := audio.Announce(moq.AnnounceRoute{}); err != nil { - t.Fatal(err) - } - chat, err := origin.CreateBroadcast("room/alice/chat") - if err != nil { - t.Fatal(err) - } - if err := chat.Announce(moq.AnnounceRoute{}); err != nil { - t.Fatal(err) - } + newRoute(t, origin, "room/alice/audio", moq.RouteOptions{}) + newRoute(t, origin, "room/alice/chat", moq.RouteOptions{}) update := nextAnnounced(t, ctx, announced) if update.Prefix != "room/alice/chat" { @@ -1643,13 +1641,7 @@ func TestAnnouncedExactFilterCapturesEmpty(t *testing.T) { } defer announced.Cancel() - chat, err := origin.CreateBroadcast("room/alice/chat") - if err != nil { - t.Fatal(err) - } - if err := chat.Announce(moq.AnnounceRoute{}); err != nil { - t.Fatal(err) - } + newRoute(t, origin, "room/alice/chat", moq.RouteOptions{}) update := nextAnnounced(t, ctx, announced) if update.Prefix != "room/alice/chat" { @@ -1660,8 +1652,8 @@ func TestAnnouncedExactFilterCapturesEmpty(t *testing.T) { } } -// A broadcast mints its own instance and keeps it across re-announcing; another -// instance is another stream and restarts announce consumers. +// A route mints its own instance and keeps it across re-pricing; another route +// is another stream and restarts announce consumers. func TestAnnouncedInstanceRestarts(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), testTimeout) defer cancel() @@ -1673,19 +1665,13 @@ func TestAnnouncedInstanceRestarts(t *testing.T) { } defer announced.Cancel() - publication, err := origin.CreateBroadcast("instance") - if err != nil { - t.Fatal(err) - } - if err := publication.Announce(moq.AnnounceRoute{}); err != nil { - t.Fatal(err) - } + route, _ := newRoute(t, origin, "instance", moq.RouteOptions{}) minted := nextAnnounced(t, ctx, announced).Route.Instance - if minted == "" { - t.Fatal("start instance is empty, want a minted one") + if minted == "" || minted != route.Instance() { + t.Fatalf("start instance = %q, want the minted %q", minted, route.Instance()) } - if err := publication.Announce(moq.AnnounceRoute{Cost: 1}); err != nil { + if err := route.SetCost(1); err != nil { t.Fatal(err) } update, ok := nextRoute(t, ctx, announced).(moq.AnnounceEventUpdate) @@ -1694,17 +1680,15 @@ func TestAnnouncedInstanceRestarts(t *testing.T) { } stable := "cam" - if err := publication.Announce(moq.AnnounceRoute{Instance: &stable, Epoch: 1}); err != nil { - t.Fatal(err) - } + newRoute(t, origin, "instance", moq.RouteOptions{Instance: &stable, Epoch: 1}) restart, ok := nextRoute(t, ctx, announced).(moq.AnnounceEventRestart) if !ok || restart.Announce.Route.Instance != stable { t.Fatalf("restart = %+v, want instance %s", restart, stable) } empty := "" - if err := publication.Announce(moq.AnnounceRoute{Instance: &empty}); !errors.Is(err, moq.ErrInvalidInstance) { - t.Fatalf("Announce(empty instance) = %v, want ErrInvalidInstance", err) + if _, err := origin.Route("refused", moq.RouteOptions{Instance: &empty}); !errors.Is(err, moq.ErrInvalidInstance) { + t.Fatalf("Route(empty instance) = %v, want ErrInvalidInstance", err) } } @@ -1739,7 +1723,7 @@ func TestDynamicServesARequestUnderAPrefix(t *testing.T) { defer cancel() origin := newOrigin(t) - dynamic, err := origin.Requests("live") + dynamic, err := origin.RoutePrefix("live", moq.RouteOptions{}) if err != nil { t.Fatal(err) } @@ -1752,7 +1736,7 @@ func TestDynamicServesARequestUnderAPrefix(t *testing.T) { done <- err }() - request, err := dynamic.RequestedBroadcast(ctx) + request, err := dynamic.Requested(ctx) if err != nil { t.Fatal(err) } @@ -1760,26 +1744,22 @@ func TestDynamicServesARequestUnderAPrefix(t *testing.T) { if err != nil || path != "live/cam" { t.Fatalf("path = %q err=%v", path, err) } - prepared, err := request.Prepare() - if err != nil { - t.Fatal(err) - } - served, err := prepared.Publish() + served, err := request.Route(moq.RouteOptions{}) if err != nil { t.Fatal(err) } - defer served.Broadcast().Close() + defer runtime.KeepAlive(served) if err := <-done; err != nil { t.Fatal(err) } } -func TestClosingAPreparedAnswerRefusesTheRequest(t *testing.T) { +func TestCancellingAHiddenAnswerRefusesTheRequest(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), testTimeout) defer cancel() origin := newOrigin(t) - dynamic, err := origin.Requests("live") + dynamic, err := origin.RoutePrefix("live", moq.RouteOptions{}) if err != nil { t.Fatal(err) } @@ -1792,15 +1772,15 @@ func TestClosingAPreparedAnswerRefusesTheRequest(t *testing.T) { done <- err }() - request, err := dynamic.RequestedBroadcast(ctx) + request, err := dynamic.Requested(ctx) if err != nil { t.Fatal(err) } - prepared, err := request.Prepare() + hidden, err := request.Route(moq.RouteOptions{Hidden: true}) if err != nil { t.Fatal(err) } - prepared.Close() + hidden.Cancel() select { case err := <-done: diff --git a/go/wrapper/origin.go b/go/wrapper/origin.go index 0123431e09d..3237c8ca8a1 100644 --- a/go/wrapper/origin.go +++ b/go/wrapper/origin.go @@ -13,7 +13,7 @@ import ( // consume sink for a full-duplex peer. // // There is no Close: the origin ends once the collector reaches every owner -// (each producer, published broadcast, and [OriginRequests]), and its consumers +// (each producer and [Route]), and its consumers // then fail with [ErrClosed]. Keep an owner reachable for as long as the origin // should live. type OriginProducer struct { @@ -35,95 +35,122 @@ func (o *OriginProducer) Consume() *OriginConsumer { return &OriginConsumer{inner: o.inner.Consume()} } -// Requests advertises prefix and serves the requests beneath it. +// Route creates a route at exactly path, owning a new broadcast to fill. // -// A route claims prefix and every path beneath it ("" claims every path). A -// service that only serves some of them rejects the rest as they are requested. -// Create, Requests if tracks are served on demand, populate, then -// [Publication.Announce]. -func (o *OriginProducer) Requests(prefix string) (*OriginRequests, error) { - inner, err := o.inner.Requests(prefix) +// The route is visible at once unless options.Hidden: a hidden route is +// invisible and unroutable, for this origin's consumers and peers alike, until +// [Route.Announce], so create it hidden to fill the catalog first. It serves a +// fresh instance, kept across [Route.Withdraw] and [Route.Announce], unless +// options names one. Keep the route reachable: [Route.Cancel], or the collector +// reclaiming it, retracts it, and [BroadcastProducer.Close] ends both. +func (o *OriginProducer) Route(path string, options RouteOptions) (*Route, error) { + inner, err := o.inner.Route(path, options) if err != nil { return nil, err } - return &OriginRequests{inner: inner}, nil + return newRoute(inner), nil } -// CreateBroadcast creates a broadcast at the given path, returning its publication. +// RoutePrefix creates a route over prefix that serves the requests beneath it. // -// The broadcast is invisible and unroutable, for this origin's consumers and -// peers alike, until [Publication.Announce]. Announce it after populating -// tracks. [BroadcastProducer.Close] ends it for good; dropping the last handle, -// the publication included, does the same. -func (o *OriginProducer) CreateBroadcast(path string) (*Publication, error) { - inner, err := o.inner.CreateBroadcast(path) +// A route claims prefix and every path beneath it ("" claims every path). A +// service that only serves some of them rejects the rest as they are requested. +// Answer each [Route.Requested] request, and keep the route reachable while it +// should stay advertised. +func (o *OriginProducer) RoutePrefix(prefix string, options RouteOptions) (*Route, error) { + inner, err := o.inner.RoutePrefix(prefix, options) if err != nil { return nil, err } - return newPublication(inner), nil + return newRoute(inner), nil } -// Publication is a broadcast published on an origin: the broadcast to fill and -// its announcement. +// Route is a route on an origin: an exact route owning one broadcast, or a +// prefix route yielding the requests beneath it. // -// The collector reclaiming it does not retract the route; [BroadcastProducer.Close] does. -type Publication struct { - inner *ffi.MoqPublication +// [Route.Cancel], or the collector reclaiming it, retracts the route, as does +// closing an exact route's broadcast; a [BroadcastProducer] alone does not keep +// it announced. +type Route struct { + inner *ffi.MoqRoute broadcast *BroadcastProducer } -func newPublication(inner *ffi.MoqPublication) *Publication { - return &Publication{inner: inner, broadcast: &BroadcastProducer{inner: inner.Broadcast()}} +func newRoute(inner *ffi.MoqRoute) *Route { + route := &Route{inner: inner} + // A prefix route owns no broadcast. + if broadcast, err := inner.Broadcast(); err == nil { + route.broadcast = &BroadcastProducer{inner: broadcast} + } + return route } -// Broadcast returns the broadcast to fill, the same one on every call. -func (p *Publication) Broadcast() *BroadcastProducer { - return p.broadcast +// Broadcast returns the broadcast an exact route owns, the same one on every +// call, or an error on a prefix route, which owns none. +func (r *Route) Broadcast() (*BroadcastProducer, error) { + if r.broadcast == nil { + _, err := r.inner.Broadcast() + return nil, err + } + return r.broadcast, nil } -// Announce advertises the broadcast's exact path as a route. -// -// Announcing again re-prices the route in place. Until announced, the -// broadcast is invisible and unroutable for local consumers and peers alike. -// Errors with ErrClosed once the broadcast is closed. -func (p *Publication) Announce(route AnnounceRoute) error { - return p.inner.Announce(route) +// Instance returns the stream this route serves, minted at creation unless +// [RouteOptions] named one. +func (r *Route) Instance() string { + return r.inner.Instance() } -// Unannounce retracts the broadcast's exact-path advertisement, if any, from -// local consumers and peers alike. Tracks already in flight carry on, and -// Announce brings it back. Errors with ErrClosed once the broadcast is closed. -func (p *Publication) Unannounce() error { - return p.inner.Unannounce() +// Announce makes the route visible, or keeps it so. A route from +// [BroadcastRequest.Route] also answers the requesters waiting on its path. +// Errors with ErrClosed once its broadcast is closed. +func (r *Route) Announce() error { + return r.inner.Announce() } -// OriginRequests streams requests for paths with no existing exact-path broadcast. -type OriginRequests struct { - inner *ffi.MoqOriginRequests +// Withdraw hides the route from local consumers and peers alike, keeping its +// broadcast and instance. Tracks already in flight carry on, and Announce +// brings the same stream back. +func (r *Route) Withdraw() error { + return r.inner.Withdraw() } -// RequestedBroadcast blocks until a consumer requests a path with no existing -// exact-path broadcast. -func (d *OriginRequests) RequestedBroadcast(ctx context.Context) (*BroadcastRequest, error) { - inner, err := bridge.CallHandle(ctx, d.inner.Cancel, d.inner.RequestedBroadcast) - if err != nil { +// SetCost re-prices the route in place: lower wins among routes covering the +// same prefix. A hidden route keeps the price for when it next announces. +func (r *Route) SetCost(cost uint64) error { + return r.inner.SetCost(cost) +} + +// Requested blocks until a consumer requests a path beneath this prefix route, +// returning (nil, nil) once the origin closes, and at once on an exact route. +// +// Cancelling ctx abandons only this wait: the route stays advertised. +func (r *Route) Requested(ctx context.Context) (*BroadcastRequest, error) { + inner, err := bridge.CallRelease(ctx, nil, r.inner.Requested, func(request **ffi.MoqBroadcastRequest) { + if request != nil { + (*request).Destroy() + } + }) + if err != nil || inner == nil { return nil, err } - return &BroadcastRequest{inner: inner}, nil + return &BroadcastRequest{inner: *inner}, nil } -// All ranges over requested broadcasts until the stream errors or the loop -// breaks. -func (d *OriginRequests) All(ctx context.Context) iter.Seq2[*BroadcastRequest, error] { - return bridge.Seq(ctx, d.RequestedBroadcast) +// All ranges over requested broadcasts until the route ends, a call errors, or +// the loop breaks. +func (r *Route) All(ctx context.Context) iter.Seq2[*BroadcastRequest, error] { + return bridge.Seq(ctx, r.Requested) } -// Cancel stops serving requested broadcasts and retracts the route. -func (d *OriginRequests) Cancel() { - d.inner.Cancel() +// Cancel retracts the route now, rather than when the collector reclaims it. +// Pending requests are rejected and later calls fail with ErrCancelled. An exact +// route's broadcast lives on until [BroadcastProducer.Close]. +func (r *Route) Cancel() { + r.inner.Cancel() } -// BroadcastRequest is a requested broadcast that has not been accepted yet. +// BroadcastRequest is a requested broadcast that has not been answered yet. type BroadcastRequest struct { inner *ffi.MoqBroadcastRequest } @@ -133,13 +160,17 @@ func (r *BroadcastRequest) Path() (string, error) { return r.inner.Path() } -// Prepare starts answering as a new stream under a fresh instance, hidden until published. -func (r *BroadcastRequest) Prepare() (*BroadcastPrepared, error) { - inner, err := r.inner.Prepare() +// Route answers with the path's own exact route, owning a new broadcast. +// +// It serves a fresh instance unless options names one. Created visible, it +// announces now and answers the waiting requesters; created hidden, they wait +// until [Route.Announce], so the job can fill its catalog first. +func (r *BroadcastRequest) Route(options RouteOptions) (*Route, error) { + inner, err := r.inner.Route(options) if err != nil { return nil, err } - return &BroadcastPrepared{inner: inner}, nil + return newRoute(inner), nil } // Serve answers with held content under the prefix route's continuous sequence space, @@ -153,31 +184,6 @@ func (r *BroadcastRequest) Reject(errorCode uint16) error { return r.inner.Reject(errorCode) } -// BroadcastPrepared is a claim answer being filled before announcement. -type BroadcastPrepared struct { - inner *ffi.MoqBroadcastPrepared -} - -// Broadcast returns the unannounced broadcast to fill before publishing; only Publish announces it. -func (p *BroadcastPrepared) Broadcast() *BroadcastProducer { - return &BroadcastProducer{inner: p.inner.Broadcast()} -} - -// Publish announces the answer and resolves every waiting requester, returning -// its publication. -func (p *BroadcastPrepared) Publish() (*Publication, error) { - inner, err := p.inner.Publish() - if err != nil { - return nil, err - } - return newPublication(inner), nil -} - -// Close abandons the answer if it was not published, refusing every waiting requester. -func (p *BroadcastPrepared) Close() { - p.inner.Destroy() -} - // OriginConsumer discovers and requests broadcasts published to an origin. type OriginConsumer struct { inner *ffi.MoqOriginConsumer diff --git a/go/wrapper/origin_internal_test.go b/go/wrapper/origin_internal_test.go index d0c9fd04b4e..e3f2de5544b 100644 --- a/go/wrapper/origin_internal_test.go +++ b/go/wrapper/origin_internal_test.go @@ -35,15 +35,15 @@ func TestOriginEndsWithItsProducer(t *testing.T) { } } -// An OriginRequests owns its origin: once the collector finalizes the last +// A prefix Route owns its origin: once the collector finalizes the last // OriginProducer, the route still serves and a consumer made earlier still // resolves through it. -func TestRequestsKeepTheOrigin(t *testing.T) { +func TestRouteKeepsTheOrigin(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() origin := NewOriginProducer() - dynamic, err := origin.Requests("") + dynamic, err := origin.RoutePrefix("", RouteOptions{}) if err != nil { t.Fatal(err) } @@ -62,19 +62,15 @@ func TestRequestsKeepTheOrigin(t *testing.T) { requested <- result{broadcast: broadcast, err: err} }() - request, err := dynamic.RequestedBroadcast(ctx) - if err != nil { - t.Fatalf("RequestedBroadcast err = %v, want a request", err) - } - prepared, err := request.Prepare() - if err != nil { - t.Fatal(err) + request, err := dynamic.Requested(ctx) + if err != nil || request == nil { + t.Fatalf("Requested = (%v, %v), want a request", request, err) } - served, err := prepared.Publish() + served, err := request.Route(RouteOptions{}) if err != nil { t.Fatal(err) } - defer func() { _ = served.Broadcast().Close() }() + defer func() { _ = served.broadcast.Close() }() var res result select { @@ -87,34 +83,37 @@ func TestRequestsKeepTheOrigin(t *testing.T) { } } -// Releasing a publication, which is what its finalizer does, keeps the route: -// only closing the broadcast retracts it. -func TestReleasingAPublicationKeepsItsRoute(t *testing.T) { +// Releasing a route, which is what its finalizer does, retracts it: the +// broadcast alone keeps nothing announced, though it lives on until closed. +func TestReleasingARouteRetractsIt(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() origin := NewOriginProducer() consumer := origin.Consume() - publication, err := origin.CreateBroadcast("live") + route, err := origin.Route("live", RouteOptions{}) if err != nil { t.Fatal(err) } - if err := publication.Announce(AnnounceRoute{}); err != nil { + broadcast, err := route.Broadcast() + if err != nil { t.Fatal(err) } - broadcast := publication.Broadcast() - if broadcast != publication.Broadcast() { + if again, _ := route.Broadcast(); again != broadcast { t.Fatal("Broadcast must return the same producer on every call") } - publication.inner.Destroy() - if _, err := consumer.Request(ctx, "live", nil); err != nil { - t.Fatalf("Request = %v, want the released publication's broadcast", err) + t.Fatalf("Request = %v, want the route's broadcast", err) + } + route.inner.Destroy() + + if _, err := consumer.Request(ctx, "live", nil); err == nil { + t.Fatal("a released route must be unroutable") + } + if _, err := broadcast.PublishTrack("data", nil); err != nil { + t.Fatalf("PublishTrack = %v, want the broadcast still open", err) } if err := broadcast.Close(); err != nil { t.Fatal(err) } - if _, err := consumer.Request(ctx, "live", nil); err == nil { - t.Fatal("a closed broadcast must be unroutable") - } } diff --git a/go/wrapper/publish.go b/go/wrapper/publish.go index 4ad723616a2..fe8e62d41dc 100644 --- a/go/wrapper/publish.go +++ b/go/wrapper/publish.go @@ -10,8 +10,8 @@ import ( ) // BroadcastProducer publishes a collection of tracks. Create one at a path with -// [OriginProducer.CreateBroadcast] (or [Client.CreateBroadcast]) and take it -// from the [Publication], then publish tracks onto it. +// [OriginProducer.Route] (or [Client.Route]) and take it from the [Route], then +// publish tracks onto it. type BroadcastProducer struct { inner *ffi.MoqBroadcastProducer } @@ -19,7 +19,7 @@ type BroadcastProducer struct { // NewBroadcastProducer creates a standalone broadcast, not attached to any // origin: pass its [BroadcastProducer.Consume] result to [BroadcastRequest.Serve] // for a dynamic request, or use it for local pub/sub. To publish at a path, use -// [OriginProducer.CreateBroadcast]. +// [OriginProducer.Route]. func NewBroadcastProducer() (*BroadcastProducer, error) { inner, err := ffi.NewMoqBroadcastProducer() if err != nil { diff --git a/go/wrapper/reconnect_test.go b/go/wrapper/reconnect_test.go index eca76e3b1fa..7003cd12396 100644 --- a/go/wrapper/reconnect_test.go +++ b/go/wrapper/reconnect_test.go @@ -184,11 +184,15 @@ func TestReconnectAcrossRelayRestart(t *testing.T) { publisher := dialWorker(t, ctx, url) defer publisher.Close() - publication, err := publisher.CreateBroadcast("live") + route, err := publisher.Route("live", moq.RouteOptions{Hidden: true}) + if err != nil { + t.Fatal(err) + } + defer route.Cancel() + broadcast, err := route.Broadcast() if err != nil { t.Fatal(err) } - broadcast := publication.Broadcast() defer broadcast.Close() track, err := broadcast.PublishTrack("data", timedInfo()) @@ -196,7 +200,7 @@ func TestReconnectAcrossRelayRestart(t *testing.T) { t.Fatal(err) } defer track.Finish() - if err := publication.Announce(moq.AnnounceRoute{}); err != nil { + if err := route.Announce(); err != nil { t.Fatal(err) } diff --git a/go/wrapper/runtime_bench_test.go b/go/wrapper/runtime_bench_test.go index 5507f55d70c..0d01fb69477 100644 --- a/go/wrapper/runtime_bench_test.go +++ b/go/wrapper/runtime_bench_test.go @@ -150,11 +150,15 @@ func benchThroughput(b *testing.B, c benchCase) { origin := moq.NewOriginProducerWithConfig(moq.OriginConfig{CacheCapacityBytes: &cacheBytes}) // The origin owns the cache policy; keep it until the case ends. b.Cleanup(func() { runtime.KeepAlive(origin) }) - publication, err := origin.CreateBroadcast("bench") + route, err := origin.Route("bench", moq.RouteOptions{Hidden: true}) + if err != nil { + b.Fatal(err) + } + b.Cleanup(func() { runtime.KeepAlive(route) }) + broadcast, err := route.Broadcast() if err != nil { b.Fatal(err) } - broadcast := publication.Broadcast() b.Cleanup(func() { _ = broadcast.Close() }) tracks := make([]*moq.TrackProducer, c.publishers) consumers := make([]*moq.TrackConsumer, 0, c.publishers*c.subscribers) diff --git a/go/wrapper/server.go b/go/wrapper/server.go index 2247aa52cd0..c81e5e30029 100644 --- a/go/wrapper/server.go +++ b/go/wrapper/server.go @@ -215,14 +215,14 @@ func (s *Server) CertFingerprints() ([]string, error) { return s.inner.CertFingerprints() } -// CreateBroadcast creates an unannounced broadcast at path, invisible to everyone until announced. Announce it after populating tracks. +// Route creates a route at exactly path on the publish origin, owning a new broadcast to fill. // -// See [OriginProducer.CreateBroadcast]. -func (s *Server) CreateBroadcast(path string) (*Publication, error) { +// See [OriginProducer.Route]. +func (s *Server) Route(path string, options RouteOptions) (*Route, error) { if s.publishOrigin == nil { return nil, ErrNoPublishOrigin } - return s.publishOrigin.CreateBroadcast(path) + return s.publishOrigin.Route(path, options) } // Accept returns the next incoming request, or (nil, nil) when the server stops. diff --git a/go/wrapper/types.go b/go/wrapper/types.go index 1ee5b6beb73..621f0a4269d 100644 --- a/go/wrapper/types.go +++ b/go/wrapper/types.go @@ -33,16 +33,18 @@ type ( ProtocolKind = ffi.MoqProtocolKind // OriginConfig configures a new origin, such as its maximum cache size in bytes. OriginConfig = ffi.MoqOriginConfig - // AnnounceRoute is how a broadcast advertises its exact path: its static production Cost (lower wins) and, optionally, a stable Instance. - // A nil Instance keeps the one the broadcast minted, which it keeps across re-announcing, so a restarted - // publisher is a new stream viewers restart onto. Set one only for a publisher that continues its group - // sequences across restarts and raises Epoch on each: readers stitch every route of one instance together, - // so restarting the sequences under an old instance splices unrelated groups into their tracks. - AnnounceRoute = ffi.MoqAnnounceRoute - // Route is an observed route: the Instance of the stream it serves (routes with one instance are one continuous stream), the hop chain it took to reach an origin, and its static production and link cost (lower wins). - Route = ffi.MoqRoute + // RouteOptions is how a [Route] advertises itself: Hidden until [Route.Announce], its static + // production Cost (lower wins) and, optionally, a stable Instance. The zero value is visible at + // once, at cost 0, under a fresh instance the route keeps for its lifetime, so a restarted + // publisher is a new stream viewers restart onto. Set Instance only for a publisher that + // continues its group sequences across restarts and raises Epoch on each: readers stitch every + // route of one instance together, so restarting the sequences under an old instance splices + // unrelated groups into their tracks. + RouteOptions = ffi.MoqRouteOptions + // RouteInfo is the read-only facts on a received route: the Instance of the stream it serves (routes with one instance are one continuous stream), the hop chain it took to reach an origin, and its static production and link cost (lower wins). + RouteInfo = ffi.MoqRouteInfo // Announce is a route over a prefix: the origin-relative Prefix, what each filter - // wildcard matched (Captures), and the Route serving it. It carries no broadcast; + // wildcard matched (Captures), and the RouteInfo serving it. It carries no broadcast; // resolve a path with [OriginConsumer.Request]. Captures is a required slice, // empty when the filter has no wildcards. Announce = ffi.MoqAnnounce diff --git a/kt/moq/MIGRATE.md b/kt/moq/MIGRATE.md index 4eda798883f..4615ba299e4 100644 --- a/kt/moq/MIGRATE.md +++ b/kt/moq/MIGRATE.md @@ -4,6 +4,22 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Publishing goes through one `Route` + +`OriginProducer.createBroadcast(path)`, `Moq.createBroadcast`, and `Server.createBroadcast` are `route(path, RouteOptions())`, and `OriginProducer.requests(prefix)` is `routePrefix(prefix, RouteOptions())`. Both return a `Route`, which replaces `Publication`, `OriginRequests`, and `BroadcastPrepared`: + +- `Publication.broadcast()` is `Route.broadcast()`, which throws `MoqException.Internal` on a prefix route. +- `Publication.announce(AnnounceRoute(...))` is `announce()`, and re-pricing is `setCost(cost)`. `unannounce()` is `withdraw()`. +- `OriginRequests.requestedBroadcast()` is `Route.requested()`, which returns null once the origin closes; `requestedBroadcasts()` is now an extension on `Route`, and ending its collection no longer retracts the route. +- `BroadcastRequest.prepare()` then `BroadcastPrepared.publish()` is `BroadcastRequest.route(options)`: create it hidden to fill it first, then `announce()`. +- `Route.instance()` is the stream's instance, minted at creation and kept across `withdraw` and `announce`. + +`AnnounceRoute` is `RouteOptions(hidden, cost, instance, epoch)`, given once at creation. A route is visible at once unless `hidden = true`; set it and call `announce()` after filling the catalog to keep the old create-then-announce order. A stable `instance` is fixed for the route's lifetime: announcing another one is a new route. + +Hold the `Route` for as long as the broadcast should stay announced: closing or cancelling it retracts it, while `BroadcastProducer.end()` still ends both. A `BroadcastProducer` alone no longer keeps it announced. + +`Route`, the received facts in `Announce.route`, is renamed `RouteInfo`; its fields are unchanged. + ### `VideoInit.lower` takes either producer kind ([#7699](https://github.com/moq-dev/moq/pull/7699)) `VideoInit.lower` is a `dev.moq.media.Producer` (`uniffi.moq.MoqMediaProducer`) instead of a `TrackProducer`. Pass `MoqMediaProducer.Track(producer)`, or `MoqMediaProducer.Stream(producer)` for a byte-stream rendition. diff --git a/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Aliases.kt b/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Aliases.kt index 2789356ded4..f31434b787d 100644 --- a/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Aliases.kt +++ b/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Aliases.kt @@ -49,14 +49,16 @@ typealias Request = uniffi.moq.MoqRequest typealias Transport = uniffi.moq.MoqTransport // Origin (broadcast discovery / announcement). -/** The publish side of an origin: create broadcasts so subscribers can discover them. */ +/** The publish side of an origin: create routes so subscribers can discover them. */ typealias OriginProducer = uniffi.moq.MoqOriginProducer /** - * An origin's handle on one broadcast: `broadcast()` to fill it, `announce` and `unannounce` to - * advertise it. + * A route on an origin: an exact route owning one broadcast (`broadcast()` to fill it), or a prefix + * route yielding the requests beneath it (`requested()`). `announce`, `withdraw`, and `setCost` + * advertise it. Closing or cancelling it retracts it, as does ending its broadcast; a broadcast + * handle alone does not keep it announced. */ -typealias Publication = uniffi.moq.MoqPublication +typealias Route = uniffi.moq.MoqRoute /** Config for creating an origin, such as its total cache budget. */ typealias OriginConfig = uniffi.moq.MoqOriginConfig @@ -64,15 +66,9 @@ typealias OriginConfig = uniffi.moq.MoqOriginConfig /** The subscribe side of an origin: discover and request published broadcasts. */ typealias OriginConsumer = uniffi.moq.MoqOriginConsumer -/** A served route: advertises a path prefix and yields broadcast requests beneath it. */ -typealias OriginRequests = uniffi.moq.MoqOriginRequests - -/** A requested broadcast not yet accepted: fulfill it with a producer or reject it. */ +/** A requested broadcast not yet answered: serve it, route it, or reject it. */ typealias BroadcastRequest = uniffi.moq.MoqBroadcastRequest -/** A claim answer being filled before its exact route is announced. */ -typealias BroadcastPrepared = uniffi.moq.MoqBroadcastPrepared - /** A stream of announce events under a prefix. */ typealias AnnounceConsumer = uniffi.moq.MoqAnnounceConsumer @@ -169,17 +165,17 @@ typealias Frame = uniffi.moq.MoqFrame typealias Timestamp = uniffi.moq.MoqTimestamp /** - * How a broadcast advertises its exact path: its static production cost (lower wins), an optional - * stable instance (null keeps the one the broadcast minted), and the epoch, which only matters with - * a stable instance. + * How a [Route] advertises itself: `hidden` until `announce`, its static production cost (lower + * wins), an optional stable instance (null mints a fresh one the route keeps for its lifetime), and + * the epoch, which only matters with a stable instance. */ -typealias AnnounceRoute = uniffi.moq.MoqAnnounceRoute +typealias RouteOptions = uniffi.moq.MoqRouteOptions /** - * An observed path-prefix route: the instance of the stream it serves, relay hop ids (oldest - * first), and static production and link cost (lower wins). + * The read-only facts on a received route: the instance of the stream it serves, relay hop ids + * (oldest first), and static production and link cost (lower wins). */ -typealias Route = uniffi.moq.MoqRoute +typealias RouteInfo = uniffi.moq.MoqRouteInfo /** Tunes how a track subscription is delivered: priority, delay, ranges, and group ordering. */ typealias Subscription = uniffi.moq.MoqSubscription diff --git a/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Flows.kt b/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Flows.kt index 90e8ec7da82..c7549950564 100644 --- a/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Flows.kt +++ b/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Flows.kt @@ -47,9 +47,11 @@ fun BroadcastRequests.requestedTracks(): Flow = /** Stream of the fills readers of one track need. */ fun TrackRequests.requestedFills(): Flow = pull({ cancel() }) { requestedFill() } -/** Stream of broadcasts requested by consumers. */ -fun OriginRequests.requestedBroadcasts(): Flow = - pull({ cancel() }) { requestedBroadcast() } +/** + * Stream of broadcasts requested beneath a prefix route, ending once the origin closes. Ending the + * collection leaves the route advertised; close or cancel the route to retract it. + */ +fun Route.requestedBroadcasts(): Flow = pull { requested() } /** Stream of timestamped raw frames within a group. */ fun GroupConsumer.frames(): Flow = pull({ cancel() }) { readFrame() } diff --git a/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Moq.kt b/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Moq.kt index 46dc101fff8..1efee9215e1 100644 --- a/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Moq.kt +++ b/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Moq.kt @@ -4,8 +4,8 @@ package dev.moq * A MoQ session with publish/subscribe conveniences. * * Build one with [Moq.connect]. The underlying [session] always exposes a publisher and a - * subscriber (wired from the origins in its [ClientConfig], or auto-created), so you can - * [createBroadcast] and collect [announced] updates without touching the raw [Client] handle. + * subscriber (wired from the origins in its [ClientConfig], or auto-created), so you can [route] + * and collect [announced] updates without touching the raw [Client] handle. * * Call [shutdown], then await [Session.closed] to drain finished tracks before disconnecting. * [AutoCloseable] disposal through `use { ... }` or [close] cancels immediately. @@ -17,13 +17,14 @@ internal constructor( private val client: Client, ) : AutoCloseable { /** - * Create an unannounced broadcast at [path], invisible to everyone until announced. + * Create a route at exactly [path], owning a new broadcast to fill. * - * Fill `broadcast()`, then advertise it with `announce`. The broadcast's `end()` ends it for - * good, as does releasing its last handle: the publication, each `broadcast()`, and - * `requests()`. + * Visible at once unless [options] is `hidden`: then fill `broadcast()` and advertise it with + * `announce()`. Hold the route while it should stay announced: closing it retracts it, and the + * broadcast's `end()` ends both. */ - fun createBroadcast(path: String): Publication = session.publish().createBroadcast(path) + fun route(path: String, options: RouteOptions = RouteOptions()): Route = + session.publish().route(path, options) /** * Discover routes matching [config]; prefixes stay relative to the origin. Collect diff --git a/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Server.kt b/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Server.kt index 25a4547156c..033e46d1f88 100644 --- a/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Server.kt +++ b/kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Server.kt @@ -9,8 +9,8 @@ import uniffi.moq.MoqServer /** * A listening MoQ server with publish/subscribe conveniences. * - * Build one with [Server.listen]. Broadcasts created via [createBroadcast] are served to incoming - * sessions, and [requests] streams each incoming [Request] for the caller to accept or reject. + * Build one with [Server.listen]. Broadcasts created via [route] are served to incoming sessions, + * and [requests] streams each incoming [Request] for the caller to accept or reject. * * [Server] is [AutoCloseable]; `use { ... }` (or [close]) stops accepting new sessions. In-flight * sessions stay alive until their handles are dropped or cancelled. @@ -24,15 +24,15 @@ internal constructor( private val publishOrigin: OriginProducer?, ) : AutoCloseable { /** - * Create an unannounced broadcast at [path], served to incoming sessions once announced. + * Create a route at exactly [path], served to incoming sessions while announced. * - * Fill `broadcast()`, then advertise it with `announce`. The broadcast's `end()` ends it for - * good, as does releasing its last handle: the publication, each `broadcast()`, and - * `requests()`. + * Visible at once unless [options] is `hidden`: then fill `broadcast()` and advertise it with + * `announce()`. Hold the route while it should stay announced: closing it retracts it, and the + * broadcast's `end()` ends both. */ - fun createBroadcast(path: String): Publication { + fun route(path: String, options: RouteOptions = RouteOptions()): Route { val origin = publishOrigin ?: throw IllegalStateException("no publish origin configured") - return origin.createBroadcast(path) + return origin.route(path, options) } /** diff --git a/kt/moq/src/jvmAndAndroidTest/kotlin/dev/moq/SmokeTest.kt b/kt/moq/src/jvmAndAndroidTest/kotlin/dev/moq/SmokeTest.kt index 4bf978bed2d..ff2066900b8 100644 --- a/kt/moq/src/jvmAndAndroidTest/kotlin/dev/moq/SmokeTest.kt +++ b/kt/moq/src/jvmAndAndroidTest/kotlin/dev/moq/SmokeTest.kt @@ -28,6 +28,7 @@ import kotlin.test.Test import kotlin.test.assertEquals import kotlin.test.assertFailsWith import kotlin.test.assertIs +import kotlin.test.assertNotEquals import kotlin.test.assertNotNull import kotlin.test.assertNull import kotlin.test.assertTrue @@ -184,7 +185,7 @@ class SmokeTest { fun `origin alias constructs and consumes`() = runTest { OriginProducer(OriginConfig()).use { origin -> origin.consume().use { /* lifecycle smoke */ } - origin.requests("").use { /* dynamic origin smoke */ } + origin.routePrefix("", RouteOptions()).use { /* prefix route smoke */ } } } @@ -645,9 +646,9 @@ class SmokeTest { assertEquals(1, fingerprints.size) assertEquals(64, fingerprints[0].length) - server.createBroadcast("live").use { publication -> - publication.announce(AnnounceRoute()) - publication.unannounce() + server.route("live", RouteOptions(hidden = true)).use { route -> + route.announce() + route.withdraw() } } } @@ -700,57 +701,75 @@ class SmokeTest { @Test fun `a broadcast is reachable only while announced`() = runTest { OriginProducer(OriginConfig()).use { origin -> - origin.createBroadcast("live").use { publication -> - publication.broadcast().use { it.publishTrack("events", null) } + origin.route("live", RouteOptions(hidden = true)).use { route -> + route.broadcast().use { it.publishTrack("events", null) } val consumer = origin.consume() assertFailsWith { consumer.request("live") } - publication.announce(AnnounceRoute()) + route.announce() val announced = consumer.announced(AnnounceConfig()) val first = assertIs(announced.nextRoute()) assertEquals("live", first.announce.prefix) + assertEquals(route.instance(), first.announce.route.instance) - publication.unannounce() + route.withdraw() val retracted = assertIs(announced.nextRoute()) assertEquals("live", retracted.announce.prefix) assertFailsWith { consumer.request("live") } - publication.announce(AnnounceRoute()) - assertIs(announced.nextRoute()) + // Announcing again continues the same stream. + route.announce() + val again = assertIs(announced.nextRoute()) + assertEquals(route.instance(), again.announce.route.instance) consumer.request("live") } } } @Test - fun `closing a publication keeps its route until the broadcast ends`() = runTest { + fun `closing a route retracts it while its broadcast lives on`() = runTest { OriginProducer(OriginConfig()).use { origin -> val consumer = origin.consume() val announced = consumer.announced(AnnounceConfig()) - val publication = origin.createBroadcast("live") - publication.broadcast().use { broadcast -> - publication.use { it.announce(AnnounceRoute()) } + val route = origin.route("live", RouteOptions()) + route.broadcast().use { broadcast -> assertIs(announced.nextRoute()) consumer.request("live") + route.close() + assertIs(announced.nextRoute()) + assertFailsWith { consumer.request("live") } + broadcast.publishTrack("events", null) broadcast.end() + } + } + } + + @Test + fun `ending the broadcast retracts its route`() = runTest { + OriginProducer(OriginConfig()).use { origin -> + val consumer = origin.consume() + val announced = consumer.announced(AnnounceConfig()) + origin.route("live", RouteOptions()).use { route -> + assertIs(announced.nextRoute()) + route.broadcast().use { it.end() } assertIs(announced.nextRoute()) assertFailsWith { consumer.request("live") } + assertFailsWith { route.announce() } } } } @Test - fun `a stale publication leaves its replacement alone`() = runTest { + fun `a stale route leaves its replacement alone`() = runTest { OriginProducer(OriginConfig()).use { origin -> - origin.createBroadcast("live").use { stale -> - stale.announce(AnnounceRoute()) + origin.route("live", RouteOptions()).use { stale -> stale.broadcast().use { it.end() } - origin.createBroadcast("live").use { replacement -> - replacement.announce(AnnounceRoute()) - assertFailsWith { stale.announce(AnnounceRoute()) } - assertFailsWith { stale.unannounce() } + origin.route("live", RouteOptions()).use { replacement -> + assertFailsWith { stale.announce() } + assertFailsWith { stale.setCost(1uL) } + stale.withdraw() origin.consume().request("live") replacement.broadcast().use { it.end() } } @@ -762,17 +781,18 @@ class SmokeTest { fun `a new instance restarts announce consumers`() = runTest { OriginProducer(OriginConfig()).use { origin -> val announced = origin.consume().announced(AnnounceConfig()) - origin.createBroadcast("instance").use { publication -> - publication.announce(AnnounceRoute()) + origin.route("instance", RouteOptions()).use { first -> val start = assertIs(announced.nextRoute()) assertTrue(start.announce.route.instance.isNotEmpty()) + assertEquals(first.instance(), start.announce.route.instance) - publication.announce(AnnounceRoute(instance = "camera", epoch = 1uL)) - val restart = assertIs(announced.nextRoute()) - assertEquals("camera", restart.announce.route.instance) + origin.route("instance", RouteOptions(instance = "camera", epoch = 1uL)).use { + val restart = assertIs(announced.nextRoute()) + assertEquals("camera", restart.announce.route.instance) + } assertFailsWith { - publication.announce(AnnounceRoute(instance = "")) + origin.route("refused", RouteOptions(instance = "")) } } } @@ -783,8 +803,7 @@ class SmokeTest { OriginProducer(OriginConfig()).use { origin -> val announced = origin.consume().announced(AnnounceConfig(prefix = "room", filter = "*/chat")) - origin.createBroadcast("room/alice/chat").use { publication -> - publication.announce(AnnounceRoute()) + origin.route("room/alice/chat", RouteOptions()).use { val update = assertIs(announced.nextRoute()) assertEquals("room/alice/chat", update.announce.prefix) assertEquals(listOf("alice"), update.announce.captures) @@ -795,21 +814,23 @@ class SmokeTest { @Test fun `dynamic serves a request under a prefix`() = runTest { OriginProducer(OriginConfig()).use { origin -> - origin.requests("live").use { dynamic -> + origin.routePrefix("live", RouteOptions()).use { dynamic -> + assertFailsWith { dynamic.broadcast() } val pending = async { origin.consume().request("live/cam") } - val request = dynamic.requestedBroadcast() + val request = assertNotNull(dynamic.requested()) assertEquals("live/cam", request.path()) - request.prepare().use { prepared -> - prepared.broadcast().use { fill -> - prepared.publish().use { publication -> - pending.await() - // The publication fills the broadcast it prepared: ending one ends the - // other. - publication.broadcast().use { it.end() } - assertFailsWith { fill.publishTrack("late", null) } - } + request.route(RouteOptions(hidden = true)).use { job -> + assertNotEquals(dynamic.instance(), job.instance()) + job.broadcast().use { fill -> + // Only announcing answers the requester. + job.announce() + pending.await() + // The route hands out one broadcast: ending it ends the route too. + job.broadcast().use { it.end() } + assertFailsWith { fill.publishTrack("late", null) } + assertFailsWith { job.announce() } } } } @@ -947,8 +968,8 @@ class SmokeTest { @Test fun `audio consumer reports its playout delay`() = runTest { OriginProducer(OriginConfig()).use { origin -> - origin.createBroadcast("audio-delay").use { publication -> - publication.broadcast().use { broadcast -> + origin.route("audio-delay", RouteOptions(hidden = true)).use { route -> + route.broadcast().use { broadcast -> val audio = AudioProducer( CatalogProducer(broadcast), @@ -963,7 +984,7 @@ class SmokeTest { track = "mic", ), ) - publication.announce(AnnounceRoute()) + route.announce() val consumer = origin.consume().request("audio-delay") val catalog = CatalogConsumer.subscribe(consumer).next()!! @@ -1019,8 +1040,8 @@ class SmokeTest { @Test fun `decoded video frame owns its picture`() = runTest { OriginProducer(OriginConfig()).use { origin -> - origin.createBroadcast("video-decode-frame").use { publication -> - publication.broadcast().use { broadcast -> + origin.route("video-decode-frame", RouteOptions(hidden = true)).use { route -> + route.broadcast().use { broadcast -> val video = VideoProducer( CatalogProducer(broadcast), @@ -1041,7 +1062,7 @@ class SmokeTest { bandwidth = null, ), ) - publication.announce(AnnounceRoute()) + route.announce() // Seed the track so a subscriber joining below lands on encoded media. val rgba = ByteArray(320 * 240 * 4) { 0x80.toByte() } diff --git a/kt/moq/src/jvmTest/kotlin/dev/moq/FfiBench.kt b/kt/moq/src/jvmTest/kotlin/dev/moq/FfiBench.kt index 1fa325f5e59..d66b8fa64aa 100644 --- a/kt/moq/src/jvmTest/kotlin/dev/moq/FfiBench.kt +++ b/kt/moq/src/jvmTest/kotlin/dev/moq/FfiBench.kt @@ -83,8 +83,8 @@ class FfiBench { kotlinx.coroutines.coroutineScope { // Close every handle inside the case, so native teardown never lands in a later one. val origin = OriginProducer(OriginConfig(cacheCapacityBytes = CACHE_BYTES)) - val publication = origin.createBroadcast("bench") - val broadcast = publication.broadcast() + val route = origin.route("bench", RouteOptions(hidden = true)) + val broadcast = route.broadcast() val tracks = (0 until case.publishers).map { broadcast.publishTrack("$it", TrackInfo(timescale = 1_000_000uL)) @@ -142,7 +142,7 @@ class FfiBench { val mb = (n - WARMUP) * case.delivered / 1e6 results += Result("throughput/${case.name}", "MB/s", mb / (wallNs / 1e9)) results += Result("cpu/${case.name}", "ms/MB", cpuUsedNs / 1e6 / mb) - (consumers + tracks + listOf(broadcast, publication, origin)).forEach { it.close() } + (consumers + tracks + listOf(broadcast, route, origin)).forEach { it.close() } } private inline fun call(name: String, results: MutableList, fn: () -> Unit) { diff --git a/py/moq-ffi/tests/exit_inside_callback.py b/py/moq-ffi/tests/exit_inside_callback.py index 9e2ec2038de..6520a4cd2a9 100644 --- a/py/moq-ffi/tests/exit_inside_callback.py +++ b/py/moq-ffi/tests/exit_inside_callback.py @@ -54,9 +54,8 @@ def _preempted_continuation(future_ptr, poll_code): async def main() -> None: origin = moq_ffi.MoqOriginProducer(moq_ffi.MoqOriginConfig()) - publication = origin.create_broadcast("exit") - publication.announce(moq_ffi.MoqAnnounceRoute()) - broadcast = publication.broadcast() + route = origin.route("exit", moq_ffi.MoqRouteOptions()) + broadcast = route.broadcast() track = broadcast.publish_track("data", moq_ffi.MoqTrackInfo(timescale=1_000_000)) consumer = await origin.consume().request("exit") diff --git a/py/moq-rs/MIGRATE.md b/py/moq-rs/MIGRATE.md index dbcce1fe979..9460463a32b 100644 --- a/py/moq-rs/MIGRATE.md +++ b/py/moq-rs/MIGRATE.md @@ -4,6 +4,20 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Publishing goes through one `Route` handle + +`OriginProducer.create_broadcast(path)` (and `Client.create_broadcast` / `Server.create_broadcast`) is `route(path, *, hidden=False, cost=0, instance=None, epoch=0)`, and `OriginProducer.requests(prefix)` is `route_prefix(prefix, ...)`. Both return a `moq.Route`, which replaces `Publication`, `OriginRequests`, and `BroadcastPrepared`: + +- `Publication.broadcast` is `Route.broadcast`, which raises `Error.Internal` on a prefix route. +- `Publication.announce(AnnounceRoute(...))` is `Route.announce()`; pass the cost and instance to `route()` instead, and re-price with `set_cost(cost)`. `unannounce()` is `withdraw()`. +- `OriginRequests.requested_broadcast()` is `Route.requested()`, which returns `None` once the origin closes; `async for` still iterates the requests. +- `BroadcastRequest.prepare()` then `.publish()` is `BroadcastRequest.route(hidden=True)`, then fill `.broadcast` and call `announce()`. +- `Route.instance` is the stream's instance, minted at creation and kept across `withdraw()` and `announce()`. + +A route is visible at once unless `hidden=True`, so pass it and call `announce()` after filling the catalog to keep the old create-then-announce order. Hold the `Route` while the broadcast should stay announced: dropping or cancelling it retracts it, while `broadcast.close()` still ends both. + +`AnnounceRoute` is gone, and `moq.Route` now names the handle: the read-only facts on `Announce.route` are `moq.RouteInfo`. + ### `VideoInit.lower` takes either producer kind ([#7699](https://github.com/moq-dev/moq/pull/7699)) The `lower=` argument of `TrackProducer.video` and `TrackStreamProducer.video` accepts either producer and needs no change. Code that sets the raw `VideoInit.lower` field wraps the handle as `MoqMediaProducer.TRACK(producer=...)` or `MoqMediaProducer.STREAM(producer=...)`. diff --git a/py/moq-rs/README.md b/py/moq-rs/README.md index d9457e4456b..928d22fc608 100644 --- a/py/moq-rs/README.md +++ b/py/moq-rs/README.md @@ -59,8 +59,9 @@ import moq async def main(): async with moq.Client("https://cdn.moq.dev/anon") as client: - publication = client.create_broadcast("my-stream") - broadcast = publication.broadcast + # Hidden until announced; hold the route, since dropping it retracts the broadcast. + route = client.route("my-stream", hidden=True) + broadcast = route.broadcast # Publish an Opus audio track (init bytes from your encoder) audio = moq.media.TrackProducer.audio( @@ -74,8 +75,8 @@ async def main(): audio.write_frame(payload, timestamp=moq.Timestamp(20, 1_000)) audio.cut() - # Each broadcast mints a fresh instance, so viewers see a restart as a new stream. - publication.announce() + # Each route mints a fresh instance, so viewers see a restart as a new stream. + route.announce() # Clean up audio.finish() @@ -94,9 +95,9 @@ import moq async def main(): async with moq.Server("127.0.0.1:4443", tls_generate=["localhost"]) as server: - publication = server.create_broadcast("hello") - track = publication.broadcast.publish_track("events") - publication.announce() + route = server.route("hello", hidden=True) + track = route.broadcast.publish_track("events") + route.announce() print(f"listening on https://{server.local_addr}") sessions = [] @@ -150,7 +151,7 @@ client = moq.Client( - `keylog`. Write TLS session secrets to the file `SSLKEYLOGFILE` names, for decrypting a capture; without `SSLKEYLOGFILE` entering the server fails. - `.local_addr`. The bound address (useful when binding to port `0`). - `.cert_fingerprints()`. SHA-256 fingerprints of the configured TLS certificates, for `serverCertificateHashes` browser cert pinning. - - `.create_broadcast(path) → Publication`. Create an unannounced broadcast, invisible to everyone; fill `.broadcast`, then `announce()` makes it discoverable and reachable; `.broadcast.close()` ends it. + - `.route(path, *, hidden=False, cost=0, instance=None, epoch=0) → Route`. Create a route owning a broadcast to fill at `.broadcast`. Create it `hidden` to fill it before `announce()` makes it discoverable and reachable; dropping or cancelling the route retracts it, and `.broadcast.close()` ends both. - **`Request`**. An incoming session, yielded by `async for request in server`. - `.url`, `.path`, `.query`, `.transport`. The query-free path is uniform across transports; the root or missing path is `""`. The encoded query may contain credentials. - `await .accept(*, publish=None, consume=None) → Session`. Origins are captured when accept starts; None inherits the server default and a supplied origin replaces it. Pass fresh origins for isolation, or the same origin on both sides to share it. A second response raises `AlreadyResponded`; calls after cancel raise `Cancelled`. Complete the handshake (hold the result to keep the connection alive). @@ -249,20 +250,19 @@ same either way. Opaque bytes go on a plain `TrackProducer`. - **`GroupConsumer`**. Async iterator of raw `Frame`s. - `.read_frame() -> Frame | None` returns a raw frame with optional capture time. -Every handle whose cleanup is `cancel()` is an async context manager, so exiting `async with` releases it: the consumers (`media.CatalogConsumer`, `media.TrackConsumer`, `media.GroupConsumer`, `TrackConsumer`, `audio.Consumer`, `video.Consumer`, `GroupConsumer`, `json.SnapshotConsumer`, `json.StreamConsumer`, `json.WindowConsumer`, `AnnounceConsumer`, `Following`) and the dynamic sources (`OriginRequests`, `BroadcastRequests`, `TrackRequests`). +Every handle whose cleanup is `cancel()` is an async context manager, so exiting `async with` releases it: the consumers (`media.CatalogConsumer`, `media.TrackConsumer`, `media.GroupConsumer`, `TrackConsumer`, `audio.Consumer`, `video.Consumer`, `GroupConsumer`, `json.SnapshotConsumer`, `json.StreamConsumer`, `json.WindowConsumer`, `AnnounceConsumer`, `Following`) and the dynamic sources (`Route`, `BroadcastRequests`, `TrackRequests`). ### Origin (advanced) - **`OriginProducer(*, cache_capacity_bytes=None)`**. Manage broadcast announcements. Set `cache_capacity_bytes` to bound cached groups under this origin. - `.consume() → OriginConsumer` - - `.requests(prefix) → OriginRequests` - - `.create_broadcast(path) → Publication` -- **`Publication`**. A broadcast published on an origin. Dropping it keeps the route; closing the broadcast ends it. - - `.broadcast → BroadcastProducer`. The broadcast to fill. - - `.announce(route=None)`, `.unannounce()`. Advertise or retract its exact path; both raise `Closed` once the broadcast closed. -- **`OriginRequests`**. Async source of broadcasts requested by consumers. - - `await .requested_broadcast() → BroadcastRequest`. Call `.serve(consumer)` to answer with held content under the prefix route's continuous sequence space, `.prepare()` then fill its `.broadcast` and `.publish() → Publication` for an independently restarting job under a fresh instance, or `.reject(code)` to fail the requester. - - Async iterator yielding `BroadcastRequest` + - `.route(path, *, hidden=False, cost=0, instance=None, epoch=0) → Route`. An exact route owning a new broadcast, visible at once unless `hidden`, under a fresh instance unless `instance` names one. + - `.route_prefix(prefix, *, hidden=False, cost=0, instance=None, epoch=0) → Route`. A prefix route that yields the requests beneath it. +- **`Route`**. A route on an origin. Hold it: dropping or cancelling it retracts it, and so does closing its broadcast. + - `.broadcast → BroadcastProducer`. The broadcast an exact route owns; raises `Internal` on a prefix route. + - `.instance`. The stream it serves, kept across `withdraw()` and `announce()`. + - `.announce()`, `.withdraw()`, `.set_cost(cost)`. Show, hide, or re-price it in place; `announce` and `set_cost` raise `Closed` once the broadcast closed. + - `await .requested() → BroadcastRequest | None`, or async iteration over a prefix route. Call `.serve(consumer)` to answer with held content under the prefix route's continuous sequence space, `.route(hidden=..., ...)` for the path's own route under a fresh instance, as an independently restarting job, or `.reject(code)` to fail the requester. - **`OriginConsumer`**. Discover broadcasts. - `.announced(prefix, filter=None) → AnnounceConsumer` (async iterator of `AnnounceEvent`: `AnnounceEventStart`, `AnnounceEventUpdate`, `AnnounceEventEnd`, `AnnounceEventRestart`, or `AnnounceEventTakeover`, each carrying an `Announce` whose `.route.instance` names the stream; on a restart, request the path again; a takeover continues what the route at `.predecessor` served); `filter` is a pattern relative to the literal prefix, while each `Announce.prefix` stays origin-relative and `.captures` is a required list of wildcard matches, empty without wildcards - `.follow(path, instance=None) → Following` (awaitable, waits until something serves the path, then each stream that takes over; an `instance` follows only that stream) diff --git a/py/moq-rs/benches/ffi.py b/py/moq-rs/benches/ffi.py index f5049c4cad2..120441b4228 100644 --- a/py/moq-rs/benches/ffi.py +++ b/py/moq-rs/benches/ffi.py @@ -70,7 +70,8 @@ async def read(case: Case, consumer: moq.TrackConsumer, payload: bytes, n: int) async def throughput(case: Case, results: list[dict]) -> None: origin = moq.OriginProducer(cache_capacity_bytes=CACHE_BYTES) - broadcast = origin.create_broadcast("bench").broadcast + route = origin.route("bench", hidden=True) + broadcast = route.broadcast tracks = [broadcast.publish_track(str(p), moq.TrackInfo(timescale=1_000_000)) for p in range(case.publishers)] consumers = [track.consume() for track in tracks for _ in range(case.subscribers)] # A non-uniform payload, so a zero-filled or truncated copy fails the check. diff --git a/py/moq-rs/docs/index.md b/py/moq-rs/docs/index.md index e563f229ac9..08667b3f923 100644 --- a/py/moq-rs/docs/index.md +++ b/py/moq-rs/docs/index.md @@ -166,8 +166,7 @@ broadcast, and producers advertise it in the catalog. OriginProducer OriginConsumer - OriginRequests - Publication + Route AnnounceConsumer Following Announce @@ -215,8 +214,7 @@ Rust side ([`moq-ffi`](https://crates.io/crates/moq-ffi)). Subscription TrackInfo FetchGroupOptions - AnnounceRoute - Route + RouteInfo ConnectionStats ``` diff --git a/py/moq-rs/examples/clock.py b/py/moq-rs/examples/clock.py index 7fd03a5a569..0b3bc3e00b8 100644 --- a/py/moq-rs/examples/clock.py +++ b/py/moq-rs/examples/clock.py @@ -17,9 +17,9 @@ async def publish(url: str, broadcast_name: str, track_name: str, insecure: bool) -> None: async with moq.Client(url, tls=moq.ClientTls(insecure=insecure)) as client: - publication = client.create_broadcast(broadcast_name) - track = publication.broadcast.publish_track(track_name, moq.TrackInfo(timescale=1_000_000)) - publication.announce() + route = client.route(broadcast_name, hidden=True) + track = route.broadcast.publish_track(track_name, moq.TrackInfo(timescale=1_000_000)) + route.announce() print(f"publishing {broadcast_name!r} track={track_name!r} at {url}") while True: diff --git a/py/moq-rs/examples/serve_clock.py b/py/moq-rs/examples/serve_clock.py index 5df6325cb1a..01e4871700a 100644 --- a/py/moq-rs/examples/serve_clock.py +++ b/py/moq-rs/examples/serve_clock.py @@ -20,9 +20,9 @@ async def run(bind: str, broadcast_name: str, track_name: str, host: str) -> None: async with moq.Server(bind, tls_generate=[host]) as server: - publication = server.create_broadcast(broadcast_name) - track = publication.broadcast.publish_track(track_name, moq.TrackInfo(timescale=1_000_000)) - publication.announce() + route = server.route(broadcast_name, hidden=True) + track = route.broadcast.publish_track(track_name, moq.TrackInfo(timescale=1_000_000)) + route.announce() print(f"serving {broadcast_name!r} track={track_name!r} on https://{server.local_addr}") for fp in server.cert_fingerprints(): print(f" cert fingerprint sha256: {fp}") diff --git a/py/moq-rs/moq/__init__.py b/py/moq-rs/moq/__init__.py index 6ab6dbb7630..c7b400cfeba 100644 --- a/py/moq-rs/moq/__init__.py +++ b/py/moq-rs/moq/__init__.py @@ -22,13 +22,11 @@ AnnounceEventStart, AnnounceEventTakeover, AnnounceEventUpdate, - BroadcastPrepared, BroadcastRequest, Following, OriginConsumer, OriginProducer, - OriginRequests, - Publication, + Route, ) from .publish import ( BroadcastProducer, @@ -57,7 +55,6 @@ ) from .types import ( Anchor, - AnnounceRoute, AudioCodec, AudioEncoderInput, AudioSampleFormat, @@ -79,7 +76,7 @@ QuicConfig, Range, RateTarget, - Route, + RouteInfo, Subscription, Timestamp, TrackInfo, @@ -103,7 +100,6 @@ "AnnounceEventTakeover", "AnnounceEventStart", "AnnounceEventUpdate", - "AnnounceRoute", "AudioCodec", "AudioEncoderInput", "AudioSampleFormat", @@ -111,7 +107,6 @@ "BandwidthConsumer", "BroadcastConsumer", "BroadcastRequests", - "BroadcastPrepared", "BroadcastProducer", "BroadcastRequest", "Client", @@ -136,17 +131,16 @@ "GroupConsumer", "GroupProducer", "OriginConsumer", - "OriginRequests", "OriginProducer", "Order", "Position", - "Publication", "Range", "RateControl", "RateTarget", "Request", "Reservation", "Route", + "RouteInfo", "Server", "Session", "Subscription", diff --git a/py/moq-rs/moq/client.py b/py/moq-rs/moq/client.py index 2394adea5df..c65e489bb0a 100644 --- a/py/moq-rs/moq/client.py +++ b/py/moq-rs/moq/client.py @@ -14,7 +14,7 @@ ) from ._records import Backoff, ClientTls, QuicConfig, WebSocketConfig, _implementation, _strs -from .origin import AnnounceConsumer, Following, OriginConsumer, OriginProducer, Publication +from .origin import AnnounceConsumer, Following, OriginConsumer, OriginProducer, Route from .session import Session from .subscribe import BroadcastConsumer @@ -155,12 +155,14 @@ async def __aexit__(self, *exc) -> None: self._inner.cancel() self._inner = None - def create_broadcast(self, path: str) -> Publication: - """Create an unannounced broadcast at ``path``, invisible until announced. Announce it after populating tracks. + def route( + self, path: str, *, hidden: bool = False, cost: int = 0, instance: str | None = None, epoch: int = 0 + ) -> Route: + """Create a route at ``path`` owning a broadcast to fill; hold it to keep it announced. - See :meth:`OriginProducer.create_broadcast`. + See :meth:`OriginProducer.route`. """ - return self._require_publisher().create_broadcast(path) + return self._require_publisher().route(path, hidden=hidden, cost=cost, instance=instance, epoch=epoch) def announced(self, prefix: str = "", *, filter: str | None = None, hidden: bool = False) -> AnnounceConsumer: """Async-iterate broadcasts under ``prefix`` matching an optional pattern. diff --git a/py/moq-rs/moq/origin.py b/py/moq-rs/moq/origin.py index 751735b1aea..c1d3f674461 100644 --- a/py/moq-rs/moq/origin.py +++ b/py/moq-rs/moq/origin.py @@ -7,20 +7,18 @@ MoqAnnounceConfig, MoqAnnounceConsumer, MoqAnnounceEvent, - MoqBroadcastPrepared, MoqBroadcastRequest, MoqFollowing, MoqOriginConfig, MoqOriginConsumer, MoqOriginProducer, - MoqOriginRequests, - MoqPublication, + MoqRoute, + MoqRouteOptions, ) from ._stream import _Stream from .publish import BroadcastProducer from .subscribe import BroadcastConsumer -from .types import AnnounceRoute Announce = MoqAnnounce """A route over a prefix: the origin-relative ``prefix``, what each filter wildcard @@ -109,8 +107,12 @@ def cancel(self) -> None: self._inner.cancel() +def _options(*, hidden: bool, cost: int, instance: str | None, epoch: int) -> MoqRouteOptions: + return MoqRouteOptions(hidden=hidden, cost=cost, instance=instance, epoch=epoch) + + class BroadcastRequest: - """A requested broadcast that has not been accepted yet.""" + """A requested broadcast that has not been answered yet.""" def __init__(self, inner: MoqBroadcastRequest) -> None: self._inner = inner @@ -120,9 +122,16 @@ def path(self) -> str: """The requested broadcast path.""" return self._inner.path() - def prepare(self) -> BroadcastPrepared: - """Start answering as a new stream under a fresh instance, hidden until published.""" - return BroadcastPrepared(self._inner.prepare()) + def route(self, *, hidden: bool = False, cost: int = 0, instance: str | None = None, epoch: int = 0) -> Route: + """Answer with the path's own exact :class:`Route`, owning a new broadcast. + + The route serves a fresh instance unless ``instance`` names one, so a job that + restarts is a new stream. Created visible, it announces now and answers the waiting + requesters; created ``hidden``, they wait until :meth:`Route.announce`, so the job can + fill its catalog first, and cancelling the route before then refuses them. Ending the + route withdraws only this path. + """ + return Route(self._inner.route(_options(hidden=hidden, cost=cost, instance=instance, epoch=epoch))) def serve(self, broadcast: BroadcastConsumer) -> None: """Serve held content under the prefix route's continuous sequence space, without an exact route.""" @@ -133,72 +142,75 @@ def reject(self, error_code: int) -> None: self._inner.reject(error_code) -class BroadcastPrepared: - """A claim answer being filled before its exact route is announced.""" - - def __init__(self, inner: MoqBroadcastPrepared) -> None: - self._inner = inner - self._broadcast = BroadcastProducer._from_inner(inner.broadcast()) - - @property - def broadcast(self) -> BroadcastProducer: - """The unannounced broadcast to fill before publishing; only `publish` announces it.""" - return self._broadcast - - def publish(self) -> Publication: - """Announce the filled broadcast and resolve waiting requesters.""" - return Publication(self._inner.publish(), self._broadcast) +class Route(_Stream[BroadcastRequest]): + """A route on an origin: an exact route owning one broadcast, or a prefix route + yielding the requests beneath it. - -class Publication: - """A broadcast published on an origin: the broadcast to fill and its announcement. - - Dropping it does not retract the route; :meth:`BroadcastProducer.close` does. + Hold it for as long as the route should stay advertised: dropping or cancelling it + retracts it, as does closing an exact route's broadcast. A broadcast handle alone does + not keep it announced. Iterate a prefix route with ``async for`` for its + :class:`BroadcastRequest` values; usable as an async context manager that cancels the + route on exit. """ - def __init__(self, inner: MoqPublication, broadcast: BroadcastProducer) -> None: + def __init__(self, inner: MoqRoute) -> None: self._inner = inner - self._broadcast = broadcast + self._broadcast: BroadcastProducer | None = None @property def broadcast(self) -> BroadcastProducer: - """The broadcast to fill, without announcement control.""" + """The broadcast this exact route owns, to fill with tracks. + + Raises ``moq.Error.Internal`` on a prefix route, which owns none: answer its requests instead. + """ + if self._broadcast is None: + self._broadcast = BroadcastProducer._from_inner(self._inner.broadcast()) return self._broadcast - def announce(self, route: AnnounceRoute | None = None) -> None: - """Advertise the broadcast's exact path as a route, or re-price it in place. + @property + def instance(self) -> str: + """The stream this route serves, minted at creation unless one was named, and kept + across :meth:`withdraw` and :meth:`announce`.""" + return self._inner.instance() + + def announce(self) -> None: + """Make the route visible, or keep it so. - Until announced, the broadcast is invisible and unroutable for local - consumers and peers alike. Raises ``moq.Error.Closed`` once the broadcast closed. + A route from :meth:`BroadcastRequest.route` also answers the requesters waiting on + its path. Raises ``moq.Error.Closed`` once its broadcast closed. """ - self._inner.announce(route if route is not None else AnnounceRoute()) + self._inner.announce() - def unannounce(self) -> None: - """Retract the advertisement, if any, keeping the filled tracks alive. + def withdraw(self) -> None: + """Hide the route from everyone, keeping its broadcast and instance. - Announcing again brings it back. Raises ``moq.Error.Closed`` once the broadcast closed. + :meth:`announce` brings the same stream back; tracks already in flight carry on. """ - self._inner.unannounce() - + self._inner.withdraw() -class OriginRequests(_Stream[BroadcastRequest]): - """A served route: advertises a prefix and yields requests beneath it. + def set_cost(self, cost: int) -> None: + """Re-price the route in place: lower wins among routes covering the same prefix. - Usable as an async context manager that cancels the route on exit. - """ + A hidden route keeps the price for when it next announces. Raises + ``moq.Error.Closed`` once its broadcast closed. + """ + self._inner.set_cost(cost) - def __init__(self, inner: MoqOriginRequests) -> None: - self._inner = inner + async def _next(self) -> BroadcastRequest | None: + return await self.requested() - async def _next(self) -> BroadcastRequest: - return await self.requested_broadcast() + async def requested(self) -> BroadcastRequest | None: + """Await the next broadcast a consumer requests beneath this prefix route. - async def requested_broadcast(self) -> BroadcastRequest: - """Await the next broadcast a consumer requested but that isn't published yet.""" - return BroadcastRequest(await self._inner.requested_broadcast()) + Serve, route, or reject it; the requester stays pending until then. Returns + ``None`` once the origin closes, and at once on an exact route. + """ + request = await self._inner.requested() + return None if request is None else BroadcastRequest(request) def cancel(self) -> None: - """Stop serving and retract the route.""" + """Retract the route and release it now. An exact route's broadcast lives on until + :meth:`BroadcastProducer.close`.""" self._inner.cancel() @@ -244,12 +256,11 @@ async def request(self, path: str, *, instance: str | None = None) -> BroadcastC class OriginProducer: - """The publishing side of an origin: announce broadcasts for consumers to discover. + """The publishing side of an origin: route broadcasts for consumers to discover. - Call :meth:`create_broadcast` to publish at a path, :meth:`consume` for a - matching :class:`OriginConsumer`, or :meth:`requests` to advertise a prefix - and serve on-demand requests. Create, :meth:`requests` if tracks are served - on demand, populate, then :meth:`Publication.announce`. + Call :meth:`route` to publish a broadcast at a path, :meth:`route_prefix` to + serve on-demand requests beneath a prefix, or :meth:`consume` for a matching + :class:`OriginConsumer`. """ def __init__(self, *, cache_capacity_bytes: int | None = None) -> None: @@ -266,25 +277,29 @@ def consume(self) -> OriginConsumer: """Create a consumer that discovers the broadcasts this origin publishes.""" return OriginConsumer(self._inner.consume()) - def requests(self, prefix: str) -> OriginRequests: - """Advertise ``prefix`` and serve the requests beneath it. - - A route claims ``prefix`` and every path beneath it (``""`` claims every - path). A service that only serves some of them rejects the rest as they - are requested. Hold the returned handle while the route should stay - advertised. + def route( + self, path: str, *, hidden: bool = False, cost: int = 0, instance: str | None = None, epoch: int = 0 + ) -> Route: + """Create a :class:`Route` at exactly ``path``, owning a new broadcast to fill. + + Visible at once unless ``hidden``: a hidden route is invisible and unroutable, for + this origin's consumers and peers alike, until :meth:`Route.announce`, so create it + hidden to fill the catalog first. ``cost`` prices it: lower wins. The route serves a + fresh instance unless ``instance`` names a stable one, whose runs raise ``epoch``. + Hold the route: dropping or cancelling it retracts it, and + :meth:`BroadcastProducer.close` ends both. """ - return OriginRequests(self._inner.requests(prefix)) + return Route(self._inner.route(path, _options(hidden=hidden, cost=cost, instance=instance, epoch=epoch))) - def create_broadcast(self, path: str) -> Publication: - """Create a broadcast at ``path``, returning its :class:`Publication`. + def route_prefix( + self, prefix: str, *, hidden: bool = False, cost: int = 0, instance: str | None = None, epoch: int = 0 + ) -> Route: + """Create a :class:`Route` over ``prefix`` that yields the requests beneath it. - Fill :attr:`Publication.broadcast`. The broadcast is invisible and - unroutable, for this origin's consumers and peers alike, until - :meth:`Publication.announce`. Announce it after populating tracks. Create, - :meth:`requests` if tracks are served on demand, populate, then announce. - :meth:`BroadcastProducer.close` ends it for good; dropping its last - handle, the publication included, does the same. + A route claims ``prefix`` and every path beneath it (``""`` claims every + path). A service that only serves some of them rejects the rest as they + are requested. Hold the route while it should stay advertised. """ - inner = self._inner.create_broadcast(path) - return Publication(inner, BroadcastProducer._from_inner(inner.broadcast())) + return Route( + self._inner.route_prefix(prefix, _options(hidden=hidden, cost=cost, instance=instance, epoch=epoch)) + ) diff --git a/py/moq-rs/moq/publish.py b/py/moq-rs/moq/publish.py index 6b1456b9c31..b92e0e051d7 100644 --- a/py/moq-rs/moq/publish.py +++ b/py/moq-rs/moq/publish.py @@ -326,9 +326,9 @@ def cancel(self) -> None: class BroadcastProducer: """Wraps MoqBroadcastProducer with a cleaner interface. - It fills tracks; announcing belongs to the :class:`moq.Publication` that - :meth:`moq.OriginProducer.create_broadcast` returns, the way to publish at a - path. Constructing one directly creates a standalone broadcast for local pub/sub. + It fills tracks; announcing belongs to the :class:`moq.Route` that + :meth:`moq.OriginProducer.route` returns, the way to publish at a path. + Constructing one directly creates a standalone broadcast for local pub/sub. """ def __init__(self) -> None: diff --git a/py/moq-rs/moq/server.py b/py/moq-rs/moq/server.py index 5a81fa4571d..ffde0e4740f 100644 --- a/py/moq-rs/moq/server.py +++ b/py/moq-rs/moq/server.py @@ -8,7 +8,7 @@ from moq_ffi import MoqQuicConfig, MoqRequest, MoqServer, MoqServerConfig, MoqServerTls, MoqTransport from ._records import _implementation, _strs -from .origin import OriginProducer, Publication +from .origin import OriginProducer, Route from .session import Session # The network transport carrying an incoming session. @@ -94,8 +94,7 @@ class Server: In simple mode (no origin provided), creates an internal origin automatically:: async with Server("127.0.0.1:4443", tls_generate=["localhost"]) as server: - publication = server.create_broadcast("live") - publication.announce() # unannounced broadcasts are invisible + route = server.route("live") # announced while held await server.serve() Or hand-roll the accept loop if you need per-request control:: @@ -205,15 +204,18 @@ async def __anext__(self) -> Request: raise StopAsyncIteration return Request(request) - def create_broadcast(self, path: str) -> Publication: - """Create a live broadcast at ``path``, served to incoming sessions. + def route( + self, path: str, *, hidden: bool = False, cost: int = 0, instance: str | None = None, epoch: int = 0 + ) -> Route: + """Create a route at ``path`` owning a broadcast served to incoming sessions; hold it + to keep it announced. - See :meth:`OriginProducer.create_broadcast`. + See :meth:`OriginProducer.route`. """ origin = self._publish_origin if origin is None: raise RuntimeError("no publish origin configured") - return origin.create_broadcast(path) + return origin.route(path, hidden=hidden, cost=cost, instance=instance, epoch=epoch) async def serve(self) -> None: """Accept every session in a loop, holding each one alive until it closes. diff --git a/py/moq-rs/moq/types.py b/py/moq-rs/moq/types.py index 07ea1e05a49..f6a07b2c020 100644 --- a/py/moq-rs/moq/types.py +++ b/py/moq-rs/moq/types.py @@ -4,9 +4,6 @@ timestamp, are owned in `_records` instead. """ -from moq_ffi import ( - MoqAnnounceRoute as AnnounceRoute, -) from moq_ffi import ( MoqAudioCodec as AudioCodec, ) @@ -44,7 +41,7 @@ MoqRateTarget as RateTarget, ) from moq_ffi import ( - MoqRoute as Route, + MoqRouteInfo as RouteInfo, ) from moq_ffi import ( MoqVideoCodec as VideoCodec, @@ -84,7 +81,6 @@ ) __all__ = [ - "AnnounceRoute", "Anchor", "AudioCodec", "AudioEncoderInput", @@ -107,7 +103,7 @@ "QuicConfig", "Range", "RateTarget", - "Route", + "RouteInfo", "Subscription", "Timestamp", "TrackInfo", diff --git a/py/moq-rs/tests/test_local.py b/py/moq-rs/tests/test_local.py index bcf801290ca..cc8c8302943 100644 --- a/py/moq-rs/tests/test_local.py +++ b/py/moq-rs/tests/test_local.py @@ -21,12 +21,6 @@ async def until_wanted(demand: moq.TrackDemand, wanted: bool = True) -> None: pass -def create_announced(origin: moq.OriginProducer, path: str) -> moq.BroadcastProducer: - publication = origin.create_broadcast(path) - publication.announce() - return publication.broadcast - - async def routes(announced: moq.AnnounceConsumer): """Yield each newly announced route, skipping updates and ends.""" async for event in announced: @@ -226,7 +220,8 @@ def test_audio_rejects_bad_init_bytes(): async def test_local_publish_consume_audio(): origin = moq.OriginProducer() - broadcast = create_announced(origin, "live") + route = origin.route("live") + broadcast = route.broadcast media = moq.media.TrackProducer.audio( broadcast, moq.media.AudioInit(format=moq.media.AudioFormat.OPUS, data=opus_head()) ) @@ -264,7 +259,8 @@ async def test_local_publish_consume_audio(): async def test_video_publish_consume(): origin = moq.OriginProducer() - broadcast = create_announced(origin, "video-test") + route = origin.route("video-test") + broadcast = route.broadcast media = moq.media.TrackProducer.video( broadcast, moq.media.VideoInit(format=moq.media.VideoFormat.AVC3, data=h264_init()) ) @@ -301,7 +297,8 @@ async def test_video_publish_consume(): async def test_video_publish_named_track(): origin = moq.OriginProducer() - broadcast = create_announced(origin, "video-named-test") + route = origin.route("video-named-test") + broadcast = route.broadcast media = moq.media.TrackProducer.video( broadcast, moq.media.VideoInit(format=moq.media.VideoFormat.AVC3, data=h264_init()), @@ -320,7 +317,8 @@ async def test_video_publish_named_track(): async def test_multiple_frames_ordering(): origin = moq.OriginProducer() - broadcast = create_announced(origin, "ordering-test") + route = origin.route("ordering-test") + broadcast = route.broadcast media = moq.media.TrackProducer.audio( broadcast, moq.media.AudioInit(format=moq.media.AudioFormat.OPUS, data=opus_head()) ) @@ -350,7 +348,8 @@ async def test_multiple_frames_ordering(): async def test_catalog_update_on_new_track(): origin = moq.OriginProducer() - broadcast = create_announced(origin, "catalog-update") + route = origin.route("catalog-update") + broadcast = route.broadcast _media1 = moq.media.TrackProducer.audio( broadcast, moq.media.AudioInit(format=moq.media.AudioFormat.OPUS, data=opus_head()) ) @@ -392,7 +391,7 @@ def test_close_twice_is_a_noop(): async def test_announced_broadcast(): origin = moq.OriginProducer() - _broadcast = create_announced(origin, "test/broadcast") + _route = origin.route("test/broadcast") consumer = origin.consume() @@ -407,36 +406,39 @@ async def test_announced_instance_restarts(): origin = moq.OriginProducer() consumer = origin.consume() announced = consumer.announced() - publication = origin.create_broadcast("instance") - # The broadcast mints its own instance and keeps it across re-announcing. - publication.announce() + # The route mints its own instance and keeps it across re-pricing. + first = origin.route("instance") start = await next_route(announced) assert isinstance(start, moq.AnnounceEventStart) minted = start.announce.route.instance - assert minted + assert minted == first.instance - publication.announce(moq.AnnounceRoute(cost=1)) + first.set_cost(1) update = await next_route(announced) assert isinstance(update, moq.AnnounceEventUpdate) assert update.announce.route.instance == minted + assert update.announce.route.cost == 1 - # Another instance is another stream: consumers restart onto it. - publication.announce(moq.AnnounceRoute(instance="cam", epoch=1)) + # Another route is another stream: consumers restart onto it. + second = origin.route("instance", instance="cam", epoch=1) + assert second.instance == "cam" restart = await next_route(announced) assert isinstance(restart, moq.AnnounceEventRestart) assert restart.announce.route.instance == "cam" with pytest.raises(moq.Error.InvalidInstance): - publication.announce(moq.AnnounceRoute(instance="")) - publication.broadcast.close() + origin.route("refused", instance="") + first.broadcast.close() + second.broadcast.close() async def test_finish_serves_until_closed(): origin = moq.OriginProducer() consumer = origin.consume() announced = consumer.announced() - broadcast = create_announced(origin, "finish") + route = origin.route("finish") + broadcast = route.broadcast assert isinstance(await next_route(announced), moq.AnnounceEventStart) track = broadcast.publish_track("status") @@ -776,18 +778,20 @@ async def test_dynamic_track_request_can_publish_media(): async def test_dynamic_broadcast_request(): origin = moq.OriginProducer(cache_capacity_bytes=4096) - dynamic = origin.requests("") + dynamic = origin.route_prefix("") consumer = origin.consume() requesting = asyncio.create_task(consumer.request("dynamic/broadcast")) - request = await asyncio.wait_for(dynamic.requested_broadcast(), timeout=5.0) + request = await asyncio.wait_for(dynamic.requested(), timeout=5.0) + assert request is not None assert request.path == "dynamic/broadcast" - prepared = request.prepare() - track = prepared.broadcast.publish_track("status", moq.TrackInfo(timescale=1_000_000)) - served = prepared.publish() - assert served.broadcast is prepared.broadcast + # A hidden job route answers once it announces, under its own instance. + served = request.route(hidden=True) + assert served.instance != dynamic.instance + track = served.broadcast.publish_track("status", moq.TrackInfo(timescale=1_000_000)) + served.announce() with pytest.raises(Exception): _ = request.path @@ -806,12 +810,13 @@ async def test_dynamic_broadcast_request(): async def test_dynamic_serves_held_content_without_an_exact_route(): origin = moq.OriginProducer() - dynamic = origin.requests("live") + dynamic = origin.route_prefix("live") held = moq.BroadcastProducer() track = held.publish_track("status", moq.TrackInfo(timescale=1_000_000)) source = held.consume() requesting = asyncio.create_task(origin.consume().request("live/cam")) - request = await dynamic.requested_broadcast() + request = await dynamic.requested() + assert request is not None request.serve(source) with pytest.raises(Exception): request.serve(source) @@ -827,11 +832,12 @@ async def test_dynamic_serves_held_content_without_an_exact_route(): async def test_dynamic_broadcast_request_can_reject(): origin = moq.OriginProducer() - dynamic = origin.requests("") + dynamic = origin.route_prefix("") consumer = origin.consume() requesting = asyncio.create_task(consumer.request("missing")) - request = await asyncio.wait_for(dynamic.requested_broadcast(), timeout=5.0) + request = await asyncio.wait_for(dynamic.requested(), timeout=5.0) + assert request is not None assert request.path == "missing" request.reject(404) @@ -975,7 +981,8 @@ async def test_container_consumer_default_latency_and_context_manager(): """TrackConsumer.subscribe defaults the latency; the returned consumer is also an async context manager.""" origin = moq.OriginProducer() - broadcast = create_announced(origin, "live") + route = origin.route("live") + broadcast = route.broadcast media = moq.media.TrackProducer.audio( broadcast, moq.media.AudioInit(format=moq.media.AudioFormat.OPUS, data=opus_head()) ) @@ -1002,7 +1009,8 @@ async def test_container_consumer_default_latency_and_context_manager(): async def test_raw_publish_consume(): origin = moq.OriginProducer() - broadcast = create_announced(origin, "robot/arm") + route = origin.route("robot/arm") + broadcast = route.broadcast raw = broadcast.publish_track("events") consumer = origin.consume() @@ -1027,7 +1035,8 @@ async def test_raw_publish_consume(): async def test_raw_multiple_frames(): origin = moq.OriginProducer() - broadcast = create_announced(origin, "robot/io") + route = origin.route("robot/io") + broadcast = route.broadcast raw = broadcast.publish_track("commands") consumer = origin.consume() @@ -1156,7 +1165,8 @@ async def test_broadcast_producer_consume_direct(): async def test_raw_group_sequence(): """Consumer sees the same sequence numbers the producer assigned.""" origin = moq.OriginProducer() - broadcast = create_announced(origin, "track/seq") + route = origin.route("track/seq") + broadcast = route.broadcast raw = broadcast.publish_track("seq", moq.TrackInfo(timescale=1_000_000)) consumer = origin.consume() @@ -1193,7 +1203,8 @@ async def test_default_iteration_is_sequence_order(): this fails if the default iteration ever reverts to recv_group. """ origin = moq.OriginProducer() - broadcast = create_announced(origin, "track/ordering") + route = origin.route("track/ordering") + broadcast = route.broadcast raw = broadcast.publish_track("ordering") subscription = moq.Subscription(delay=moq.Delay(max=timedelta(seconds=1)), ranges=FROM_GROUP_0) @@ -1318,7 +1329,8 @@ async def test_container_group_fails_loudly(): async def test_raw_multi_frame_group(): """A single group can carry multiple frames, not just one per group.""" origin = moq.OriginProducer() - broadcast = create_announced(origin, "stream/chunks") + route = origin.route("stream/chunks") + broadcast = route.broadcast raw = broadcast.publish_track("chunks") consumer = origin.consume() @@ -1548,7 +1560,8 @@ def test_encode_audio_with_opus_object(): async def test_audio_consumer_reports_its_playout_delay(): """A fixed playout delay is reported back as is; an estimated one moves as frames are read.""" origin = moq.OriginProducer() - broadcast = create_announced(origin, "audio-delay") + route = origin.route("audio-delay") + broadcast = route.broadcast audio = moq.audio.Producer( moq.media.CatalogProducer(broadcast), moq.AudioEncoderInput(format=moq.AudioSampleFormat.F32, sample_rate=48_000, channels=1), @@ -1592,7 +1605,8 @@ def output(delay: timedelta | None) -> moq.audio.DecoderOutput: async def test_decode_video_frame(): """A decoded frame owns its picture and converts to either layout, even after its consumer is cancelled.""" origin = moq.OriginProducer() - broadcast = create_announced(origin, "video-decode-frame") + route = origin.route("video-decode-frame") + broadcast = route.broadcast video = moq.video.Producer( moq.media.CatalogProducer(broadcast), moq.VideoEncoderInput( @@ -1648,39 +1662,39 @@ async def test_decode_video_frame(): async def test_broadcast_is_reachable_only_while_announced(): origin = moq.OriginProducer() - publication = origin.create_broadcast("live") - track = publication.broadcast.publish_track("events") + route = origin.route("live", hidden=True) + track = route.broadcast.publish_track("events") consumer = origin.consume() with pytest.raises(Exception): await asyncio.wait_for(consumer.request("live"), timeout=5.0) - publication.announce() + route.announce() announced = consumer.announced() first = await next_route(announced) assert isinstance(first, moq.AnnounceEventStart) assert first.announce.prefix == "live" - publication.unannounce() + route.withdraw() retracted = await next_route(announced) assert isinstance(retracted, moq.AnnounceEventEnd) assert retracted.announce.prefix == "live" with pytest.raises(Exception): await asyncio.wait_for(consumer.request("live"), timeout=5.0) - publication.announce() + route.announce() back = await next_route(announced) assert isinstance(back, moq.AnnounceEventStart) + assert back.announce.route.instance == route.instance await asyncio.wait_for(consumer.request("live"), timeout=5.0) announced.cancel() track.finish() - publication.broadcast.close() + route.broadcast.close() async def test_an_instance_pins_request_and_follow(): origin = moq.OriginProducer() consumer = origin.consume() - publication = origin.create_broadcast("live") - publication.announce(moq.AnnounceRoute(instance="cam")) + route = origin.route("live", instance="cam") await asyncio.wait_for(consumer.request("live", instance="cam"), timeout=5.0) with pytest.raises(moq.Error.Protocol): @@ -1689,37 +1703,50 @@ async def test_an_instance_pins_request_and_follow(): consumer.follow("live", instance="") async with consumer.follow("live", instance="cam") as following: await asyncio.wait_for(following.available(), timeout=5.0) - publication.broadcast.close() + route.broadcast.close() -async def test_dropping_a_publication_keeps_its_route(): +async def test_the_route_keeps_its_broadcast_announced(): origin = moq.OriginProducer() consumer = origin.consume() - publication = origin.create_broadcast("live") - broadcast = publication.broadcast - assert publication.broadcast is broadcast - publication.announce() - del publication + route = origin.route("live") + broadcast = route.broadcast + assert route.broadcast is broadcast + # The broadcast handle alone retracts nothing. + del broadcast await asyncio.wait_for(consumer.request("live"), timeout=5.0) - broadcast.close() + # Dropping the route retracts it; its broadcast lives on for its other handles. + broadcast = route.broadcast + del route with pytest.raises(moq.Error.Protocol): await asyncio.wait_for(consumer.request("live"), timeout=5.0) + broadcast.publish_track("data") + broadcast.close() + + # Cancelling retracts it too, and later calls fail. + cancelled = origin.route("cancelled") + await asyncio.wait_for(consumer.request("cancelled"), timeout=5.0) + cancelled.cancel() + with pytest.raises(moq.Error.Protocol): + await asyncio.wait_for(consumer.request("cancelled"), timeout=5.0) + with pytest.raises(moq.Error.Cancelled): + cancelled.announce() + cancelled.broadcast.close() -async def test_a_stale_publication_leaves_its_replacement_alone(): +async def test_a_closed_route_leaves_its_replacement_alone(): origin = moq.OriginProducer() consumer = origin.consume() - stale = origin.create_broadcast("live") - stale.announce() + stale = origin.route("live") stale.broadcast.close() - replacement = origin.create_broadcast("live") - replacement.announce() + replacement = origin.route("live") with pytest.raises(moq.Error.Closed): stale.announce() with pytest.raises(moq.Error.Closed): - stale.unannounce() + stale.set_cost(1) + stale.withdraw() await asyncio.wait_for(consumer.request("live"), timeout=5.0) replacement.broadcast.close() @@ -1730,10 +1757,10 @@ async def test_announced_pattern_captures(): announced = consumer.announced("room", filter="*/chat") # A claim at "room" could serve a match, but its own name is none, so it is not listed. - dynamic = origin.requests("room") + dynamic = origin.route_prefix("room") - audio = create_announced(origin, "room/alice/audio") - chat = create_announced(origin, "room/alice/chat") + audio = origin.route("room/alice/audio") + chat = origin.route("room/alice/chat") match = await next_route(announced) assert isinstance(match, moq.AnnounceEventStart) assert match.announce.prefix == "room/alice/chat" @@ -1741,19 +1768,21 @@ async def test_announced_pattern_captures(): announced.cancel() dynamic.cancel() - audio.close() - chat.close() + audio.broadcast.close() + chat.broadcast.close() async def test_dynamic_serves_a_request_under_a_prefix(): origin = moq.OriginProducer() - dynamic = origin.requests("live") + dynamic = origin.route_prefix("live") consumer = origin.consume() + with pytest.raises(moq.Error.Internal): + _ = dynamic.broadcast pending = asyncio.create_task(consumer.request("live/cam")) - request = await asyncio.wait_for(dynamic.requested_broadcast(), timeout=5.0) + request = await asyncio.wait_for(anext(dynamic), timeout=5.0) assert request.path == "live/cam" - served = request.prepare().publish() + served = request.route() await asyncio.wait_for(pending, timeout=5.0) dynamic.cancel() served.broadcast.close() @@ -1768,9 +1797,9 @@ async def assert_cancelled(awaitable) -> None: assert moq.is_shutdown(excinfo.value) origin = moq.OriginProducer() - async with origin.requests("live") as origin_dynamic: + async with origin.route_prefix("live") as origin_dynamic: pass - await assert_cancelled(origin_dynamic.requested_broadcast()) + await assert_cancelled(origin_dynamic.requested()) broadcast = moq.BroadcastProducer() async with broadcast.requests() as broadcast_dynamic: diff --git a/py/moq-rs/tests/test_server.py b/py/moq-rs/tests/test_server.py index 11297357e69..1639e89726c 100644 --- a/py/moq-rs/tests/test_server.py +++ b/py/moq-rs/tests/test_server.py @@ -43,12 +43,12 @@ async def test_server_client_roundtrip(): """Server publishes a broadcast; a client connects and receives a frame.""" async with moq.Server("127.0.0.1:0", versions=["moq-lite-07-wip"], tls_generate=["localhost"]) as server: # Publish a broadcast on the server side. - publication = server.create_broadcast("hello") - broadcast = publication.broadcast + published = server.route("hello", hidden=True) + broadcast = published.broadcast media = moq.media.TrackProducer.audio( broadcast, moq.media.AudioInit(format=moq.media.AudioFormat.OPUS, data=opus_head()) ) - publication.announce() + published.announce() # Auto-accept incoming sessions in the background so the handshake # completes from the server side. Hold references so the sessions @@ -163,9 +163,8 @@ async def accept_loop() -> None: assert session.state().failure is None # A broadcast published only after the reconnect still arrives. - publication = server.create_broadcast("after-reconnect") - broadcast = publication.broadcast - publication.announce() + published = server.route("after-reconnect") + broadcast = published.broadcast async for announcement in routes(client.announced()): assert announcement.prefix == "after-reconnect" break @@ -397,9 +396,8 @@ async def accept_once() -> None: async def test_serve_helper_accepts_clients(): """Server.serve() accepts incoming sessions and holds them automatically.""" async with moq.Server("127.0.0.1:0", tls_generate=["localhost"]) as server: - publication = server.create_broadcast("via-serve") - broadcast = publication.broadcast - publication.announce() + published = server.route("via-serve") + broadcast = published.broadcast serve_task = asyncio.create_task(server.serve()) try: @@ -423,9 +421,8 @@ async def test_serve_helper_accepts_clients(): async def test_broadcast_route_over_wire(): """A route received over the wire exposes its hop chain and cost.""" async with moq.Server("127.0.0.1:0", tls_generate=["localhost"]) as server: - publication = server.create_broadcast("with-route") - broadcast = publication.broadcast - publication.announce() + published = server.route("with-route") + broadcast = published.broadcast serve_task = asyncio.create_task(server.serve()) try: @@ -454,12 +451,11 @@ async def test_route_update_observes_restart(): """A route metadata update arrives as an AnnounceEventUpdate. The publisher re-prices its announced route; the subscriber observes the new - cost in place (no retraction), and unannouncing retracts it. + cost in place (no retraction), and withdrawing retracts it. """ origin = moq.OriginProducer() async with moq.Server("127.0.0.1:0", tls_generate=["localhost"], publish=origin) as server: - publication = origin.create_broadcast("routed") - publication.announce(moq.AnnounceRoute(cost=1)) + published = origin.route("routed", cost=1) serve_task = asyncio.create_task(server.serve()) try: @@ -475,14 +471,14 @@ async def test_route_update_observes_restart(): first_cost = first.announce.route.cost # The publisher raises its cost: an in-place update. - publication.announce(moq.AnnounceRoute(cost=5)) + published.set_cost(5) updated = await next_route(announced) assert isinstance(updated, moq.AnnounceEventUpdate) assert updated.announce.prefix == "routed" assert updated.announce.route.cost == first_cost + 4 - # Unannouncing retracts the route. - publication.unannounce() + # Withdrawing retracts the route. + published.withdraw() ended = await next_route(announced) assert isinstance(ended, moq.AnnounceEventEnd) assert ended.announce.prefix == "routed" @@ -526,9 +522,8 @@ async def drain(reader: moq.TrackConsumer) -> None: # rather than lean on the last session reference dropping. session = client.session assert session is not None - publication = client.create_broadcast("live") - broadcast = publication.broadcast - publication.announce() + published = client.route("live") + broadcast = published.broadcast track = broadcast.publish_track("data") await asyncio.wait_for(accepted.wait(), timeout=5.0) consume = sessions[0].consume() diff --git a/py/moq-rs/tests/test_testing_clock.py b/py/moq-rs/tests/test_testing_clock.py index e06bb6e3392..2af1c52b772 100644 --- a/py/moq-rs/tests/test_testing_clock.py +++ b/py/moq-rs/tests/test_testing_clock.py @@ -25,7 +25,8 @@ def test_a_pending_timer_waits_for_advance() -> None: async def main(): # The origin's driver runs the timers that judge a group stale. origin = moq.OriginProducer() - track = origin.create_broadcast("clock").broadcast.publish_track("track") + route = origin.route("clock", hidden=True) + track = route.broadcast.publish_track("track") from_group_0 = [moq.Range(start=moq.Anchor.ABSOLUTE(group=0))] consumer = track.consume(moq.Subscription(delay=moq.Delay(max=timedelta(seconds=1)), ranges=from_group_0)) diff --git a/rs/hang/examples/subscribe.rs b/rs/hang/examples/subscribe.rs index 9718326d08f..9f3c497da13 100644 --- a/rs/hang/examples/subscribe.rs +++ b/rs/hang/examples/subscribe.rs @@ -77,7 +77,9 @@ 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(&announce.prefix, announce.route.instance).await?; + let broadcast = consumer + .request(&announce.prefix, announce.route.instance().clone()) + .await?; // Read the catalog to discover available tracks. let catalog_track = broadcast diff --git a/rs/hang/examples/video.rs b/rs/hang/examples/video.rs index 899b59c8807..7910196fd66 100644 --- a/rs/hang/examples/video.rs +++ b/rs/hang/examples/video.rs @@ -82,11 +82,10 @@ fn create_track(broadcast: &mut moq_net::broadcast::Producer) -> anyhow::Result< async fn run_broadcast(origin: moq_net::origin::Producer) -> anyhow::Result<()> { // Create a broadcast on the origin and announce its path. // NOTE: The path is empty because we're using the URL to scope the broadcast. - let broadcast = origin.create_broadcast("").context("failed to create broadcast")?; - broadcast - .announce(Default::default()) + let route = origin + .route("", moq_net::origin::RouteOptions::default()) .context("failed to announce broadcast")?; - let track = create_track(&mut broadcast.broadcast().clone())?; + let track = create_track(&mut route.broadcast().clone())?; // Wrap in a Producer for keyframe-based group management. let mut producer = moq_mux::container::Producer::new( diff --git a/rs/moq-archive/README.md b/rs/moq-archive/README.md index b96bee472f7..da623fa263d 100644 --- a/rs/moq-archive/README.md +++ b/rs/moq-archive/README.md @@ -31,7 +31,7 @@ use moq_archive::object_store::memory::InMemory; let store = moq_archive::Store::new(InMemory::new(), "recordings/demo"); moq_archive::Producer::new(store.clone(), broadcast, Default::default()).run().await?; -// `served` is an `origin::Publication`'s fill, announced once `open` returns. +// `served` is an `origin::Route`'s broadcast, created hidden and announced once `open` returns. let consumer = moq_archive::Consumer::open(store, served, Default::default()).await?; consumer.run().await?; ``` diff --git a/rs/moq-audio/src/decode/consumer.rs b/rs/moq-audio/src/decode/consumer.rs index 764576e8429..927c555adf9 100644 --- a/rs/moq-audio/src/decode/consumer.rs +++ b/rs/moq-audio/src/decode/consumer.rs @@ -974,11 +974,14 @@ mod tests { #[tokio::test(start_paused = true)] async fn latest_skips_a_warm_copys_backlog() { let publisher = origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast + .broadcast() .create_track("audio", hang::container::track_info(hang::catalog::PRIORITY.audio)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut demand = track.demand(); let mut producer = moq_mux::container::Producer::new( track, @@ -1046,11 +1049,14 @@ mod tests { #[tokio::test(start_paused = true)] async fn latest_loses_no_group_the_publisher_bursts_before_its_first_frame() { let publisher = origin(1); - let broadcast = publisher.create_broadcast("bcast").unwrap(); + let broadcast = publisher + .route("bcast", moq_net::origin::RouteOptions::hidden()) + .unwrap(); let track = broadcast + .broadcast() .create_track("audio", hang::container::track_info(hang::catalog::PRIORITY.audio)) .unwrap(); - broadcast.announce(Default::default()).unwrap(); + broadcast.announce().unwrap(); let mut producer = moq_mux::container::Producer::new( track, moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Audio), diff --git a/rs/moq-bench/src/connection.rs b/rs/moq-bench/src/connection.rs index 05409c94558..e0e67c9280c 100644 --- a/rs/moq-bench/src/connection.rs +++ b/rs/moq-bench/src/connection.rs @@ -108,7 +108,7 @@ pub async fn run(ctx: Connection) { config.name() }; - let mut broadcasts = Vec::new(); + let mut routes = Vec::new(); let mut publishing = Vec::new(); let mut own = HashSet::new(); let mut tasks = JoinSet::new(); @@ -126,14 +126,14 @@ pub async fn run(ctx: Connection) { }; for (relative, path) in paths { - let broadcast = match publish.create_broadcast(&path) { - Ok(broadcast) => broadcast, + let route = match publish.route(&path, moq_net::origin::RouteOptions::hidden()) { + Ok(route) => route, Err(err) => { tracing::error!(connection, %err, "failed to create broadcast"); continue; } }; - let track = match broadcast.create_track( + let track = match route.broadcast().create_track( TRACK, moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) { @@ -143,14 +143,14 @@ pub async fn run(ctx: Connection) { continue; } }; - if let Err(err) = broadcast.announce(Default::default()) { + if let Err(err) = route.announce() { tracing::error!(connection, %err, "failed to announce broadcast"); continue; } own.insert(relative); - // Hold the broadcast producer for the connection's lifetime so it stays - // published and advertised. - broadcasts.push(broadcast); + // Hold the route for the connection's lifetime so it stays published and + // advertised. + routes.push(route); let published = Published::new(stats.clone()); publishing.push(Arc::downgrade(&published)); @@ -989,22 +989,26 @@ mod tests { let origin = moq_tokio::origin::spawn(); // The relay-internal broadcast: announced, but with no bench data track. - let _internal = origin.create_broadcast(".stats/node/host").unwrap(); - _internal.announce(Default::default()).unwrap(); + let _internal = origin + .route(".stats/node/host", moq_net::origin::RouteOptions::default()) + .unwrap(); // Our own broadcast: in the namespace, but excluded via the `own` set // (paths relative to the namespace, matching the scoped announce consumer). - let _previous = origin.create_broadcast("bench/previous/0/0").unwrap(); - _previous.announce(Default::default()).unwrap(); + let _previous = origin + .route("bench/previous/0/0", moq_net::origin::RouteOptions::default()) + .unwrap(); - let _own = origin.create_broadcast("bench/current/9/9").unwrap(); - _own.announce(Default::default()).unwrap(); + let _own = origin + .route("bench/current/9/9", moq_net::origin::RouteOptions::default()) + .unwrap(); let own = HashSet::from(["9/9".to_string()]); // One legitimate peer under the bench namespace with a single finished group. - let peer = origin.create_broadcast("bench/current/0/0").unwrap(); - peer.announce(Default::default()).unwrap(); - let track = peer.create_track(TRACK, timed()).unwrap(); + let peer = origin + .route("bench/current/0/0", moq_net::origin::RouteOptions::default()) + .unwrap(); + let track = peer.broadcast().create_track(TRACK, timed()).unwrap(); let mut group = track.append_group().unwrap(); group .write_frame(moq_net::Timestamp::now(), Bytes::from_static(b"{}")) @@ -1034,9 +1038,10 @@ mod tests { stats.clone(), )); - let broadcast = origin.create_broadcast("bench/run/chat").unwrap(); - broadcast.announce(Default::default()).unwrap(); - let track = broadcast.create_track(TRACK, timed()).unwrap(); + let broadcast = origin + .route("bench/run/chat", moq_net::origin::RouteOptions::default()) + .unwrap(); + let track = broadcast.broadcast().create_track(TRACK, timed()).unwrap(); tokio::task::yield_now().await; let mut group = track.append_group().unwrap(); let header = serde_json::json!({ @@ -1053,7 +1058,7 @@ mod tests { task.await.unwrap().unwrap(); assert_eq!(stats.groups_recv.load(Ordering::Relaxed), 1); - broadcast.close(); + broadcast.broadcast().close(); } /// The relay fails a group it gave up on (`Error::Lagged` once a subscriber diff --git a/rs/moq-boy/src/input.rs b/rs/moq-boy/src/input.rs index b7c954e7acc..702f9da4288 100644 --- a/rs/moq-boy/src/input.rs +++ b/rs/moq-boy/src/input.rs @@ -186,15 +186,16 @@ mod tests { } /// Publish a viewer with a live command track. - fn viewer(origin: &moq_net::origin::Producer) -> (moq_net::origin::Publication, moq_net::track::Producer) { - let broadcast = origin.create_broadcast("alice").unwrap(); + fn viewer(origin: &moq_net::origin::Producer) -> (moq_net::origin::Route, moq_net::track::Producer) { + let broadcast = origin.route("alice", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast + .broadcast() .create_track( "command", moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) .unwrap(); - broadcast.announce(moq_net::origin::Route::default()).unwrap(); + broadcast.announce().unwrap(); (broadcast, track) } @@ -249,7 +250,7 @@ mod tests { send(&old_track, r#"{"type":"reset"}"#); assert!(matches!(rx.recv().await, Some(Command::Reset))); - old.unannounce(); + old.withdraw(); assert!(matches!(rx.recv().await, Some(Command::ViewerLeft { .. }))); let (_new, new_track) = viewer(&origin); kio::clock::sleep(Duration::from_secs(1)).await; diff --git a/rs/moq-boy/src/main.rs b/rs/moq-boy/src/main.rs index e56168d146e..227101ac80a 100644 --- a/rs/moq-boy/src/main.rs +++ b/rs/moq-boy/src/main.rs @@ -256,15 +256,11 @@ async fn run(config: &Config) -> Result<()> { let publish_origin = moq_tokio::origin::spawn(); let (broadcast_path, viewer_path) = config.paths(&name)?; - // Create the broadcast on the publish origin and announce its path. - let broadcast = publish_origin - .create_broadcast(&broadcast_path) - .context("failed to create broadcast")?; - let instance = moq_net::Instance::random(); - broadcast - .announce(moq_net::origin::Route::default().with_instance(instance.clone(), 0)) + // Announce the game session's route on the publish origin; it owns the broadcast. + let route = publish_origin + .route(&broadcast_path, moq_net::origin::RouteOptions::default()) .context("failed to announce broadcast")?; - tracing::info!(broadcast = %broadcast_path, %instance, "announced"); + tracing::info!(broadcast = %broadcast_path, instance = %route.instance(), "announced"); // Consume origin: viewer broadcasts under the viewer prefix. // JS publishes viewer feedback at "{viewer_prefix}/{name}/{viewerId}" @@ -282,16 +278,15 @@ async fn run(config: &Config) -> Result<()> { .connect(url); // Set up catalog and encoders. - let catalog = - moq_mux::catalog::Producer::new(&mut broadcast.broadcast().clone(), moq_mux::catalog::Config::default())?; - let video_encoder = video::VideoEncoder::spawn(broadcast.broadcast().clone(), catalog.clone()).await; + let catalog = moq_mux::catalog::Producer::new(&mut route.broadcast().clone(), moq_mux::catalog::Config::default())?; + let video_encoder = video::VideoEncoder::spawn(route.broadcast().clone(), catalog.clone()).await; - let audio_encoder = audio::AudioEncoder::new(broadcast.broadcast().clone(), catalog.clone(), 44100)?; + let audio_encoder = audio::AudioEncoder::new(route.broadcast().clone(), catalog.clone(), 44100)?; let video_track = video_encoder.demand.clone(); let audio_track = audio_encoder.demand(); - let status_publisher = status::StatusPublisher::new(&mut broadcast.broadcast().clone())?; + let status_publisher = status::StatusPublisher::new(&mut route.broadcast().clone())?; let session = Arc::new(Session { video_encoder, @@ -332,7 +327,7 @@ async fn run(config: &Config) -> Result<()> { }; // Close the broadcast now, even if the emulator thread still holds a clone. - broadcast.close(); + route.broadcast().close(); result } diff --git a/rs/moq-c/MIGRATE.md b/rs/moq-c/MIGRATE.md index d524ff1358a..70061b4a17f 100644 --- a/rs/moq-c/MIGRATE.md +++ b/rs/moq-c/MIGRATE.md @@ -4,6 +4,22 @@ How to update your code for each breaking change, newest first. ## Unreleased +### Publishing goes through one route handle + +A route handle replaces the publication, the prepared answer, and the request handler: + +- `moq_origin_create_broadcast(origin, path, len, &broadcast)` is `moq_origin_route(origin, path, len, options)`, which returns a route; `moq_route_broadcast(route)` gives the broadcast handle to fill. +- `moq_publication_announce(publication, route)` is `moq_route_announce(route)`, and re-pricing is `moq_route_set_cost(route, cost)`. `moq_publication_unannounce` is `moq_route_withdraw`, and `moq_publication_free` is `moq_route_free`. +- `moq_origin_requests(origin, prefix, len, on_request, user_data)` is `moq_origin_route_prefix(origin, prefix, len, options, on_request, user_data)`, and `moq_origin_requests_cancel` is `moq_route_free`. +- `moq_broadcast_request_prepare(request, &broadcast)` then `moq_broadcast_prepared_publish` is `moq_broadcast_request_route(request, options)`: create it hidden to fill it first, then `moq_route_announce`. `moq_broadcast_prepared_free` is `moq_route_free`. +- `moq_route_instance(route, &dst)` reads the stream's instance, minted at creation and kept across withdraw and announce. + +`moq_announce_route` is `moq_route_options`, given once at creation, and gains a trailing `hidden`. A zeroed or NULL `moq_route_options` is visible at once, so set `hidden` and call `moq_route_announce` after filling the catalog to keep the old create-then-announce order. A stable `instance` is fixed for the route's lifetime: announcing another one is a new route. + +Hold the route for as long as the broadcast should stay announced. `moq_route_free` now retracts it, while `moq_publish_close` still ends both; the broadcast handle alone no longer keeps it announced. + +`moq_route`, the struct carried by `moq_announce_event.route`, is renamed `moq_route_info`; its fields are unchanged. Recompile against the regenerated `moq.h`. + ### JSON writes refuse a NULL timestamp ([#7691](https://github.com/moq-dev/moq/pull/7691)) `moq_publish_json_snapshot_update`, `moq_publish_json_stream_append`, `moq_publish_json_window_push`, and `moq_publish_json_window_pop` fail with `MOQ_ERROR_INVALID_POINTER` and publish nothing on a NULL `timestamp`, instead of stamping the broadcast clock's current time. diff --git a/rs/moq-c/README.md b/rs/moq-c/README.md index 16835118d7e..3b53efa3c6e 100644 --- a/rs/moq-c/README.md +++ b/rs/moq-c/README.md @@ -54,7 +54,6 @@ int32_t moq_session_request_free(uint32_t request); // Origin int32_t moq_origin_create(void); int32_t moq_origin_close(uint32_t origin); -int32_t moq_origin_create_broadcast(uint32_t origin, const char *path, uintptr_t path_len, uint32_t *broadcast); int32_t moq_origin_request(uint32_t origin, const char *path, uintptr_t path_len, const char *instance, uintptr_t instance_len, moq_status_callback on_broadcast, void *user_data); int32_t moq_origin_request_cancel(uint32_t task); int32_t moq_origin_follow(uint32_t origin, const char *path, uintptr_t path_len, const char *instance, uintptr_t instance_len, moq_status_callback on_broadcast, void *user_data); @@ -65,11 +64,21 @@ int32_t moq_origin_announced_free(uint32_t announced); int32_t moq_origin_announced_cancel(uint32_t announced); // config (NULL for everything): filter is relative to the literal prefix, or NULL for **. hidden also lists `.`-named paths. Updates stay relative to the origin. -// Publishing: Announcement (a publication from moq_origin_create_broadcast or moq_broadcast_prepared_publish) -int32_t moq_publication_announce(uint32_t publication, const moq_announce_route *route); -// route (NULL for the default): a cost, and an optional stable instance with its epoch. Hops are the origin's to add. -int32_t moq_publication_unannounce(uint32_t publication); -int32_t moq_publication_free(uint32_t publication); +// Publishing: Routes (freeing one retracts it; moq_publish_close on its broadcast ends both) +int32_t moq_origin_route(uint32_t origin, const char *path, uintptr_t path_len, const moq_route_options *options); +int32_t moq_origin_route_prefix(uint32_t origin, const char *prefix, uintptr_t prefix_len, const moq_route_options *options, moq_status_callback on_request, void *user_data); +// options (NULL for the default): hidden until moq_route_announce, a cost, and an optional stable instance with its epoch. Hops are the origin's to add. +int32_t moq_route_broadcast(uint32_t route); +int32_t moq_route_instance(uint32_t route, moq_string *dst); +int32_t moq_route_announce(uint32_t route); +int32_t moq_route_withdraw(uint32_t route); +int32_t moq_route_set_cost(uint32_t route, uint64_t cost); +int32_t moq_route_free(uint32_t route); +int32_t moq_broadcast_request_path(uint32_t request, moq_string *dst); +int32_t moq_broadcast_request_serve(uint32_t request, uint32_t broadcast); +int32_t moq_broadcast_request_route(uint32_t request, const moq_route_options *options); +int32_t moq_broadcast_request_reject(uint32_t request, uint16_t error_code); +int32_t moq_broadcast_request_free(uint32_t request); // Publishing int32_t moq_publish_close(uint32_t broadcast); diff --git a/rs/moq-c/c-tests/audio-decode-output.c b/rs/moq-c/c-tests/audio-decode-output.c index 73e0364d40a..59e6092f93f 100644 --- a/rs/moq-c/c-tests/audio-decode-output.c +++ b/rs/moq-c/c-tests/audio-decode-output.c @@ -104,11 +104,11 @@ int main(void) { int32_t origin = moq_origin_create(); CHECK(origin > 0); const char *path = "audio-decode-output"; - uint32_t broadcast = 0; - int32_t publication = moq_origin_create_broadcast((uint32_t)origin, path, strlen(path), &broadcast); - CHECK(publication > 0); - CHECK(moq_publication_announce((uint32_t)publication, NULL) == 0); - CHECK(moq_publication_free((uint32_t)publication) == 0); + int32_t route = moq_origin_route((uint32_t)origin, path, strlen(path), NULL); + CHECK(route > 0); + int32_t created = moq_route_broadcast((uint32_t)route); + CHECK(created > 0); + uint32_t broadcast = (uint32_t)created; moq_audio_encoder_input input = {MOQ_AUDIO_SAMPLE_FORMAT_F32, 48000, 2}; moq_audio_encoder_output output = {"pcm", 3, 0, 0, 0, 0}; int32_t producer = moq_encode_audio((uint32_t)broadcast, "audio", 5, &input, &output, 0); @@ -155,6 +155,7 @@ int main(void) { CHECK(moq_consume_catalog_free((uint32_t)c.catalog) == 0); CHECK(moq_consume_catalog_cancel((uint32_t)catalogs) == 0); CHECK(moq_consume_close((uint32_t)c.broadcast) == 0); + CHECK(moq_route_free((uint32_t)route) == 0); CHECK(moq_publish_close((uint32_t)broadcast) == 0); CHECK(moq_origin_close((uint32_t)origin) == 0); pthread_mutex_lock(&c.mutex); diff --git a/rs/moq-c/c-tests/decode-output.c b/rs/moq-c/c-tests/decode-output.c index c8dbaf59741..f2c431a2a3e 100644 --- a/rs/moq-c/c-tests/decode-output.c +++ b/rs/moq-c/c-tests/decode-output.c @@ -243,13 +243,11 @@ int main(void) { if (origin <= 0) fail("error: moq_origin_create failed: %d\n", origin); const char *path = "c-decoder-output-test"; - uint32_t broadcast = 0; - int32_t publication = moq_origin_create_broadcast((uint32_t)origin, path, strlen(path), &broadcast); - if (publication <= 0) fail("error: moq_origin_create_broadcast failed: %d\n", publication); - if (moq_publication_announce((uint32_t)publication, NULL) < 0) - fail("error: moq_publication_announce failed (%s)\n", moq_error()); - if (moq_publication_free((uint32_t)publication) < 0) - fail("error: moq_publication_free failed (%s)\n", moq_error()); + int32_t route = moq_origin_route((uint32_t)origin, path, strlen(path), NULL); + if (route <= 0) fail("error: moq_origin_route failed: %d\n", route); + int32_t created = moq_route_broadcast((uint32_t)route); + if (created <= 0) fail("error: moq_route_broadcast failed: %d\n", created); + uint32_t broadcast = (uint32_t)created; moq_video_encoder_input input = {MOQ_VIDEO_PIXEL_FORMAT_RGBA, WIDTH, HEIGHT, {30000, 1001}}; moq_video_encoder_output output = {MOQ_VIDEO_CODEC_H264, 0, 0, MOQ_VIDEO_ENCODER_KIND_SOFTWARE, NULL, 0}; @@ -300,6 +298,8 @@ int main(void) { fail("error: moq_consume_close failed (%s)\n", moq_error()); if (moq_encode_video_finish((uint32_t)producer) < 0) fail("error: moq_encode_video_finish failed (%s)\n", moq_error()); + if (moq_route_free((uint32_t)route) < 0) + fail("error: moq_route_free failed (%s)\n", moq_error()); if (moq_publish_close((uint32_t)broadcast) < 0) fail("error: moq_publish_close failed (%s)\n", moq_error()); if (moq_origin_close((uint32_t)origin) < 0) diff --git a/rs/moq-c/c-tests/timestamps.c b/rs/moq-c/c-tests/timestamps.c index 88954ac9292..cde792ca554 100644 --- a/rs/moq-c/c-tests/timestamps.c +++ b/rs/moq-c/c-tests/timestamps.c @@ -78,11 +78,11 @@ int main(void) { int32_t origin = moq_origin_create(); CHECK(origin > 0); const char *path = "timestamps"; - uint32_t broadcast = 0; - int32_t publication = moq_origin_create_broadcast((uint32_t)origin, path, strlen(path), &broadcast); - CHECK(publication > 0); - CHECK(moq_publication_announce((uint32_t)publication, NULL) == 0); - CHECK(moq_publication_free((uint32_t)publication) == 0); + int32_t route = moq_origin_route((uint32_t)origin, path, strlen(path), NULL); + CHECK(route > 0); + int32_t created = moq_route_broadcast((uint32_t)route); + CHECK(created > 0); + uint32_t broadcast = (uint32_t)created; moq_track_info info = {0}; info.timescale = 90000; info.timescale_present = true; @@ -153,6 +153,7 @@ int main(void) { CHECK(moq_consume_close((uint32_t)c.broadcast) == 0); CHECK(moq_publish_json_stream_finish((uint32_t)json) == 0); CHECK(moq_publish_track_finish((uint32_t)track) == 0); + CHECK(moq_route_free((uint32_t)route) == 0); CHECK(moq_publish_close((uint32_t)broadcast) == 0); CHECK(moq_origin_close((uint32_t)origin) == 0); WAIT_FOR(&c, c.request_done); diff --git a/rs/moq-c/src/api.rs b/rs/moq-c/src/api.rs index c207a408075..7d24725c83c 100644 --- a/rs/moq-c/src/api.rs +++ b/rs/moq-c/src/api.rs @@ -915,42 +915,45 @@ pub struct moq_section { pub json_len: usize, } -/// How a publication advertises its exact path: a static cost and, optionally, a stable -/// instance. +/// How a route advertises itself: its visibility at creation, a static cost and, optionally, +/// a stable instance. /// -/// Pass one to [moq_publication_announce]. The hop chain is the origin's to build, -/// so a local publisher cannot claim relay hops it never took. Zeroed (cost 0, NULL -/// instance) is the default route. `instance` is borrowed for the duration of the call. +/// Pass one to [moq_origin_route], [moq_origin_route_prefix], or [moq_broadcast_request_route]. +/// The hop chain is the origin's to build, so a local publisher cannot claim relay hops it +/// never took. Zeroed (or NULL) is the default: visible at once, cost 0, under a fresh +/// instance. `instance` is borrowed for the duration of the call. #[repr(C)] #[derive(Clone, Copy)] -pub struct moq_announce_route { +pub struct moq_route_options { /// Preference among routes covering the same prefix: lower wins. A publisher /// sets its production cost here: zero for content it is already producing, /// larger for content it would have to start producing on demand. pub cost: u64, - /// A stable instance for the stream, NOT NULL terminated, or NULL (or empty) to keep the - /// one the publication minted. + /// A stable instance for the stream, NOT NULL terminated, or NULL (or empty) to mint a + /// fresh one when the route is created. /// - /// Every publication mints a fresh instance, kept across re-announcing, so a restarted - /// publisher is a new stream viewers restart onto. Set one only for a publisher that - /// continues its group sequences across restarts and raises `epoch` on each: readers - /// stitch every route of one instance together, so restarting the sequences under an - /// old instance splices unrelated groups into their tracks. Changing it is a - /// `MOQ_ANNOUNCE_KIND_RESTART`. + /// A route keeps its instance for its lifetime, across [moq_route_withdraw] and + /// [moq_route_announce], so a new route is a new stream viewers restart onto. Set one only + /// for a publisher that continues its group sequences across restarts and raises `epoch` + /// on each: readers stitch every route of one instance together, so restarting the + /// sequences under an old instance splices unrelated groups into their tracks. pub instance: *const c_char, /// The length in bytes of `instance`. pub instance_len: usize, /// Which run of a stable `instance` this is: only its highest epoch is eligible, cheaper /// or not. Ignored without one. pub epoch: u64, + /// Create the route hidden: it exists for nobody until [moq_route_announce]. For a + /// publisher that fills its catalog first. + pub hidden: bool, } -/// An observed route: hops, a static cost, and the stream's instance. +/// The read-only facts on a received route: hops, a static cost, and the stream's instance. /// /// Carried by [moq_announce_event]. Its pointers borrow the announcement's storage. #[repr(C)] #[derive(Clone, Copy)] -pub struct moq_route { +pub struct moq_route_info { /// Hop ids of the relay hops the route traversed, oldest first. 0 is the /// anonymous mark, which ranks the route below every fully identified one. /// A route announced on this origin has none. @@ -963,18 +966,24 @@ pub struct moq_route { pub instance: moq_string, } -/// Parse a [moq_announce_route], treating NULL as the default. +/// Parse [moq_route_options], treating NULL as the default. +/// +/// The instance parses as at every API that takes one: NULL or empty names none. /// /// # Safety -/// `route` may be NULL, or must point at a readable [moq_announce_route] whose `instance` +/// `options` may be NULL, or must point at a readable [moq_route_options] whose `instance` /// pointer is valid for `instance_len` bytes. -unsafe fn parse_announce_route(route: *const moq_announce_route) -> Result { - let Some(route) = (unsafe { route.as_ref() }) else { - return Ok(moq_net::origin::Route::default()); +unsafe fn parse_route_options(options: *const moq_route_options) -> Result { + let Some(options) = (unsafe { options.as_ref() }) else { + return Ok(moq_net::origin::RouteOptions::default()); }; - let mut out = moq_net::origin::Route::default().with_cost(moq_net::origin::Cost::new(route.cost)); - if let Some(instance) = unsafe { parse_instance(route.instance, route.instance_len)? } { - out = out.with_instance(instance, route.epoch); + let mut out = match options.hidden { + true => moq_net::origin::RouteOptions::hidden(), + false => moq_net::origin::RouteOptions::default(), + } + .with_cost(options.cost); + if let Some(instance) = unsafe { parse_instance(options.instance, options.instance_len)? } { + out = out.with_instance(instance, options.epoch); } Ok(out) } @@ -1040,7 +1049,7 @@ pub struct moq_announce_event { /// The route serving the prefix. On `MOQ_ANNOUNCE_KIND_END` it carries the last /// advertised route. - pub route: moq_route, + pub route: moq_route_info, /// For [moq_announce_kind::MOQ_ANNOUNCE_KIND_TAKEOVER], the prefix of the route continued, /// relative to the origin, NOT NULL terminated. Empty for every other kind. pub predecessor: *const c_char, @@ -2004,89 +2013,178 @@ pub extern "C" fn moq_origin_create() -> i32 { ffi::enter(move || State::lock().origin.create()) } -/// Create a broadcast at `path` on an origin, for publishing media tracks. +/// Create a route at exactly `path` on an origin, owning a new broadcast to fill. /// -/// Writes the broadcast handle to fill with the `moq_publish_*` functions to -/// `broadcast`, and returns a positive publication handle that announces it, or a -/// negative code on failure. The broadcast is invisible and unroutable, on this -/// origin and its peers alike, until [moq_publication_announce]. Fill it, then -/// announce it. [moq_publish_close] ends it for good; -/// [moq_publication_free] releases the publication handle without retracting. +/// Returns a positive route handle, or a negative code on failure. [moq_route_broadcast] +/// gives the broadcast handle to fill with the `moq_publish_*` functions. The route is +/// visible at once unless `options` sets `hidden`: a hidden route is invisible and +/// unroutable, on this origin and its peers alike, until [moq_route_announce], so create +/// it hidden to fill the catalog first. NULL `options` is the default. +/// +/// Hold the route while the broadcast should stay announced: [moq_route_free] retracts it, +/// and [moq_publish_close] ends both. /// /// # Safety /// - The caller must ensure that path is a valid pointer to path_len bytes of data. -/// - `broadcast` must point at writable storage for one handle. +/// - `options` may be NULL, or must point at a readable [moq_route_options]. #[unsafe(no_mangle)] -pub unsafe extern "C" fn moq_origin_create_broadcast( +pub unsafe extern "C" fn moq_origin_route( origin: u32, path: *const c_char, path_len: usize, - broadcast: *mut u32, + options: *const moq_route_options, ) -> i32 { ffi::enter(move || { let origin = ffi::parse_id(origin)?; let path = unsafe { ffi::parse_str(path, path_len)? }; - let broadcast_out = unsafe { broadcast.as_mut() }.ok_or(Error::InvalidPointer)?; - + let options = unsafe { parse_route_options(options)? }; let mut state = State::lock(); - let publication = state.origin.create_broadcast(origin, path)?; - let (publication, broadcast) = state.publish.create_publication(publication)?; - *broadcast_out = broadcast.into(); - Ok(publication) + let route = state.origin.route(origin, path, options)?; + state.exact_route(route) }) } -/// Advertise `prefix` and serve the requests beneath it. +/// Create a route over `prefix` that serves the requests beneath it. /// /// A route claims `prefix` and every path beneath it (the empty prefix claims /// every path). A service that only serves some of them advertises the -/// covering prefix and rejects the rest as they are requested. `on_request` is -/// required: a NULL callback is refused before the route is advertised. It is -/// invoked with a positive request handle for each -/// pending broadcast, then exactly once more with a terminal code: `0` (stopped -/// cleanly, including after [moq_origin_requests_cancel]) or a negative error. +/// covering prefix and rejects the rest as they are requested. NULL `options` is the +/// default. +/// +/// `on_request` is required: a NULL callback is refused before the route is advertised. +/// It is invoked with a positive request handle for each pending broadcast (answer it with +/// [moq_broadcast_request_serve], [moq_broadcast_request_route], or +/// [moq_broadcast_request_reject]), then exactly once more with a terminal code: `0` +/// (stopped cleanly, after [moq_route_free] or the origin closing) or a negative error. /// After the terminal (`<= 0`) callback, `user_data` is never touched again. /// -/// Returns a non-zero handle on success, or a negative code on failure. +/// Returns a positive route handle on success, or a negative code on failure. /// /// # Safety /// - The caller must ensure that prefix is a valid pointer to prefix_len bytes of data. +/// - `options` may be NULL, or must point at a readable [moq_route_options]. /// - `on_request` must be non-NULL; a missing callback is refused before the route is advertised. /// - The caller must keep `user_data` valid until the terminal (`<= 0`) `on_request` callback. #[unsafe(no_mangle)] -pub unsafe extern "C" fn moq_origin_requests( +pub unsafe extern "C" fn moq_origin_route_prefix( origin: u32, prefix: *const c_char, prefix_len: usize, + options: *const moq_route_options, on_request: ffi::moq_status_callback, user_data: *mut c_void, ) -> i32 { ffi::enter(move || { let origin = ffi::parse_id(origin)?; let prefix = unsafe { ffi::parse_str(prefix, prefix_len)? }; + let options = unsafe { parse_route_options(options)? }; let on_request = unsafe { ffi::OnStatus::new(user_data, on_request)? }; - State::lock().origin.dynamic(origin, prefix, on_request) + State::lock().origin.route_prefix(origin, prefix, options, on_request) }) } -/// Stop serving and retract the route. +/// The broadcast an exact route owns, to fill with the `moq_publish_*` functions. /// -/// Returns immediately: zero on success, or a negative code if already closed. -/// The [moq_origin_requests] `on_request` callback still fires once more with a -/// terminal `0` (or a negative error), and that final callback is where -/// `user_data` should be released. +/// Returns the same positive broadcast handle on every call, or a negative code: a prefix +/// route owns none (`MOQ_ERROR_BROADCAST_NOT_FOUND`), and neither does a route whose +/// broadcast [moq_publish_close] ended. #[unsafe(no_mangle)] -pub extern "C" fn moq_origin_requests_cancel(dynamic: u32) -> i32 { +pub extern "C" fn moq_route_broadcast(route: u32) -> i32 { ffi::enter(move || { - let dynamic = ffi::parse_id(dynamic)?; - State::lock().origin.dynamic_close(dynamic) + let route = ffi::parse_id(route)?; + let state = State::lock(); + let broadcast = state.origin.route_broadcast(route)?; + match state.publish.contains(broadcast) { + true => Ok(broadcast), + false => Err(Error::BroadcastNotFound), + } + }) +} + +/// The stream a route serves, minted at creation unless its options named one. +/// +/// Kept across [moq_route_withdraw] and [moq_route_announce]. The destination borrows the +/// route's storage until [moq_route_free]. +/// +/// Returns zero on success, or a negative code on failure. +/// +/// # Safety +/// - `dst` must point at a writable [moq_string]. +#[unsafe(no_mangle)] +pub unsafe extern "C" fn moq_route_instance(route: u32, dst: *mut moq_string) -> i32 { + ffi::enter(move || { + let route = ffi::parse_id(route)?; + let dst = unsafe { dst.as_mut() }.ok_or(Error::InvalidPointer)?; + State::lock().origin.route_instance(route, dst) + }) +} + +/// Make a route visible, or keep it so. +/// +/// A route from [moq_broadcast_request_route] also answers the requesters waiting on its +/// path. Fails once its broadcast closed, and when a request's route can never announce +/// because the request was released or its prefix route retracted meanwhile. +/// +/// Returns zero on success, or a negative code on failure. +#[unsafe(no_mangle)] +pub extern "C" fn moq_route_announce(route: u32) -> i32 { + ffi::enter(move || { + let route = ffi::parse_id(route)?; + State::lock().origin.route_with(route, |route| route.announce()) + }) +} + +/// Hide a route from everyone, keeping its broadcast and instance. +/// +/// Local consumers and peers alike stop discovering and requesting it; tracks already in +/// flight carry on, and [moq_route_announce] brings the same stream back. +/// Returns zero on success, or a negative code on failure. +#[unsafe(no_mangle)] +pub extern "C" fn moq_route_withdraw(route: u32) -> i32 { + ffi::enter(move || { + let route = ffi::parse_id(route)?; + State::lock().origin.route_with(route, |route| { + route.withdraw(); + Ok(()) + }) + }) +} + +/// Re-price a route in place: lower wins among routes covering the same prefix. +/// +/// A hidden route keeps the price for when it next announces. Fails once its broadcast +/// closed. Returns zero on success, or a negative code on failure. +#[unsafe(no_mangle)] +pub extern "C" fn moq_route_set_cost(route: u32, cost: u64) -> i32 { + ffi::enter(move || { + let route = ffi::parse_id(route)?; + State::lock().origin.route_with(route, |route| route.set_cost(cost)) + }) +} + +/// Release a route handle, retracting the route. +/// +/// An exact route's broadcast handle stays the caller's until [moq_publish_close]. A prefix +/// route stops serving: requests not yet delivered are rejected, and its `on_request` +/// callback fires once more with a terminal `0`, which is where `user_data` should be +/// released. +/// +/// Returns zero on success, or a negative code if the handle is unknown. +#[unsafe(no_mangle)] +pub extern "C" fn moq_route_free(route: u32) -> i32 { + ffi::enter(move || { + let route = ffi::parse_id(route)?; + // Dropped outside the lock: retracting refuses a job's waiting requesters. + let route = State::lock().origin.route_take(route)?; + drop(route); + Ok(()) }) } -/// The path of a broadcast request delivered to a [moq_origin_requests] callback. +/// The path of a broadcast request delivered to a [moq_origin_route_prefix] callback. /// /// The destination borrows the request's storage: copy it out before -/// [moq_broadcast_request_serve], [moq_broadcast_request_prepare], +/// [moq_broadcast_request_serve], [moq_broadcast_request_route], /// [moq_broadcast_request_reject], or [moq_broadcast_request_free]. /// /// Returns a zero on success, or a negative code on failure. @@ -2105,7 +2203,7 @@ pub unsafe extern "C" fn moq_broadcast_request_path(request: u32, dst: *mut moq_ /// Serve a held consumer under the prefix route's instance without announcing an exact route. /// /// Every answer at this path must continue the same sequences and bytes. Start a new -/// prefix route for different content, or prepare and publish a job with its own instance. +/// prefix route for different content, or route a job with its own instance. /// Consumes the request handle; the consumer remains owned by the caller. /// Returns zero on success, or a negative error. #[unsafe(no_mangle)] @@ -2123,55 +2221,28 @@ pub extern "C" fn moq_broadcast_request_serve(request: u32, broadcast: u32) -> i }) } -/// Start a broadcast request answer as a new stream under a fresh instance, hidden until -/// published. +/// Answer a broadcast request with the path's own exact route, owning a new broadcast. /// -/// Consumes the request handle, writes the new broadcast handle to `broadcast` -/// (which cannot announce itself; only [moq_broadcast_prepared_publish] does), -/// and returns a positive prepared-answer handle or a negative error. +/// Consumes the request handle and returns a positive route handle, or a negative error. +/// The route serves a fresh instance unless `options` names one, so a job that restarts is +/// a new stream. Created visible, it announces now and answers the waiting requesters; +/// created hidden, they wait until [moq_route_announce], so the job can fill its catalog +/// first, and freeing the route before then refuses them. Ending the route withdraws only +/// this path. Unreadable `options` fail without consuming the request. /// /// # Safety -/// - `broadcast` must point at writable storage for one handle. +/// - `options` may be NULL, or must point at a readable [moq_route_options]. #[unsafe(no_mangle)] -pub unsafe extern "C" fn moq_broadcast_request_prepare(request: u32, broadcast: *mut u32) -> i32 { +pub unsafe extern "C" fn moq_broadcast_request_route(request: u32, options: *const moq_route_options) -> i32 { ffi::enter(move || { let request = ffi::parse_id(request)?; - let broadcast_out = unsafe { broadcast.as_mut() }.ok_or(Error::InvalidPointer)?; + let options = unsafe { parse_route_options(options)? }; let mut state = State::lock(); let (pending, driver) = state.origin.broadcast_request_take(request)?; - let prepared = pending.prepare()?; - let broadcast = state.publish.create((prepared.broadcast().clone(), driver.clone()))?; - let id = state.origin.prepared_insert(prepared, driver, broadcast)?; - *broadcast_out = broadcast.into(); - Ok(id) - }) -} - -/// Publish a prepared claim answer and resolve every waiting requester. -/// -/// Consumes the prepared handle and returns a positive publication handle, or a -/// negative code on failure. The broadcast handle returned by -/// [moq_broadcast_request_prepare] remains owned by the caller. -#[unsafe(no_mangle)] -pub extern "C" fn moq_broadcast_prepared_publish(prepared: u32) -> i32 { - ffi::enter(move || { - let prepared = ffi::parse_id(prepared)?; - let mut state = State::lock(); - let (prepared, driver, broadcast) = state.origin.prepared_take(prepared)?; driver.check()?; - let result = state.publish.admit(broadcast, prepared, driver.clone()); + let result = pending.route(options); driver.check()?; - result - }) -} - -/// Free a prepared claim answer without publishing it. -#[unsafe(no_mangle)] -pub extern "C" fn moq_broadcast_prepared_free(prepared: u32) -> i32 { - ffi::enter(move || { - let prepared = ffi::parse_id(prepared)?; - State::lock().origin.prepared_take(prepared)?; - Ok(()) + state.exact_route((result?, driver)) }) } @@ -2191,7 +2262,7 @@ pub extern "C" fn moq_broadcast_request_reject(request: u32, error_code: u16) -> }) } -/// Free a broadcast request without accepting or rejecting it. +/// Free a broadcast request without answering it. /// /// Dropping the request rejects it. Returns a zero on success, or a negative /// code if the handle is unknown. @@ -2368,8 +2439,8 @@ pub extern "C" fn moq_origin_follow_cancel(task: u32) -> i32 { /// /// Owns discovery of the path and retries route churn while resolving one publisher instance. /// It fails as unroutable once discovery has synced without a covering route, including a -/// broadcast created but not announced. No separate announcement stream is needed. -/// Serve on-demand paths with [moq_origin_requests]. +/// hidden route not announced yet. No separate announcement stream is needed. +/// Serve on-demand paths with [moq_origin_route_prefix]. /// /// `instance` is the only stream to accept, or NULL (or empty) for any. A request pinned to an /// instance that does not serve the path is unroutable. @@ -2435,8 +2506,7 @@ unsafe fn parse_instance(instance: *const c_char, instance_len: usize) -> Result /// Close an origin and clean up its resources. /// -/// The origin keeps running while a broadcast published on it or a -/// [moq_origin_requests] handler lives; close or cancel those to end it. +/// The origin keeps running while a route created on it lives; free those to end it. /// /// Returns a zero on success, or a negative code on failure. #[unsafe(no_mangle)] @@ -2447,51 +2517,6 @@ pub extern "C" fn moq_origin_close(origin: u32) -> i32 { }) } -/// Advertise a publication's exact path as a route. -/// -/// Announcing again re-prices the route in place, or restarts it under another instance. A -/// NULL `route` uses the default: cost 0, under the instance the publication minted. Until -/// announced, the broadcast is invisible and unroutable for local consumers and peers alike. -/// Fails once the broadcast closed. -/// -/// Returns a zero on success, or a negative code on failure. -/// -/// # Safety -/// - `route` may be NULL, or must point at a readable [moq_announce_route]. -#[unsafe(no_mangle)] -pub unsafe extern "C" fn moq_publication_announce(publication: u32, route: *const moq_announce_route) -> i32 { - ffi::enter(move || { - let publication = ffi::parse_id(publication)?; - let route = unsafe { parse_announce_route(route)? }; - State::lock().publish.announce(publication, route) - }) -} - -/// Retract a publication's exact-path advertisement, if any. -/// -/// Local consumers and peers alike stop discovering and requesting it; tracks already in -/// flight carry on, and announcing again brings it back. Fails once the broadcast closed. -/// Returns a zero on success, or a negative code on failure. -#[unsafe(no_mangle)] -pub extern "C" fn moq_publication_unannounce(publication: u32) -> i32 { - ffi::enter(move || { - let publication = ffi::parse_id(publication)?; - State::lock().publish.unannounce(publication) - }) -} - -/// Release a publication handle. -/// -/// The broadcast and its route stay as they are; [moq_publish_close] ends them. -/// Returns a zero on success, or a negative code on failure. -#[unsafe(no_mangle)] -pub extern "C" fn moq_publication_free(publication: u32) -> i32 { - ffi::enter(move || { - let publication = ffi::parse_id(publication)?; - State::lock().publish.publication_free(publication) - }) -} - /// End a broadcast for good and release its handle. /// /// The origin retracts the path immediately and serves no new tracks. Every media, raw track, @@ -2889,7 +2914,7 @@ pub unsafe extern "C" fn moq_publish_video_properties(broadcast: u32, properties /// /// This is the producer counterpart to [moq_consume_video_config]: instead of /// reading a rendition out of a catalog, it writes one into the catalog of a -/// broadcast created with [moq_origin_create_broadcast]. The rendition is keyed by +/// broadcast from [moq_route_broadcast]. The rendition is keyed by /// `config.name`; calling this again with the same name replaces the rendition /// you declared, so a config can be refined in place. It fails when a /// [moq_publish_video] track owns the name, since that track publishes and @@ -3026,7 +3051,7 @@ pub unsafe extern "C" fn moq_publish_audio_remove(broadcast: u32, name: *const c /// /// This is the producer counterpart to [moq_consume_catalog_section] / /// [moq_consume_catalog_section_at]: it writes an arbitrary top-level JSON key into the -/// catalog of a broadcast created with [moq_origin_create_broadcast], beyond the +/// catalog of a broadcast from [moq_route_broadcast], beyond the /// `video`/`audio` keys owned by the media pipeline. Calling it again with the /// same name replaces the section. The updated catalog is published to /// subscribers automatically. diff --git a/rs/moq-c/src/origin.rs b/rs/moq-c/src/origin.rs index 2463579830a..53e424157de 100644 --- a/rs/moq-c/src/origin.rs +++ b/rs/moq-c/src/origin.rs @@ -3,7 +3,7 @@ use tokio::sync::oneshot; use crate::ffi::OnStatus; use crate::task::Task; -use crate::{Error, Id, NonZeroSlab, State, moq_announce_event, moq_announce_kind, moq_route, moq_string}; +use crate::{Error, Id, NonZeroSlab, State, moq_announce_event, moq_announce_kind, moq_route_info, moq_string}; /// Global state managing all active resources. /// @@ -25,14 +25,15 @@ pub struct Origin { /// Pending consume-until-announced tasks. Close signals shutdown; the task delivers a final callback, then removes itself. consume_task: NonZeroSlab, - /// Served routes from [Self::dynamic], retracted when the handle is closed. - dynamic: NonZeroSlab, + /// Routes created on an origin, retracted when freed. + routes: NonZeroSlab, - /// Broadcast requests delivered to a dynamic handler, freed after accept/reject. - broadcast_request: NonZeroSlab<(moq_net::origin::Request, crate::ffi::Background)>, + /// Request deliveries of prefix routes. Freeing the route signals shutdown; the task + /// delivers a final callback, then removes itself. + route_requests: NonZeroSlab, - /// Claim answers being filled before their exact route is announced. - prepared: NonZeroSlab<(moq_net::origin::Prepared, crate::ffi::Background, Id)>, + /// Broadcast requests delivered to a prefix route's callback, freed after serve/route/reject. + broadcast_request: NonZeroSlab<(moq_net::origin::Request, crate::ffi::Background)>, } #[derive(Clone)] @@ -121,21 +122,39 @@ impl AnnouncedRecord { _captures: captures, capture_views, kind, - hops: update.route.hops.iter().map(|hop| hop.id()).collect(), - cost: update.route.cost.value(), - instance: update - .route - .instance - .map(|instance| instance.to_string()) - .unwrap_or_default(), + hops: update.route.hops().iter().map(|hop| hop.id()).collect(), + cost: update.route.cost().value(), + instance: update.route.instance().to_string(), predecessor, } } } -struct DynamicEntry { - task: Task, - inner: Option, +impl State { + /// Store an exact route and the fill handle of the broadcast it owns, returning the route. + pub fn exact_route( + &mut self, + (route, driver): (moq_net::origin::Route, crate::ffi::Background), + ) -> Result { + let broadcast = self.publish.create((route.broadcast().clone(), driver.clone()))?; + self.origin.route_insert(route, driver, broadcast).inspect_err(|_| { + self.publish.discard(broadcast); + }) + } +} + +struct RouteEntry { + inner: moq_net::origin::Route, + driver: crate::ffi::Background, + /// Minted at creation and kept for the route's lifetime, borrowed by [Origin::route_instance]. + instance: String, + /// An exact route's broadcast fill handle, or a prefix route's request delivery task. + kind: RouteKind, +} + +enum RouteKind { + Exact { broadcast: Id }, + Prefix { requests: Id }, } impl Origin { @@ -208,7 +227,7 @@ impl Origin { captures: announced.capture_views.as_ptr(), captures_len: announced.capture_views.len(), kind: announced.kind, - route: moq_route { + route: moq_route_info { hops: announced.hops.as_ptr(), hops_len: announced.hops.len(), cost: announced.cost, @@ -358,49 +377,83 @@ impl Origin { self.consume_task.close(task, Error::NotFound) } - /// Create an unannounced broadcast at `path` on an origin. + /// Create an exact route at `path`, returning the route and the broadcast it owns. /// /// Errors with [`Error::Moq`] if the path is outside the origin's scope. - pub fn create_broadcast>>( + pub fn route( &self, origin: Id, - path: P, - ) -> Result<(moq_net::origin::Publication, crate::ffi::Background), Error> { + path: &str, + options: moq_net::origin::RouteOptions, + ) -> Result<(moq_net::origin::Route, crate::ffi::Background), Error> { let origin = self.get(origin)?; - let result = origin.producer.create_broadcast(path); + let result = origin.producer.route(path, options); origin.driver.check()?; Ok((result?, origin.driver.clone())) } - /// Advertise `prefix` and serve requests beneath it, delivering each as a - /// broadcast-request handle via `on_request`. - pub fn dynamic(&mut self, origin: Id, prefix: &str, on_request: OnStatus) -> Result { - let origin = self.active.get(origin).ok_or(Error::OriginNotFound)?; - origin.driver.check()?; + /// Store an exact route whose broadcast fill handle is `broadcast`. + pub fn route_insert( + &mut self, + route: moq_net::origin::Route, + driver: crate::ffi::Background, + broadcast: Id, + ) -> Result { + self.routes.insert(RouteEntry { + instance: route.instance().to_string(), + inner: route, + driver, + kind: RouteKind::Exact { broadcast }, + }) + } + + /// Create a prefix route, delivering each request beneath it as a broadcast-request handle + /// via `on_request`. + pub fn route_prefix( + &mut self, + origin: Id, + prefix: &str, + options: moq_net::origin::RouteOptions, + on_request: OnStatus, + ) -> Result { + let origin = self.get(origin)?; let driver = origin.driver.clone(); - let result = origin.producer.requests(prefix); - origin.driver.check()?; - let inner = result?; + let result = origin.producer.route_prefix(prefix, options); + driver.check()?; + let route = result?; + let instance = route.instance().to_string(); + + // The route first, so the delivery task finds it once it runs; it cannot lock the + // state before this call returns. let (task, close) = Task::new(on_request); - let id = self.dynamic.insert(DynamicEntry { - task, - inner: Some(inner), - })?; + let requests = self.route_requests.insert(task)?; + let id = match self.routes.insert(RouteEntry { + inner: route, + driver: driver.clone(), + instance, + kind: RouteKind::Prefix { requests }, + }) { + Ok(id) => id, + Err(err) => { + self.route_requests.remove(requests); + return Err(err); + } + }; - let request_driver = driver.clone(); tokio::spawn(async move { - let res = crate::ffi::run(driver.watch(Self::run_dynamic(id, close, request_driver))).await; - let entry = State::lock().origin.dynamic.remove(id); + let res = crate::ffi::run(driver.watch(Self::run_requests(id, on_request, close, driver.clone()))).await; + let entry = State::lock().origin.route_requests.remove(requests); if let Some(entry) = entry { - entry.task.callback.call(res); + entry.callback.call(res); } }); Ok(id) } - async fn run_dynamic( - id: Id, + async fn run_requests( + route: Id, + callback: OnStatus, mut close: oneshot::Receiver<()>, driver: crate::ffi::Background, ) -> Result<(), Error> { @@ -408,39 +461,74 @@ impl Origin { let request = tokio::select! { biased; _ = &mut close => return Ok(()), - res = kio::wait(|waiter| { + request = kio::wait(|waiter| { let state = State::lock(); - match state.origin.dynamic.get(id).and_then(|entry| entry.inner.as_ref()) { - Some(dynamic) => dynamic.poll_requested_broadcast(waiter), - None => std::task::Poll::Ready(Err(moq_net::Error::Closed)), + match state.origin.routes.get(route) { + Some(entry) => entry.inner.poll_requested(waiter), + None => std::task::Poll::Ready(None), } - }) => match res { - Ok(request) => request, - Err(moq_net::Error::Closed) => return Ok(()), - Err(err) => return Err(err.into()), + }) => match request { + Some(request) => request, + // Retracted, or the origin closed. + None => return Ok(()), }, }; + // Hold the lock only to buffer the request; release it before the callback. let request_id = State::lock() .origin .broadcast_request .insert((request, driver.clone()))?; - let callback = State::lock().origin.dynamic.get(id).map(|entry| entry.task.callback); - let Some(callback) = callback else { - return Ok(()); - }; callback.call(request_id); } } - pub fn dynamic_close(&mut self, dynamic: Id) -> Result<(), Error> { - let entry = self.dynamic.get_mut(dynamic).ok_or(Error::NotFound)?; - let inner = entry.inner.take().ok_or(Error::NotFound)?; - entry.task.close(Error::NotFound)?; - drop(inner); + fn route_entry(&self, route: Id) -> Result<&RouteEntry, Error> { + let entry = self.routes.get(route).ok_or(Error::NotFound)?; + entry.driver.check()?; + Ok(entry) + } + + /// Run `f` against the route, then check its origin is still healthy. + pub fn route_with( + &self, + route: Id, + f: impl FnOnce(&moq_net::origin::Route) -> Result, + ) -> Result { + let entry = self.route_entry(route)?; + let result = f(&entry.inner); + entry.driver.check()?; + Ok(result?) + } + + /// An exact route's broadcast fill handle, or [`Error::BroadcastNotFound`] on a prefix route. + pub fn route_broadcast(&self, route: Id) -> Result { + match self.route_entry(route)?.kind { + RouteKind::Exact { broadcast } => Ok(broadcast), + RouteKind::Prefix { .. } => Err(Error::BroadcastNotFound), + } + } + + pub fn route_instance(&self, route: Id, dst: &mut moq_string) -> Result<(), Error> { + let entry = self.route_entry(route)?; + *dst = moq_string { + data: entry.instance.as_ptr().cast::(), + len: entry.instance.len(), + }; Ok(()) } + /// Release a route handle and stop a prefix route's request delivery, returning the route + /// for the caller to retract by dropping it. + pub fn route_take(&mut self, route: Id) -> Result { + let entry = self.routes.remove(route).ok_or(Error::NotFound)?; + if let RouteKind::Prefix { requests } = entry.kind { + // Already gone once the origin closed and the task delivered its terminal callback. + let _ = self.route_requests.close(requests, Error::NotFound); + } + Ok(entry.inner) + } + pub fn broadcast_request_path(&self, request: Id, dst: &mut crate::moq_string) -> Result<(), Error> { let request = self.broadcast_request.get(request).ok_or(Error::NotFound)?; let path = request.0.path(); @@ -458,22 +546,6 @@ impl Origin { self.broadcast_request.remove(request).ok_or(Error::NotFound) } - pub fn prepared_insert( - &mut self, - prepared: moq_net::origin::Prepared, - driver: crate::ffi::Background, - broadcast: Id, - ) -> Result { - self.prepared.insert((prepared, driver, broadcast)) - } - - pub fn prepared_take( - &mut self, - prepared: Id, - ) -> Result<(moq_net::origin::Prepared, crate::ffi::Background, Id), Error> { - self.prepared.remove(prepared).ok_or(Error::NotFound) - } - pub fn close(&mut self, origin: Id) -> Result<(), Error> { self.active.remove(origin).ok_or(Error::OriginNotFound)?; Ok(()) @@ -483,36 +555,35 @@ impl Origin { #[cfg(test)] mod supervision_tests { use super::*; + use moq_net::origin::RouteOptions; #[tokio::test] - async fn a_broadcast_keeps_the_origin_failure_after_its_origin_handle_is_released() { + async fn a_route_keeps_the_origin_failure_after_its_origin_handle_is_released() { let (producer, completion, trigger) = crate::ffi::panicking_origin(); - let mut origins = Origin::default(); - let origin = origins + let mut state = State::new(); + let origin = state + .origin .active .insert(Producer { producer, driver: completion.clone(), }) .unwrap(); - let mut publish = crate::publish::Publish::default(); - let (publication, _broadcast) = publish - .create_publication(origins.create_broadcast(origin, "retained").unwrap()) - .unwrap(); - origins.close(origin).unwrap(); + let retained = state.origin.route(origin, "retained", RouteOptions::hidden()).unwrap(); + let route = state.exact_route(retained).unwrap(); + state.origin.close(origin).unwrap(); *trigger .write() .unwrap_or_else(|_| unreachable!("test keeps its panic trigger open")) = true; assert!(matches!(completion.finished().await, Err(Error::Panic))); drop(completion); assert!(matches!( - publish.announce(publication, Default::default()), + state.origin.route_with(route, |route| route.announce()), Err(Error::Panic) )); - let healthy = origins.create().unwrap(); - let (publication, _broadcast) = publish - .create_publication(origins.create_broadcast(healthy, "healthy").unwrap()) - .unwrap(); - publish.announce(publication, Default::default()).unwrap(); + let healthy = state.origin.create().unwrap(); + let healthy = state.origin.route(healthy, "healthy", RouteOptions::hidden()).unwrap(); + let route = state.exact_route(healthy).unwrap(); + state.origin.route_with(route, |route| route.announce()).unwrap(); } } diff --git a/rs/moq-c/src/publish.rs b/rs/moq-c/src/publish.rs index 407c88fbcf3..3a74b4cb9b6 100644 --- a/rs/moq-c/src/publish.rs +++ b/rs/moq-c/src/publish.rs @@ -316,17 +316,6 @@ pub struct Publish { /// Group requests delivered to a handler, freed on accept, abort, or free. group_request: NonZeroSlab, - - /// Announcement handles for origin broadcasts, freed by the caller. - publications: NonZeroSlab, -} - -/// A broadcast's announcement capability, beside the fill handle it was published with. -struct Publication { - driver: crate::ffi::Background, - /// The fill handle, which leaves the registry once the broadcast closes. - broadcast: Id, - inner: moq_net::origin::Publication, } impl Publish { @@ -364,77 +353,14 @@ impl Publish { Ok(id) } - /// Store an origin broadcast's fill handle and its publication, returning both handles. - pub fn create_publication( - &mut self, - (publication, driver): (moq_net::origin::Publication, crate::ffi::Background), - ) -> Result<(Id, Id), Error> { - let broadcast = self.create((publication.broadcast().clone(), driver.clone()))?; - let id = self.publications.insert(Publication { - driver, - broadcast, - inner: publication, - }); - match id { - Ok(id) => Ok((id, broadcast)), - Err(err) => { - self.broadcasts.remove(broadcast); - Err(err) - } - } - } - - /// Publish a prepared answer filled through `id`, returning its publication handle. - pub fn admit( - &mut self, - id: Id, - prepared: moq_net::origin::Prepared, - driver: crate::ffi::Background, - ) -> Result { - if let Some(broadcast) = self.broadcasts.get(id) { - broadcast.driver.check()?; - if !broadcast.producer.is_clone(prepared.broadcast()) { - return Err(Error::BroadcastNotFound); - } - } - // A closed fill left this registry, and native admission refuses it. - let publication = prepared.publish()?; - self.publications.insert(Publication { - driver, - broadcast: id, - inner: publication, - }) + /// Whether `id` names a broadcast fill handle that has not been closed. + pub fn contains(&self, id: Id) -> bool { + self.broadcasts.get(id).is_some() } - /// The publication, refused with `Closed` once its broadcast closed. - fn publication(&self, id: Id) -> Result<&Publication, Error> { - let publication = self.publications.get(id).ok_or(Error::NotFound)?; - publication.driver.check()?; - if self.broadcasts.get(publication.broadcast).is_none() { - return Err(Error::Moq(moq_net::Error::Closed)); - } - Ok(publication) - } - - /// Advertise the broadcast's exact path as a route. Announcing again re-prices - /// in place. Until announced, the broadcast is invisible and unroutable. - pub fn announce(&mut self, publication: Id, route: moq_net::origin::Route) -> Result<(), Error> { - let publication = self.publication(publication)?; - let result = publication.inner.announce(route); - publication.driver.check()?; - Ok(result?) - } - - /// Retract the broadcast's exact-path advertisement, if any. - pub fn unannounce(&mut self, publication: Id) -> Result<(), Error> { - self.publication(publication)?.inner.unannounce(); - Ok(()) - } - - /// Release a publication handle; the broadcast and its route stay as they are. - pub fn publication_free(&mut self, publication: Id) -> Result<(), Error> { - self.publications.remove(publication).ok_or(Error::NotFound)?; - Ok(()) + /// Drop a fill handle that never reached the caller. + pub fn discard(&mut self, id: Id) { + self.broadcasts.remove(id); } /// The broadcast's track producer. @@ -1634,53 +1560,14 @@ mod children_tests { mod supervision_tests { use super::*; - #[tokio::test(start_paused = true)] - 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("room/first", None); - let prepared = claim.requested_broadcast().await.unwrap().prepare().unwrap(); - let mut publish = Publish::default(); - let first = publish - .create((prepared.broadcast().clone(), Default::default())) - .unwrap(); - let alias = { - let original = publish.broadcast(first).unwrap(); - Broadcast { - driver: original.driver.clone(), - producer: original.producer.clone(), - catalog: original.catalog.clone(), - video: Default::default(), - audio: Default::default(), - children: Default::default(), - ended: false, - } - }; - let clone = publish.broadcasts.insert(alias).unwrap(); - assert_ne!(first, clone); - let publication = publish.admit(clone, prepared, Default::default()).unwrap(); - pending.await.unwrap(); - publish.unannounce(publication).unwrap(); - - let pending = origin.consume().request("room/second", None); - let prepared = claim.requested_broadcast().await.unwrap().prepare().unwrap(); - publish - .create((prepared.broadcast().clone(), Default::default())) - .unwrap(); - assert!(matches!( - publish.admit(first, prepared, Default::default()), - Err(Error::BroadcastNotFound) - )); - assert!(pending.await.is_err()); - } - #[tokio::test] async fn a_container_importer_keeps_the_origin_failure_after_other_owners_are_released() { let (origin, completion, trigger) = crate::ffi::panicking_origin(); let mut publish = Publish::default(); - let (_publication, broadcast) = publish - .create_publication((origin.create_broadcast("retained").unwrap(), completion.clone())) + let route = origin + .route("retained", moq_net::origin::RouteOptions::hidden()) .unwrap(); + let broadcast = publish.create((route.broadcast().clone(), completion.clone())).unwrap(); let container = publish .container( broadcast, @@ -1702,9 +1589,12 @@ mod supervision_tests { async fn a_finish_after_a_driver_panic_reports_it_until_the_close() { let (origin, completion, trigger) = crate::ffi::panicking_origin(); let mut state = State::new(); - let (_publication, broadcast) = state + let route = origin + .route("retained", moq_net::origin::RouteOptions::hidden()) + .unwrap(); + let broadcast = state .publish - .create_publication((origin.create_broadcast("retained").unwrap(), completion.clone())) + .create((route.broadcast().clone(), completion.clone())) .unwrap(); let producer = &state.publish.broadcast(broadcast).unwrap().producer; // A dynamic handle outlives the consumed broadcast, so only an explicit close ends it. diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index dc80f7a93db..b5eb9623206 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -41,21 +41,46 @@ fn id(raw: i32) -> u32 { raw as u32 } -/// Create a broadcast at `path` on `origin`, returning its publication and fill handles. -fn create_broadcast(origin: u32, path: &[u8]) -> (u32, u32) { - let mut broadcast = 0; - let publication = - id(unsafe { moq_origin_create_broadcast(origin, path.as_ptr() as *const c_char, path.len(), &mut broadcast) }); - (publication, broadcast) +/// Create a route at `path` on `origin`, returning its route and broadcast fill handles. +fn create_route(origin: u32, path: &[u8], options: Option<&moq_route_options>) -> (u32, u32) { + let options = options.map_or(std::ptr::null(), |options| options as *const _); + let route = id(unsafe { moq_origin_route(origin, path.as_ptr() as *const c_char, path.len(), options) }); + (route, id(moq_route_broadcast(route))) } -/// Create a broadcast at `path` on `origin` and announce it, keeping only the fill handle: -/// releasing the publication leaves the route up. +/// Create a visible route at `path` on `origin`, keeping only the fill handle. The route handle +/// stays registered for the rest of the test process, so the path stays announced until the +/// broadcast closes. fn publish_broadcast(origin: u32, path: &[u8]) -> u32 { - let (publication, broadcast) = create_broadcast(origin, path); - assert_eq!(unsafe { moq_publication_announce(publication, std::ptr::null()) }, 0); - assert_eq!(moq_publication_free(publication), 0); - broadcast + create_route(origin, path, None).1 +} + +/// Route options at `cost` under the stable `instance`, borrowing it. +fn route_options(cost: u64, instance: &str, hidden: bool) -> moq_route_options { + moq_route_options { + cost, + instance: instance.as_ptr().cast(), + instance_len: instance.len(), + epoch: 0, + hidden, + } +} + +/// Default route options, created hidden. +fn hidden() -> moq_route_options { + route_options(0, "", true) +} + +/// The instance a route serves. +fn instance_of(route: u32) -> String { + let mut dst = moq_string { + data: std::ptr::null(), + len: 0, + }; + assert_eq!(unsafe { moq_route_instance(route, &mut dst) }, 0); + unsafe { std::str::from_utf8(std::slice::from_raw_parts(dst.data.cast::(), dst.len)) } + .unwrap() + .to_string() } /// Request a published broadcast via `moq_origin_request` and return its handle. @@ -166,7 +191,7 @@ fn announce_info(announced: u32) -> moq_announce_event { captures: std::ptr::null(), captures_len: 0, kind: moq_announce_kind::MOQ_ANNOUNCE_KIND_START, - route: moq_route { + route: moq_route_info { hops: std::ptr::null(), hops_len: 0, cost: 0, @@ -187,18 +212,8 @@ fn fresh_instance() -> String { moq_net::Instance::random().to_string() } -/// An announce route at `cost` under the stable `instance`, borrowing it. -fn announce_route(cost: u64, instance: &str) -> moq_announce_route { - moq_announce_route { - cost, - instance: instance.as_ptr().cast(), - instance_len: instance.len(), - epoch: 0, - } -} - /// The instance a received route carries. -fn route_instance(route: &moq_route) -> Option { +fn route_instance(route: &moq_route_info) -> Option { (route.instance.len > 0).then(|| unsafe { std::str::from_utf8(std::slice::from_raw_parts( route.instance.data.cast::(), @@ -3577,75 +3592,91 @@ fn announced_deactivation() { let announced_task = id(unsafe { moq_origin_announced(origin, std::ptr::null(), Some(channel_callback), cb.ptr) }); let path = b"deactivate/test"; - let (publication, broadcast) = create_broadcast(origin, path); - assert_eq!(unsafe { moq_publication_announce(publication, std::ptr::null()) }, 0); + let (route, broadcast) = create_route(origin, path, None); + let instance = instance_of(route); let (announced_id, info) = cb.recv_route(); assert_eq!(info.kind, moq_announce_kind::MOQ_ANNOUNCE_KIND_START); + assert_eq!(route_instance(&info.route).as_ref(), Some(&instance)); assert_eq!(moq_origin_announced_free(announced_id), 0); - // Going non-live unannounces the broadcast without tearing it down: local - // consumers stop reaching it, exactly as peers do, until it announces again. - assert_eq!(moq_publication_unannounce(publication), 0); + // Withdrawing hides the route without tearing down its broadcast: local consumers stop + // reaching it, exactly as peers do, until it announces again. + assert_eq!(moq_route_withdraw(route), 0); let (deactivated_id, info) = cb.recv_route(); assert_eq!(info.kind, moq_announce_kind::MOQ_ANNOUNCE_KIND_END); assert_eq!(moq_origin_announced_free(deactivated_id), 0); - assert!(request_once(origin, path) < 0, "an unannounced broadcast is unroutable"); + assert!(request_once(origin, path) < 0, "a withdrawn broadcast is unroutable"); - assert_eq!(unsafe { moq_publication_announce(publication, std::ptr::null()) }, 0); + // Announcing again continues the same stream. + assert_eq!(moq_route_announce(route), 0); let (reannounced_id, info) = cb.recv_route(); assert_eq!(info.kind, moq_announce_kind::MOQ_ANNOUNCE_KIND_START); + assert_eq!(route_instance(&info.route), Some(instance)); assert_eq!(moq_origin_announced_free(reannounced_id), 0); let _ = request_broadcast(origin, path); assert_eq!(moq_origin_announced_cancel(announced_task), 0); assert_eq!(cb.recv_terminal(), 0, "announced close delivers terminal 0"); assert_eq!(moq_publish_close(broadcast), 0); - assert!( - unsafe { moq_publication_announce(publication, std::ptr::null()) } < 0, - "a closed broadcast cannot announce" - ); - assert_eq!(moq_publication_free(publication), 0); - assert!(moq_publication_free(publication) < 0, "a freed publication is released"); + assert!(moq_route_announce(route) < 0, "a closed broadcast cannot announce"); + assert!(moq_route_broadcast(route) < 0, "a closed broadcast leaves the route"); + assert_eq!(moq_route_free(route), 0); + assert!(moq_route_free(route) < 0, "a freed route is released"); assert_eq!(moq_origin_close(origin), 0); } -/// A publication outliving its closed broadcast cannot announce or withdraw the broadcast that +/// Freeing the route retracts it, though its broadcast handle stays the caller's to close. +#[test] +fn freeing_a_route_retracts_it() { + let origin = id(moq_origin_create()); + let path = b"freed"; + let (route, broadcast) = create_route(origin, path, None); + let _ = request_broadcast(origin, path); + + assert_eq!(moq_route_free(route), 0); + assert!(request_once(origin, path) < 0, "a freed route is unroutable"); + assert!(moq_route_announce(route) < 0, "a freed route is released"); + let track = b"data"; + assert!(unsafe { moq_publish_track(broadcast, track.as_ptr().cast(), track.len(), std::ptr::null()) } > 0); + assert_eq!(moq_publish_close(broadcast), 0); + assert_eq!(moq_origin_close(origin), 0); +} + +/// A route outliving its closed broadcast cannot announce, re-price, or withdraw the route that /// replaced it at the same path. #[test] -fn a_stale_publication_leaves_its_replacement_alone() { +fn a_closed_route_leaves_its_replacement_alone() { let origin = id(moq_origin_create()); let path = b"replaced"; - let (stale, broadcast) = create_broadcast(origin, path); - assert_eq!(unsafe { moq_publication_announce(stale, std::ptr::null()) }, 0); + let (stale, broadcast) = create_route(origin, path, None); assert_eq!(moq_publish_close(broadcast), 0); - let (publication, replacement) = create_broadcast(origin, path); - assert_eq!(unsafe { moq_publication_announce(publication, std::ptr::null()) }, 0); - assert!(unsafe { moq_publication_announce(stale, std::ptr::null()) } < 0); - assert!(moq_publication_unannounce(stale) < 0); + let (route, replacement) = create_route(origin, path, None); + assert!(moq_route_announce(stale) < 0); + assert!(moq_route_set_cost(stale, 1) < 0); + assert_eq!(moq_route_withdraw(stale), 0); let _ = request_broadcast(origin, path); - assert_eq!(moq_publication_free(stale), 0); - assert_eq!(moq_publication_free(publication), 0); + assert_eq!(moq_route_free(stale), 0); + assert_eq!(moq_route_free(route), 0); assert_eq!(moq_publish_close(replacement), 0); assert_eq!(moq_origin_close(origin), 0); } #[test] -fn create_broadcast_is_unroutable_until_announced() { +fn a_hidden_route_is_unroutable_until_announced() { let origin = id(moq_origin_create()); let cb = Callback::new(); let announced_task = id(unsafe { moq_origin_announced(origin, std::ptr::null(), Some(channel_callback), cb.ptr) }); let path = b"quiet"; - let (publication, broadcast) = create_broadcast(origin, path); + let (route, broadcast) = create_route(origin, path, Some(&hidden())); // Nobody reaches it, locally included, until it announces. - assert!(request_once(origin, path) < 0, "an unannounced broadcast is unroutable"); + assert!(request_once(origin, path) < 0, "a hidden route is unroutable"); - assert_eq!(unsafe { moq_publication_announce(publication, std::ptr::null()) }, 0); - assert_eq!(moq_publication_free(publication), 0); + assert_eq!(moq_route_announce(route), 0); let _ = request_broadcast(origin, path); let (announced_id, info) = cb.recv_route(); assert_eq!(info.kind, moq_announce_kind::MOQ_ANNOUNCE_KIND_START); @@ -3653,6 +3684,7 @@ fn create_broadcast_is_unroutable_until_announced() { assert_eq!(moq_origin_announced_cancel(announced_task), 0); assert_eq!(cb.recv_terminal(), 0); + assert_eq!(moq_route_free(route), 0); assert_eq!(moq_publish_close(broadcast), 0); assert_eq!(moq_origin_close(origin), 0); } @@ -3660,15 +3692,14 @@ fn create_broadcast_is_unroutable_until_announced() { /// A locally announced route carries its cost and instance, and no hops: the hop chain is /// the origin's to build. #[test] -fn announce_route_carries_cost_and_instance_without_hops() { +fn route_options_carry_cost_and_instance_without_hops() { let origin = id(moq_origin_create()); let cb = Callback::new(); let announced_task = id(unsafe { moq_origin_announced(origin, std::ptr::null(), Some(channel_callback), cb.ptr) }); - let (publication, broadcast) = create_broadcast(origin, b"routed"); let instance = fresh_instance(); - let route = announce_route(7, &instance); - assert_eq!(unsafe { moq_publication_announce(publication, &route) }, 0); + let (route, broadcast) = create_route(origin, b"routed", Some(&route_options(7, &instance, false))); + assert_eq!(instance_of(route), instance); let (announced, info) = cb.recv_route(); assert_eq!(info.kind, moq_announce_kind::MOQ_ANNOUNCE_KIND_START); @@ -3677,53 +3708,50 @@ fn announce_route_carries_cost_and_instance_without_hops() { assert_eq!(route_instance(&info.route).as_ref(), Some(&instance)); assert_eq!(moq_origin_announced_free(announced), 0); - // A zeroed route is the default: cost 0 and the instance the publication minted. - let zeroed = moq_announce_route { - cost: 0, - instance: std::ptr::null(), - instance_len: 0, - epoch: 0, - }; - let (publication2, broadcast2) = create_broadcast(origin, b"plain"); - assert_eq!(unsafe { moq_publication_announce(publication2, &zeroed) }, 0); + // Re-pricing changes the route in place, under the same instance. + assert_eq!(moq_route_set_cost(route, 3), 0); + let (announced, info) = cb.recv_route(); + assert_eq!(info.kind, moq_announce_kind::MOQ_ANNOUNCE_KIND_UPDATE); + assert_eq!(info.route.cost, 3); + assert_eq!(route_instance(&info.route).as_ref(), Some(&instance)); + assert_eq!(moq_origin_announced_free(announced), 0); + + // Zeroed options are the default: visible at once, cost 0, under a freshly minted instance. + let zeroed = route_options(0, "", false); + let (plain, broadcast2) = create_route(origin, b"plain", Some(&zeroed)); let (announced, info) = cb.recv_route(); assert_eq!(info.route.cost, 0); - assert!(route_instance(&info.route).is_some_and(|minted| minted != instance)); + let minted = route_instance(&info.route).unwrap(); + assert_ne!(minted, instance); + assert_eq!(minted, instance_of(plain)); assert_eq!(moq_origin_announced_free(announced), 0); assert_eq!(moq_origin_announced_cancel(announced_task), 0); assert_eq!(cb.recv_announce_terminal(), 0); - assert_eq!(moq_publication_free(publication), 0); - assert_eq!(moq_publication_free(publication2), 0); + assert_eq!(moq_route_free(route), 0); + assert_eq!(moq_route_free(plain), 0); assert_eq!(moq_publish_close(broadcast), 0); assert_eq!(moq_publish_close(broadcast2), 0); assert_eq!(moq_origin_close(origin), 0); } -/// Announcing under another instance is another stream: subscribers see a restart rather -/// than a stalled broadcast. +/// Another route at a path is another stream: subscribers see a restart rather than a stalled +/// broadcast. #[test] -fn announce_under_a_new_instance_restarts() { +fn a_new_route_at_a_path_restarts() { let origin = id(moq_origin_create()); let cb = Callback::new(); let announced_task = id(unsafe { moq_origin_announced(origin, std::ptr::null(), Some(channel_callback), cb.ptr) }); - let (publication, broadcast) = create_broadcast(origin, b"restarted"); let first = fresh_instance(); - assert_eq!( - unsafe { moq_publication_announce(publication, &announce_route(0, &first)) }, - 0 - ); + let (first_route, first_broadcast) = create_route(origin, b"restarted", Some(&route_options(0, &first, false))); let (announced, info) = cb.recv_route(); assert_eq!(info.kind, moq_announce_kind::MOQ_ANNOUNCE_KIND_START); assert_eq!(route_instance(&info.route), Some(first)); assert_eq!(moq_origin_announced_free(announced), 0); let second = fresh_instance(); - assert_eq!( - unsafe { moq_publication_announce(publication, &announce_route(0, &second)) }, - 0 - ); + let (second_route, second_broadcast) = create_route(origin, b"restarted", Some(&route_options(0, &second, false))); let (announced, info) = cb.recv_route(); assert_eq!(info.kind, moq_announce_kind::MOQ_ANNOUNCE_KIND_RESTART); assert_eq!(route_instance(&info.route), Some(second)); @@ -3731,25 +3759,33 @@ fn announce_under_a_new_instance_restarts() { assert_eq!(moq_origin_announced_cancel(announced_task), 0); assert_eq!(cb.recv_announce_terminal(), 0); - assert_eq!(moq_publication_free(publication), 0); - assert_eq!(moq_publish_close(broadcast), 0); + assert_eq!(moq_route_free(first_route), 0); + assert_eq!(moq_route_free(second_route), 0); + assert_eq!(moq_publish_close(first_broadcast), 0); + assert_eq!(moq_publish_close(second_broadcast), 0); assert_eq!(moq_origin_close(origin), 0); } -#[test] -fn dynamic_serves_a_request_under_a_prefix() { - let origin = id(moq_origin_create()); - let cb = Callback::new(); - let prefix = b"live"; - let dynamic = id(unsafe { - moq_origin_requests( +/// Create a prefix route over `prefix` delivering its requests through `cb`. +fn route_prefix(origin: u32, prefix: &[u8], cb: &Callback) -> u32 { + id(unsafe { + moq_origin_route_prefix( origin, prefix.as_ptr() as *const c_char, prefix.len(), + std::ptr::null(), Some(channel_callback), cb.ptr, ) - }); + }) +} + +#[test] +fn dynamic_serves_a_request_under_a_prefix() { + let origin = id(moq_origin_create()); + let cb = Callback::new(); + let dynamic = route_prefix(origin, b"live", &cb); + assert!(moq_route_broadcast(dynamic) < 0, "a prefix route owns no broadcast"); let path = b"live/cam"; let req_cb = Callback::new(); @@ -3774,17 +3810,35 @@ fn dynamic_serves_a_request_under_a_prefix() { let got = unsafe { std::str::from_utf8(std::slice::from_raw_parts(info.data.cast::(), info.len)).unwrap() }; assert_eq!(got, "live/cam"); - let mut served = 0; - let prepared = id(unsafe { moq_broadcast_request_prepare(request, &mut served) }); - let publication = id(moq_broadcast_prepared_publish(prepared)); + // Unreadable options leave the request to answer. + let invalid = [0xff]; + let unreadable = moq_route_options { + instance: invalid.as_ptr().cast(), + instance_len: invalid.len(), + ..hidden() + }; + assert_eq!( + unsafe { moq_broadcast_request_route(request, &unreadable) }, + crate::error::MOQ_ERROR_UTF8 + ); + + // A hidden job route answers nobody until it announces, under its own fresh instance. + let job = id(unsafe { moq_broadcast_request_route(request, &hidden()) }); + assert!( + unsafe { moq_broadcast_request_route(request, std::ptr::null()) } < 0, + "request is consumed" + ); + assert_ne!(instance_of(job), instance_of(dynamic)); + let served = id(moq_route_broadcast(job)); + assert_eq!(moq_route_announce(job), 0); assert!(req_cb.recv() > 0); req_cb.recv_terminal(); - // The answer's route is the publication's to withdraw. - assert_eq!(moq_publication_unannounce(publication), 0); - assert_eq!(moq_publication_free(publication), 0); + // The answer's route is the job's to withdraw. + assert_eq!(moq_route_withdraw(job), 0); + assert_eq!(moq_route_free(job), 0); - assert_eq!(moq_origin_requests_cancel(dynamic), 0); - assert!(moq_origin_requests_cancel(dynamic) < 0, "double-cancel should fail"); + assert_eq!(moq_route_free(dynamic), 0); + assert!(moq_route_free(dynamic) < 0, "double-free should fail"); assert_eq!(cb.recv_terminal(), 0); assert_eq!(moq_publish_close(served), 0); assert_eq!(moq_origin_close(origin), 0); @@ -3796,8 +3850,7 @@ fn dynamic_serves_a_held_consumer_without_taking_its_handle() { let broadcast = publish_broadcast(origin, b"source"); let held = consume_local(broadcast); let cb = Callback::new(); - let dynamic = - id(unsafe { moq_origin_requests(origin, b"live".as_ptr().cast(), 4, Some(channel_callback), cb.ptr) }); + let dynamic = route_prefix(origin, b"live", &cb); let result = Callback::new(); let _task = id(unsafe { moq_origin_request( @@ -3817,7 +3870,7 @@ fn dynamic_serves_a_held_consumer_without_taking_its_handle() { assert_eq!(moq_consume_close(held), 0, "source handle remains caller-owned"); result.recv_terminal(); assert_eq!(moq_consume_close(served), 0); - assert_eq!(moq_origin_requests_cancel(dynamic), 0); + assert_eq!(moq_route_free(dynamic), 0); cb.recv_terminal(); assert_eq!(moq_publish_close(broadcast), 0); assert_eq!(moq_origin_close(origin), 0); @@ -3828,10 +3881,11 @@ fn dynamic_refuses_a_missing_callback() { let origin = id(moq_origin_create()); let prefix = b"live"; let code = unsafe { - moq_origin_requests( + moq_origin_route_prefix( origin, prefix.as_ptr() as *const c_char, prefix.len(), + std::ptr::null(), None, std::ptr::null_mut(), ) @@ -4831,16 +4885,16 @@ fn follow_close_cancels() { assert_eq!(moq_origin_close(origin), 0); } -/// Publish `path` on `origin` through `route` from Rust, keeping the Rust publication. -fn publish(origin: u32, path: &str, route: moq_net::origin::Route) -> moq_net::origin::Publication { +/// Route `path` on `origin` with `options` from Rust, keeping the Rust route. +fn publish(origin: u32, path: &str, options: moq_net::origin::RouteOptions) -> moq_net::origin::Route { let _runtime = crate::ffi::RUNTIME.enter(); let origin = crate::Id::try_from(origin).unwrap(); - State::lock().origin.get(origin).unwrap().publish(path, route).unwrap() + State::lock().origin.get(origin).unwrap().route(path, options).unwrap() } -/// Publish `path` on `origin` under a fresh instance, as each run of a publisher does. -fn publish_run(origin: u32, path: &str) -> moq_net::origin::Publication { - publish(origin, path, moq_net::origin::Route::default()) +/// Route `path` on `origin` under a fresh instance, as each run of a publisher does. +fn publish_run(origin: u32, path: &str) -> moq_net::origin::Route { + publish(origin, path, moq_net::origin::RouteOptions::default()) } /// Another publisher instance taking the path delivers a fresh handle on the same wait. @@ -4884,7 +4938,12 @@ fn follow_delivers_a_takeover_once(dynamic_at: &str) { let dynamic = { let _runtime = crate::ffi::RUNTIME.enter(); let origin = crate::Id::try_from(origin).unwrap(); - State::lock().origin.get(origin).unwrap().requests(dynamic_at).unwrap() + State::lock() + .origin + .get(origin) + .unwrap() + .route_prefix(dynamic_at, moq_net::origin::RouteOptions::default()) + .unwrap() }; let cb = Callback::new(); let path = b"live"; @@ -4901,8 +4960,8 @@ fn follow_delivers_a_takeover_once(dynamic_at: &str) { }); // The wait is on the dynamic route's answer when the exact path takes over under another instance. - let _unanswered = crate::ffi::RUNTIME.block_on(dynamic.requested_broadcast()).unwrap(); - let takeover = publish(origin, "live", moq_net::origin::Route::default()); + let _unanswered = crate::ffi::RUNTIME.block_on(dynamic.requested()).unwrap(); + let takeover = publish_run(origin, "live"); let delivered = id(cb.recv()); assert!( cb.rx @@ -4964,7 +5023,7 @@ fn an_instance_pins_request_and_follow() { let first = publish( origin, "live", - moq_net::origin::Route::default().with_instance(instance.clone(), 0), + moq_net::origin::RouteOptions::default().with_instance(instance.clone(), 0), ); let instance = instance.to_string(); @@ -4998,10 +5057,15 @@ fn an_instance_pins_request_and_follow() { } /// Serve `prefix` on `origin` dynamically. -fn serve_dynamic(origin: u32, prefix: &str) -> moq_net::origin::Requests { +fn serve_dynamic(origin: u32, prefix: &str) -> moq_net::origin::Route { let _runtime = crate::ffi::RUNTIME.enter(); let origin = crate::Id::try_from(origin).unwrap(); - State::lock().origin.get(origin).unwrap().requests(prefix).unwrap() + State::lock() + .origin + .get(origin) + .unwrap() + .route_prefix(prefix, moq_net::origin::RouteOptions::default()) + .unwrap() } /// Wait for the broadcast at `path` on `origin`, delivering each instance through `cb`. @@ -5063,16 +5127,16 @@ fn follow_delivers_the_instance_again_after_an_end() { }); let recv = || rx.recv_timeout(TIMEOUT).expect("callback timed out"); - let route = moq_net::origin::Route::default().with_instance(moq_net::Instance::random(), 0); - let run = publish(origin, "live", route.clone()); + let options = moq_net::origin::RouteOptions::default().with_instance(moq_net::Instance::random(), 0); + let run = publish(origin, "live", options); let first = id(recv()); // Hold the wait inside that delivery so both changes are on hand when it next looks: the // same stream announcing again after its route left is still a gap. { let _runtime = crate::ffi::RUNTIME.enter(); - run.unannounce(); - run.announce(route.clone()).unwrap(); + run.withdraw(); + run.announce().unwrap(); } release.send(()).unwrap(); let again = id(recv()); @@ -5095,7 +5159,7 @@ fn follow_waits_for_another_instance_after_a_freed_takeover() { let cb = Callback::new(); let task = follow(origin, b"live", &cb); - let _unanswered = crate::ffi::RUNTIME.block_on(dynamic.requested_broadcast()).unwrap(); + let _unanswered = crate::ffi::RUNTIME.block_on(dynamic.requested()).unwrap(); let takeover = publish_run(origin, "live"); assert_eq!(moq_consume_close(id(cb.recv())), 0); assert!( @@ -5123,7 +5187,7 @@ fn follow_delivers_a_gap_while_resolving_once() { let cb = Callback::new(); let task = follow(origin, b"live", &cb); - let _unanswered = crate::ffi::RUNTIME.block_on(dynamic.requested_broadcast()).unwrap(); + let _unanswered = crate::ffi::RUNTIME.block_on(dynamic.requested()).unwrap(); { let _runtime = crate::ffi::RUNTIME.enter(); drop(dynamic); @@ -5133,7 +5197,7 @@ fn follow_delivers_a_gap_while_resolving_once() { reason = "the test thread has no runtime; it waits out the hold on the C API's real runtime" )] std::thread::sleep(moq_net::origin::Config::default().update_hold * 2); - let arrival = publish(origin, "live", moq_net::origin::Route::default()); + let arrival = publish_run(origin, "live"); let delivered = id(cb.recv()); assert!( cb.rx @@ -7304,14 +7368,7 @@ fn announce_route_hops_cross_a_relay_session() { let announced_cb = Callback::new(); let task = id(unsafe { moq_origin_announced(sink, std::ptr::null(), Some(channel_callback), announced_cb.ptr) }); - let (publication, broadcast) = create_broadcast(source, b"relayed"); - let route = moq_announce_route { - cost: 7, - instance: std::ptr::null(), - instance_len: 0, - epoch: 0, - }; - assert_eq!(unsafe { moq_publication_announce(publication, &route) }, 0); + let (route, broadcast) = create_route(source, b"relayed", Some(&route_options(7, "", false))); let (announced, info) = announced_cb.recv_route(); assert_eq!(info.kind, moq_announce_kind::MOQ_ANNOUNCE_KIND_START); assert_eq!( @@ -7340,7 +7397,7 @@ fn announce_route_hops_cross_a_relay_session() { } assert_eq!(moq_server_close(server), 0); assert_eq!(server_cb.recv_terminal(), 0); - assert_eq!(moq_publication_free(publication), 0); + assert_eq!(moq_route_free(route), 0); assert_eq!(moq_publish_close(broadcast), 0); for origin in [source, relay, sink] { assert_eq!(moq_origin_close(origin), 0); diff --git a/rs/moq-cli/src/announced.rs b/rs/moq-cli/src/announced.rs index ce87d393d42..c29d51c36d4 100644 --- a/rs/moq-cli/src/announced.rs +++ b/rs/moq-cli/src/announced.rs @@ -187,7 +187,7 @@ mod tests { /// Stops the relay, which ends every session on it. shutdown: moq_relay::shutdown::Trigger, /// The published broadcasts by path; dropping one retracts it. - broadcasts: Vec<(&'static str, moq_net::origin::Publication)>, + broadcasts: Vec<(&'static str, moq_net::origin::Route)>, _publisher: moq_tokio::Connection, } @@ -212,8 +212,9 @@ mod tests { let broadcasts = ["demo/a", "demo/b", "other/c"] .into_iter() .map(|path| { - let broadcast = origin.create_broadcast(path).expect("broadcast"); - broadcast.announce(Default::default()).expect("announce"); + let broadcast = origin + .route(path, moq_net::origin::RouteOptions::default()) + .expect("broadcast"); (path, broadcast) }) .collect::>(); diff --git a/rs/moq-cli/src/archive.rs b/rs/moq-cli/src/archive.rs index 3d42ec99e6f..0260a38bcae 100644 --- a/rs/moq-cli/src/archive.rs +++ b/rs/moq-cli/src/archive.rs @@ -88,9 +88,7 @@ pub async fn export(origin: moq_net::origin::Consumer, prefix: String, args: Exp if !announce.prefix.has_prefix(&prefix) { continue; } - let Some(instance) = announce.route.instance else { - continue; - }; + let instance = announce.route.instance().clone(); let instance: Instance = (announce.prefix, instance); if !running.start(&instance) { continue; @@ -250,13 +248,17 @@ pub async fn import( if let Some(refresh) = args.refresh { config = config.with_refresh(refresh.into()); } - let broadcast = origin.create_broadcast(&name).context("failed to create broadcast")?; - let consumer = moq_archive::Consumer::open(store, broadcast.broadcast().clone(), config) + // Hidden until the recording opens, then held while the replay runs. + let route = origin + .route( + &name, + moq_net::origin::RouteOptions::hidden().with_instance(instance, 0), + ) + .context("failed to create broadcast")?; + let consumer = moq_archive::Consumer::open(store, route.broadcast().clone(), config) .await .with_context(|| format!("no readable recording at {}", args.store))?; - broadcast - .announce(moq_net::origin::Route::default().with_instance(instance, 0)) - .context("failed to announce broadcast")?; + route.announce().context("failed to announce broadcast")?; tracing::info!(%name, store = %args.store, "replaying"); notify_ready(); @@ -354,16 +356,13 @@ mod tests { let mut instances = Vec::new(); let mut broadcasts = Vec::new(); for path in ["live/a", "live/b", "other"] { - let broadcast = origin.create_broadcast(path).unwrap(); - let track = broadcast.create_track("video", info.clone()).unwrap(); + let broadcast = origin.route(path, moq_net::origin::RouteOptions::hidden()).unwrap(); + let track = broadcast.broadcast().create_track("video", info.clone()).unwrap(); let mut group = track.create_group(group::Info { sequence: 0 }).unwrap(); group.write_frame(Timestamp::from_millis(0).unwrap(), path).unwrap(); group.finish().unwrap(); - let instance = moq_net::Instance::random(); - broadcast - .announce(moq_net::origin::Route::default().with_instance(instance.clone(), 0)) - .unwrap(); - instances.push(instance); + broadcast.announce().unwrap(); + instances.push(broadcast.instance()); broadcasts.push((broadcast, track)); } @@ -374,7 +373,7 @@ mod tests { .expect("the export subscribes") .unwrap(); track.finish().unwrap(); - broadcast.close(); + broadcast.broadcast().close(); } let complete = [ format!("live/a/@{}/.end", instances[0]), @@ -446,7 +445,7 @@ mod tests { loop { if let Some(moq_net::announce::Event::Start(announce)) = announced.next().await { assert_eq!(announce.prefix.as_str(), "replay"); - assert_eq!(announce.route.instance, Some(instance.clone())); + assert_eq!(announce.route.instance(), &instance); break; } } @@ -479,16 +478,18 @@ mod tests { async fn a_resolved_broadcast_is_recorded_once() { let origin = moq_tokio::origin::spawn(); let path = moq_net::Path::from_static("live/a"); - let newest = origin.create_broadcast(&path).unwrap(); - let older = origin.create_broadcast(&path).unwrap(); + let newest = origin.route(&path, moq_net::origin::RouteOptions::hidden()).unwrap(); + let older = origin.route(&path, moq_net::origin::RouteOptions::hidden()).unwrap(); let claims = Claims::default(); - let claim = claims.claim(&path, &newest.consume()).expect("first claim"); - assert!(claims.claim(&path, &newest.consume()).is_none()); - let beside = claims.claim(&path, &older.consume()).expect("another instance"); + let claim = claims.claim(&path, &newest.broadcast().consume()).expect("first claim"); + assert!(claims.claim(&path, &newest.broadcast().consume()).is_none()); + let beside = claims + .claim(&path, &older.broadcast().consume()) + .expect("another instance"); drop(claim); - assert!(claims.claim(&path, &newest.consume()).is_some()); + assert!(claims.claim(&path, &newest.broadcast().consume()).is_some()); drop(beside); assert!(claims.0.lock().unwrap().is_empty()); } diff --git a/rs/moq-cli/src/complete.rs b/rs/moq-cli/src/complete.rs index 10e001be985..7d745d273b7 100644 --- a/rs/moq-cli/src/complete.rs +++ b/rs/moq-cli/src/complete.rs @@ -428,8 +428,7 @@ mod tests { let _ = moq_tokio::crypto::install_default(); let origin = moq_tokio::origin::spawn(); - let _alpha = origin.create_broadcast("alpha").expect("alpha"); - _alpha.announce(Default::default()).expect("alpha"); + let _alpha = origin.route("alpha", Default::default()).expect("alpha"); let mut config = moq_tokio::listen::Config::default(); config.bind = Some("127.0.0.1:0".parse().unwrap()); diff --git a/rs/moq-cli/src/fetch.rs b/rs/moq-cli/src/fetch.rs index 4c8b8398b8d..e7e1bd4d4e4 100644 --- a/rs/moq-cli/src/fetch.rs +++ b/rs/moq-cli/src/fetch.rs @@ -183,7 +183,7 @@ mod tests { struct Fixture { origin: moq_net::origin::Producer, _keep: ( - moq_net::origin::Publication, + moq_net::origin::Route, Vec, moq_net::group::Producer, ), @@ -192,10 +192,11 @@ mod tests { impl Fixture { async fn new() -> Self { let origin = moq_tokio::origin::spawn(); - let broadcast = origin.create_broadcast("demo").expect("broadcast"); - broadcast.announce(Default::default()).expect("announce"); + let broadcast = origin + .route("demo", moq_net::origin::RouteOptions::default()) + .expect("broadcast"); - let data = broadcast.create_track("data", timed()).expect("data track"); + let data = broadcast.broadcast().create_track("data", timed()).expect("data track"); for sequence in 0..3 { let mut group = data.append_group().expect("group"); for frame in frames(sequence) { @@ -203,8 +204,11 @@ mod tests { } group.finish().expect("finish"); } - let empty = broadcast.create_track("empty", timed()).expect("empty track"); - let live = broadcast.create_track("live", timed()).expect("live track"); + let empty = broadcast + .broadcast() + .create_track("empty", timed()) + .expect("empty track"); + let live = broadcast.broadcast().create_track("live", timed()).expect("live track"); let mut open = live.append_group().expect("open group"); open.write_frame(moq_net::Timestamp::ZERO, b"first".as_ref()) .expect("frame"); @@ -241,7 +245,7 @@ mod tests { /// Kept so the published broadcast, its tracks, and the open group stay live. _publisher: (moq_tokio::Connection, Fixture), /// Kept so the relay's hidden broadcast and its track stay live. - _hidden: (moq_net::origin::Publication, moq_net::track::Producer), + _hidden: (moq_net::origin::Route, moq_net::track::Producer), } impl NetworkFixture { @@ -255,10 +259,9 @@ mod tests { .relay .cluster() .origin - .create_broadcast(".hidden") + .route(".hidden", moq_net::origin::RouteOptions::default()) .expect("hidden broadcast"); - hidden.announce(Default::default()).expect("announce hidden"); - let secret = hidden.create_track("data", timed()).expect("hidden track"); + let secret = hidden.broadcast().create_track("data", timed()).expect("hidden track"); let mut group = secret.append_group().expect("group"); group .write_frame(moq_net::Timestamp::ZERO, b"secret".as_ref()) diff --git a/rs/moq-cli/src/hls.rs b/rs/moq-cli/src/hls.rs index e8e212eb1a6..7cbcfaf0b8d 100644 --- a/rs/moq-cli/src/hls.rs +++ b/rs/moq-cli/src/hls.rs @@ -170,12 +170,18 @@ pub async fn import(target: ImportTarget, args: ImportArgs, instance: moq_net::I linger, bandwidth, } = target; - let producer = origin.create_broadcast(&name).context("failed to create broadcast")?; + // Held through the linger, so the finished broadcast stays announced while it serves the tail. + let route = origin + .route( + &name, + moq_net::origin::RouteOptions::hidden().with_instance(instance, 0), + ) + .context("failed to create broadcast")?; let config = moq_mux::catalog::Config::default() .with_max_age(max_age) .with_bandwidth(bandwidth); - let catalog = moq_mux::catalog::Producer::new(&mut producer.broadcast().clone(), config)?; + let catalog = moq_mux::catalog::Producer::new(&mut route.broadcast().clone(), config)?; // Announced once the catalog first goes out, which waits for every rendition's init: a // relay queries a broadcast's tracks the moment it is announced, and keeps the refusals of a // publisher that cannot serve its declared tracks yet. @@ -183,14 +189,14 @@ pub async fn import(target: ImportTarget, args: ImportArgs, instance: moq_net::I let mut config = moq_hls::import::Config::new(playlist_url(&args.playlist)?); config.passthrough = args.passthrough; - let mut importer = moq_hls::import::Import::new(producer.broadcast().clone(), catalog, config)?; + let mut importer = moq_hls::import::Import::new(route.broadcast().clone(), catalog, config)?; tracing::info!(%name, "importing HLS"); let ran = match importer.init().await { Ok(()) => { notify_ready(); - run_announced(&mut importer, &mut listed, &producer, instance).await + run_announced(&mut importer, &mut listed, &route).await } Err(err) => Err(err.into()), }; @@ -204,7 +210,7 @@ pub async fn import(target: ImportTarget, args: ImportArgs, instance: moq_net::I // arrives after the end still gets the tail. An interrupt drops it at once. importer.finish()?; tracing::info!(?linger, "playlist ended; serving the finished broadcast"); - moq_mux::Linger::new([producer.broadcast().clone()], importer, linger) + moq_mux::Linger::new([route.broadcast().clone()], importer, linger) .wait() .await; Ok(()) @@ -216,8 +222,7 @@ pub async fn import(target: ImportTarget, args: ImportArgs, instance: moq_net::I async fn run_announced( importer: &mut moq_hls::import::Import, listed: &mut moq_mux::catalog::hang::Consumer, - publication: &moq_net::origin::Publication, - instance: moq_net::Instance, + route: &moq_net::origin::Route, ) -> anyhow::Result<()> { let run = importer.run(); tokio::pin!(run); @@ -233,9 +238,7 @@ async fn run_announced( } }; anyhow::ensure!(catalog.is_some(), "the playlist ended before it declared a track"); - publication - .announce(moq_net::origin::Route::default().with_instance(instance, 0)) - .context("failed to announce broadcast")?; + route.announce().context("failed to announce broadcast")?; if !ended { run.await?; } @@ -389,7 +392,7 @@ mod test { tempfile::TempDir, moq_hls::import::Import, moq_mux::catalog::hang::Consumer, - moq_net::origin::Publication, + moq_net::origin::Route, )> { let dir = tempfile::tempdir()?; write_playlist(dir.path(), segments, false); @@ -397,7 +400,7 @@ mod test { let (origin, driver) = moq_net::origin::Producer::new(moq_net::origin::Config::default()); tokio::spawn(moq_net::time::run(driver)); - let producer = origin.create_broadcast("hls")?; + let producer = origin.route("hls", moq_net::origin::RouteOptions::hidden())?; let catalog = moq_mux::catalog::Producer::new(&mut producer.broadcast().clone(), moq_mux::catalog::Config::default())?; let listed = catalog.consume()?; @@ -419,10 +422,8 @@ mod test { async fn an_ended_playlist_announces_its_catalog() { for _ in 0..32 { let (_dir, mut importer, mut listed, producer) = joined_then_ended(1).await.unwrap(); - run_announced(&mut importer, &mut listed, &producer, moq_net::Instance::random()) - .await - .unwrap(); - assert!(producer.route().is_some(), "the finished playlist was not announced"); + run_announced(&mut importer, &mut listed, &producer).await.unwrap(); + assert!(producer.is_announced(), "the finished playlist was not announced"); } } @@ -440,8 +441,8 @@ mod test { #[tokio::test] async fn an_empty_playlist_fails_unannounced() { let (_dir, mut importer, mut listed, producer) = joined_then_ended(0).await.unwrap(); - let result = run_announced(&mut importer, &mut listed, &producer, moq_net::Instance::random()).await; - assert!(producer.route().is_none(), "an empty playlist was announced"); + let result = run_announced(&mut importer, &mut listed, &producer).await; + assert!(!producer.is_announced(), "an empty playlist was announced"); let err = result.expect_err("an empty playlist imports nothing"); assert!(format!("{err:#}").contains("before it declared a track"), "{err:#}"); } diff --git a/rs/moq-cli/src/hls/record.rs b/rs/moq-cli/src/hls/record.rs index 90e849fae89..0bcf697e158 100644 --- a/rs/moq-cli/src/hls/record.rs +++ b/rs/moq-cli/src/hls/record.rs @@ -604,7 +604,7 @@ mod tests { /// A broadcast publishing VP8 renditions with aligned two-second GOPs. struct Publisher { origin: moq_net::origin::Producer, - broadcast: moq_net::origin::Publication, + broadcast: moq_net::origin::Route, catalog: moq_mux::catalog::Producer, video: Vec