diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 7d8a52fb5a6..a4016746bd0 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -2659,19 +2659,16 @@ where // SUBSCRIBEs: its TRACK_STATUS answer cannot say whether the track is timed. let mut target = match request.subscription() { None if ietf::TrackStatusOk::describes_track(self.version) => { - match self.track_status(&broadcast_path, &track_name, request).await { - Some(Target::Resume(idle)) => { - let Some(next) = self - .linger(&broadcast_path, &track_name, idle, &mut group_fetches, &mut gate) - .await - else { - return; - }; - Target::Resume(next) - } - Some(target) => target, - None => return, - } + let Some(idle) = self.track_status(&broadcast_path, &track_name, request).await else { + return; + }; + let Some(next) = self + .linger(&broadcast_path, &track_name, idle, &mut group_fetches, &mut gate) + .await + else { + return; + }; + Target::Resume(next) } _ => Target::Request(request), }; @@ -3750,18 +3747,15 @@ where } } - /// Learn a track nobody subscribes to from TRACK_STATUS, and accept it as a copy with no - /// subscription ([`Target::Resume`]), which [`Self::linger`] serves fetches from and - /// subscribes once someone does. A publisher that does not implement TRACK_STATUS hands - /// the request back ([`Target::Request`]) to be learned from SUBSCRIBE. `None` once the - /// request was refused or abandoned: a publisher that refuses the track's status refuses - /// the fetch-only request too. + /// Learn a track nobody subscribes to from TRACK_STATUS, accepting an idle copy that + /// [`Self::linger`] serves fetches from and subscribes once someone does. `None` once + /// refused or abandoned: a refused status fails the query-only or fetch-only request. async fn track_status( &mut self, broadcast_path: &Path<'_>, track_name: &str, request: track::Request, - ) -> Option { + ) -> Option { let validity = self.validity.start(); // An allocated ID is always sent, as in `subscribe_once`. let request_id = match validity.run(self.control.next_request_id(&self.runtime)).await { @@ -3842,12 +3836,6 @@ where }; let ok = match ok { Ok(ok) => ok, - // NOT_SUPPORTED refuses the method, not the track. The origin queries a track before - // its first reader's subscription lands, so this is often a subscriber's request. - Err(Error::Unsupported) => { - tracing::debug!(broadcast = %self.origin.absolute(broadcast_path), track = %track_name, "track status not supported, subscribing"); - return Some(Target::Request(request)); - } Err(err) => { tracing::debug!(%err, broadcast = %self.origin.absolute(broadcast_path), track = %track_name, "track status refused"); request.reject(err); @@ -3861,12 +3849,12 @@ where track.received(); // Nothing feeds this copy live: what it caches is fetched, never the live edge. track.set_idle(); - Some(Target::Resume(Idle { + Some(Idle { demand: track.demand(), track, dynamic, timescale: ok.properties.timescale, - })) + }) } /// Read the answer to a TRACK_STATUS: TRACK_STATUS_OK, or the publisher's refusal as an @@ -7410,73 +7398,198 @@ mod tests { buf } - /// A publisher without TRACK_STATUS still serves the track: its NOT_SUPPORTED refuses - /// the method, so the request is learned from SUBSCRIBE instead. The origin queries a new - /// track before its first reader's subscription lands, so a reader reaching such a - /// publisher through a relay takes this path. + /// Serve the front's request on its wake, before the requesting call can return. + /// A peer that refuses TRACK_STATUS must still receive SUBSCRIBE for a catalog reader. #[moq_clock::test] - async fn an_unsupported_track_status_subscribes_instead() { - for version in [Version::Draft18, Version::Draft19, Version::Draft22] { - let refused = message( - ietf::RequestError::ID, - &ietf::RequestError { - request_id: None, - error_code: request::to_code(&Error::Unsupported, request::Kind::TrackStatus, version), - reason_phrase: "TRACK_STATUS is not supported".into(), - retry_interval: 0, - }, - version, - ); - let subscribe_ok = message( - ietf::SubscribeOk::ID, - &ietf::SubscribeOk { - request_id: None, - track_alias: 7, - largest: None, - properties: Default::default(), - }, - version, - ); - let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![refused, subscribe_ok]); - let log = session.log.clone(); - let (tasks, _task_set) = crate::util::TaskSet::new(); - let mut subscriber = Subscriber::new( - crate::time::sim(), - session, - crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), - Control::new(None, false), - None, - peer::PeerSetup::declared(peer::Peer::default()), - crate::Hop::new(1).unwrap(), - None, - version, - tasks, - Default::default(), - ); + async fn a_catalog_subscription_never_requests_track_status() { + use std::sync::{Arc, Mutex}; + use std::task::{Context, Wake, Waker}; - let producer = crate::broadcast::Info::default().produce(); - let mut dynamic = producer.dynamic(); - let consumer = producer.consume(); - let track = consumer.track("video").unwrap(); - let mut query = std::pin::pin!(track.query()); - assert!(futures::poll!(query.as_mut()).is_pending()); - let request = dynamic.requested_track().await.expect("no track requested"); + struct Peer { + version: Version, + dynamic: Mutex>, + park: Mutex, + log: Mutex>, + } + impl Wake for Peer { + fn wake(self: Arc) { + self.wake_by_ref(); + } + fn wake_by_ref(self: &Arc) { + let (dynamic, request) = { + let mut dynamic = self.dynamic.lock().unwrap(); + let Some(serving) = dynamic.as_mut() else { return }; + let mut park = self.park.lock().unwrap(); + let waker = Waker::from(self.clone()); + let waiter = park.hold(&Context::from_waker(&waker)); + let Poll::Ready(Ok(request)) = serving.poll_requested_track(waiter) else { + return; + }; + *park = kio::Park::default(); + (dynamic.take().unwrap(), request) + }; + let version = self.version; + // The subscriber chooses its wire request from this snapshot. Answer a + // TRACK_STATUS with the undefined code used by the refusing peer. + let answer = if request.subscription().is_none() { + message( + ietf::RequestError::ID, + &ietf::RequestError { + request_id: None, + error_code: u32::MAX.into(), + reason_phrase: "TRACK_STATUS is refused".into(), + retry_interval: 0, + }, + version, + ) + } else { + message( + ietf::SubscribeOk::ID, + &ietf::SubscribeOk { + request_id: None, + track_alias: 7, + largest: None, + properties: Default::default(), + }, + version, + ) + }; + let session = crate::lite::test_transport::ScriptedSession::new(answer); + *self.log.lock().unwrap() = Some(session.log.clone()); + let mut serving = Box::pin(async move { + let (tasks, _task_set) = crate::util::TaskSet::new(); + let mut subscriber = Subscriber::new( + crate::time::sim(), + session, + crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(), + Control::new(None, false), + None, + peer::PeerSetup::declared(peer::Peer::default()), + crate::Hop::new(2).unwrap(), + None, + version, + tasks, + Default::default(), + ); + subscriber + .run_subscribe(Path::new("broadcast"), dynamic, None, request) + .await; + }); + // Run the request classification before the front can add demand after + // its query. The simulator takes over only once the wire work parks. + if std::future::Future::poll(serving.as_mut(), &mut Context::from_waker(Waker::noop())).is_pending() { + drop(moq_clock::sim::spawn(serving)); + } + } + } - let serving = moq_clock::sim::spawn(async move { - subscriber - .run_subscribe(Path::new("broadcast"), dynamic, None, request) - .await; + for version in [Version::Draft18, Version::Draft19, Version::Draft22] { + let origin = crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(); + let source = origin.publish("broadcast", Default::default()).unwrap(); + let resolved = origin.consume().request_broadcast("broadcast", None).await.unwrap(); + let peer = Arc::new(Peer { + version, + dynamic: Mutex::new(Some(source.dynamic())), + park: Default::default(), + log: Default::default(), }); - settle().await; - - assert!(query.await.is_ok(), "{version}: NOT_SUPPORTED refused the track"); - assert!(track.subscribe(None).await.is_ok(), "{version}: the reader was refused"); + peer.wake_by_ref(); + let result = resolved.track("catalog").unwrap().subscribe(None).await; + let log = peer.log.lock().unwrap(); assert_eq!( - control_message_types(&log, version)[..2], - [ietf::TrackStatus::ID, ietf::Subscribe::ID], - "{version}" + control_message_types(log.as_ref().expect("the front asked its source"), version), + [ietf::Subscribe::ID], + "{version}: a subscribing reader sent TRACK_STATUS" ); - serving.abort(); + assert!(result.is_ok(), "{version}: the catalog reader was refused"); + } + } + + /// Query-only and fetch-only demand fail with the peer's TRACK_STATUS refusal, + /// including NOT_SUPPORTED and undefined codes, without opening a subscription. + #[moq_clock::test] + async fn a_refused_track_status_never_subscribes() { + for version in [ + Version::Draft14, + Version::Draft15, + Version::Draft16, + Version::Draft18, + Version::Draft19, + Version::Draft22, + ] { + for code in [3, u64::from(u32::MAX)] { + for fetching in [false, true] { + let refused = if version == Version::Draft14 { + message( + ietf::TRACK_STATUS_ERROR_14, + &ietf::SubscribeError { + request_id: RequestId(0), + error_code: code, + reason_phrase: "TRACK_STATUS is refused".into(), + }, + version, + ) + } else { + message( + ietf::RequestError::ID, + &ietf::RequestError { + request_id: matches!(version, Version::Draft15 | Version::Draft16) + .then_some(RequestId(0)), + error_code: code, + reason_phrase: "TRACK_STATUS is refused".into(), + retry_interval: 0, + }, + version, + ) + }; + let session = crate::lite::test_transport::ScriptedSession::new(refused); + let log = session.log.clone(); + let (tasks, _task_set) = crate::util::TaskSet::new(); + let mut subscriber = Subscriber::new( + crate::time::sim(), + session, + crate::origin::Config::new(crate::Hop::new(1).unwrap()).produce(), + Control::new(None, false), + None, + peer::PeerSetup::declared(peer::Peer::default()), + crate::Hop::new(1).unwrap(), + None, + version, + tasks, + Default::default(), + ); + + let producer = crate::broadcast::Info::default().produce(); + let mut dynamic = producer.dynamic(); + let consumer = producer.consume(); + let track = consumer.track("video").unwrap(); + let mut pending = Box::pin(async { + if fetching { + track.fetch_group(0, None).await.map(|_| ()) + } else { + track.query().await.map(|_| ()) + } + }); + assert!(futures::poll!(pending.as_mut()).is_pending()); + let request = dynamic.requested_track().await.expect("no track requested"); + let mut serving = + Box::pin(subscriber.run_subscribe(Path::new("broadcast"), dynamic, None, request)); + assert!( + futures::poll!(serving.as_mut()).is_ready(), + "{version}: refusal was not terminal" + ); + match pending.await.expect_err("TRACK_STATUS was refused") { + Error::Unsupported => assert_eq!(code, 3), + Error::Remote(value) => assert_eq!(u64::from(value), code), + err => panic!("{version}, fetching: {fetching}: wrong refusal: {err:?}"), + } + assert_eq!( + control_message_types(&log, version), + [ietf::TrackStatus::ID], + "{version}" + ); + } + } } } diff --git a/rs/moq-net/src/model/broadcast.rs b/rs/moq-net/src/model/broadcast.rs index 30f9591d6f5..c77c979c977 100644 --- a/rs/moq-net/src/model/broadcast.rs +++ b/rs/moq-net/src/model/broadcast.rs @@ -999,31 +999,42 @@ impl Consumer { } /// Join the demand of the track serving `name`, requesting it from a [`Dynamic`] - /// when nothing serves it yet. Errors as [`Self::track`] does. - pub(super) fn resolve_track(&self, name: &str) -> Result, Error> { - let mut state = self.state.lock(); + /// when nothing serves it yet. Registers the subscription before exposing demand. + /// Errors as [`Self::track`] does. + pub(super) fn resolve_track( + &self, + name: &str, + subscription: Option<&track::Subscription>, + ) -> Result<(kio::Consumer, Option), Error> { + let mut state = loop { + let mut state = self.state.lock(); - if state.closing { - return Err(Error::Unroutable); - } + if state.closing { + return Err(Error::Unroutable); + } - // Reuse a live producer if one is already publishing the track. `get` drops a - // closed entry and returns `None`, so we fall through to a fresh request. - if let Some(weak) = state.tracks.get(name) { - match weak.try_consume() { - Some(consumer) => return Ok(consumer), - // It closed between the liveness probe and the count bump (an idle - // teardown committing under us). Reclaim it and request the track - // again, rather than handing back a consumer of a dead track. - None => { - state.tracks.remove(name); - } + // Reuse a live producer if one is already publishing the track. `get` drops a + // closed entry and returns `None`, so we fall through to a fresh request. + let Some(weak) = state.tracks.get(name) else { + break state; + }; + // Join outside the lock: the subscription and the first consumer wake the + // serving session, which may re-enter this broadcast. The track's own lock + // still orders the join against its idle teardown. + drop(state); + if let Some(resolved) = weak.try_consume(subscription) { + return Ok(resolved); } - } + // It closed between the liveness probe and the count bump (an idle teardown + // committing under us). Look again: `get` reclaims it and the track is + // requested again, rather than handing back a consumer of a dead track. + }; if let Some(pending) = state.requests.join(name) { - // Coalesce onto a queued request for the same name. - return Ok(pending.join()); + // Coalesce onto a queued request for the same name. Joining under the lock + // wakes no subscription observer: only a handler that popped the request + // can watch its subscriptions, and popping moves it to `tracks`. + return Ok(pending.join(subscription)); } // Allocate the name once and share the same Arc across the request, the @@ -1031,7 +1042,7 @@ impl Consumer { // cache pool through its `Arc`, same as a producer-created track. let name: Arc = name.into(); let request = track::Request::new(self.info.clone(), name.clone()).with_sequence(state.sequence(&name)); - let consumer = request.join(); + let resolved = request.join(subscription); // With no handler alive to serve it, the request is dropped: `NotFound` beats // handing back a consumer that would only resolve `Dropped`. @@ -1039,7 +1050,7 @@ impl Consumer { return Err(Error::NotFound); } - Ok(consumer) + Ok(resolved) } /// Read the track serving `name` now, without joining its demand or requesting it. @@ -1246,6 +1257,105 @@ mod test { #[cfg(feature = "async")] use std::time::Duration; + #[test] + fn a_subscription_is_registered_before_its_request_is_visible() { + struct Serve { + dynamic: std::sync::Mutex, + request: std::sync::Mutex>, + subscription: std::sync::Mutex>>, + } + impl std::task::Wake for Serve { + fn wake(self: Arc) { + self.wake_by_ref(); + } + fn wake_by_ref(self: &Arc) { + let Poll::Ready(Ok(request)) = self.dynamic.lock().unwrap().poll_requested_track(&kio::Waiter::noop()) + else { + return; + }; + *self.subscription.lock().unwrap() = Some(request.subscription()); + *self.request.lock().unwrap() = Some(request); + } + } + + let producer = Info::new().produce(); + let serve = Arc::new(Serve { + dynamic: std::sync::Mutex::new(producer.dynamic()), + request: Default::default(), + subscription: Default::default(), + }); + let consumer = producer.consume().track("catalog").unwrap(); + let waiter = kio::Waiter::new(std::task::Waker::from(serve.clone())); + assert!(serve.dynamic.lock().unwrap().poll_requested_track(&waiter).is_pending()); + let expected = track::Subscription::default().with_priority(3); + let _pending = consumer.subscribe(expected.clone()); + assert_eq!(*serve.subscription.lock().unwrap(), Some(Some(expected))); + } + + #[test] + fn a_subscription_is_registered_before_its_demand_is_visible() { + struct Inspect { + track: track::Producer, + seen: std::sync::Mutex>>, + } + impl std::task::Wake for Inspect { + fn wake(self: Arc) { + self.wake_by_ref(); + } + fn wake_by_ref(self: &Arc) { + *self.seen.lock().unwrap() = Some(self.track.subscription()); + } + } + + for lookup in [false, true] { + let producer = Info::new().produce(); + let inspect = Arc::new(Inspect { + track: producer.create_track("catalog", None).unwrap(), + seen: Default::default(), + }); + let waiter = kio::Waiter::new(std::task::Waker::from(inspect.clone())); + assert_eq!(inspect.track.demand().poll_state(&waiter), track::DemandState::Idle); + let consumer = if lookup { + producer.consume().track("catalog").unwrap() + } else { + inspect.track.consume() + }; + let expected = track::Subscription::default().with_priority(3); + let _pending = consumer.subscribe(expected.clone()); + assert_eq!(*inspect.seen.lock().unwrap(), Some(Some(expected)), "lookup: {lookup}"); + } + } + + #[test] + fn a_subscription_wakes_its_observers_outside_the_broadcast_lock() { + struct Reenter { + broadcast: Consumer, + woken: std::sync::atomic::AtomicBool, + } + impl std::task::Wake for Reenter { + fn wake(self: Arc) { + self.wake_by_ref(); + } + fn wake_by_ref(self: &Arc) { + // Deadlocks if the subscribe that woke us still holds the broadcast lock. + let _ = self.broadcast.track("other"); + self.woken.store(true, std::sync::atomic::Ordering::Relaxed); + } + } + + let producer = Info::new().produce(); + let mut track = producer.create_track("catalog", None).unwrap(); + let reenter = Arc::new(Reenter { + broadcast: producer.consume(), + woken: Default::default(), + }); + let waiter = kio::Waiter::new(std::task::Waker::from(reenter.clone())); + assert!(track.poll_subscription_changed(&waiter).is_pending()); + let consumer = producer.consume().track("catalog").unwrap(); + let _pending = consumer.subscribe(track::Subscription::default().with_priority(3)); + assert!(reenter.woken.load(std::sync::atomic::Ordering::Relaxed)); + } + #[test] fn unique_names_are_never_reused() { let producer = Info::new().produce(); diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 8d46cfbb4da..a115d7eefff 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -3133,11 +3133,14 @@ async fn serve_front(task: FrontTask) -> Vec { let closing = sources.get(&source).is_some_and(|s| s.is_closing()); match sources.get(&source).map(|s| s.track(&name)) { Some(Ok(lookup)) => { - // `into_inner` sheds the `Pending` future wrapper so only - // the pollable (which is `Sync`) is held across the wait. - let query = lookup.query().into_inner(); + // Subscribe before the query exposes upstream demand, and query + // that same instance even if the broadcast changes meanwhile. + let sub = io.weak.subscription().map(|demand| lookup.subscribe(demand)); + let query = match &sub { + Some(sub) => sub.query(), + None => lookup.query().into_inner(), + }; let copy = query.track(); - let sub = io.weak.subscription().map(|demand| copy.subscribe(demand)); io.query = Some(Asked { source, copy, diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 80d93f543eb..c8858d0b38c 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -3234,8 +3234,14 @@ impl TrackWeak { /// of [`Producer::abort_unused`]: a request either joins in time to decline the /// teardown, or gets nothing and re-requests the track. It is never handed a track /// that is already on its way out. - pub(super) fn try_consume(&self) -> Option> { - self.state.try_consume() + pub(super) fn try_consume( + &self, + subscription: Option<&Subscription>, + ) -> Option<(kio::Consumer, Option)> { + // Register before the first consumer can wake the serving session, while + // still refusing a copy whose idle teardown already committed. + let preferences = subscription.map(|value| Preferences::register(self.state.read(), value.clone())); + Some((self.state.try_consume()?, preferences)) } /// Read the cached track without joining its demand. @@ -3569,20 +3575,22 @@ impl Consumer { /// The track a request made now reads, joined to its consumer count. A broadcast /// that cannot serve the name answers with a track closed with its error. - fn resolve(&self) -> kio::Consumer { - match &self.source { - Source::Track(state) => state.consume(), - Source::Broadcast(broadcast, current) => match broadcast.resolve_track(&self.name) { - Ok(state) => state, - Err(Error::Unroutable) if let Some(current) = current => current.consume(), + fn resolve(&self, subscription: Option<&Subscription>) -> (kio::Consumer, Option) { + let state = match &self.source { + Source::Track(state) => state.clone(), + Source::Broadcast(broadcast, current) => match broadcast.resolve_track(&self.name, subscription) { + Ok(resolved) => return resolved, + Err(Error::Unroutable) if let Some(current) = current => current.clone(), Err(err) => { let request = Request::new(self.broadcast.clone(), self.name.clone()); - let state = request.state.consume(); + let state = request.peek(); request.reject(err); state } }, - } + }; + let preferences = subscription.map(|value| Preferences::register(state.read(), value.clone())); + (state.consume(), preferences) } /// Run `f` on the track instance this handle reads now, without joining its consumer @@ -3624,8 +3632,8 @@ impl Consumer { /// the floor that the budget convicts, so the default budget of zero delivers only /// the latest group and a larger one reaches back over what it can still use. pub fn subscribe(&self, subscription: impl Into>) -> kio::Pending { - let state = self.resolve(); - let subscription = Preferences::register(state.read(), subscription.into().unwrap_or_default()); + let (state, subscription) = self.resolve(Some(&subscription.into().unwrap_or_default())); + let subscription = subscription.expect("a subscription was requested"); kio::Pending::new(Subscribing { name: self.name.clone(), @@ -3843,7 +3851,7 @@ impl Consumer { /// handler request. pub fn fetch_group(&self, sequence: u64, options: impl Into>) -> kio::Pending { let options = options.into().unwrap_or_default(); - let state = self.resolve(); + let state = self.resolve(None).0; let resume = state.read().routes.clone(); // One fetch per calling context, counted here (coalesced upstream work is @@ -3915,7 +3923,7 @@ impl Consumer { kio::Pending::new(Querying { name: self.name.clone(), broadcast: self.broadcast.clone(), - state: self.resolve(), + state: self.resolve(None).0, stats: self.stats.clone(), }) } @@ -4034,6 +4042,16 @@ pub struct Subscribing { } impl Subscribing { + /// Query the same track with this subscription already registered. + pub(super) fn query(&self) -> Querying { + Querying { + name: self.name.clone(), + broadcast: self.broadcast.clone(), + state: self.state.clone(), + stats: self.stats.clone(), + } + } + /// Poll until the peer confirms the subscription, yielding the [`Subscriber`]. /// Errors if the track is aborted or not found. pub fn poll_ok(&self, waiter: &kio::Waiter) -> Poll> { @@ -5930,8 +5948,9 @@ impl Request { } /// Join the eventual track's demand, for a request made through its broadcast. - pub(super) fn join(&self) -> kio::Consumer { - self.state.consume() + pub(super) fn join(&self, subscription: Option<&Subscription>) -> (kio::Consumer, Option) { + let preferences = subscription.map(|value| Preferences::register(self.state.read(), value.clone())); + (self.state.consume(), preferences) } /// Read the eventual track without joining its demand.