diff --git a/quest/m1/c/README.md b/quest/m1/c/README.md index f2a983a8026..7e1845fc16c 100644 --- a/quest/m1/c/README.md +++ b/quest/m1/c/README.md @@ -30,4 +30,3 @@ Public API: moq-c gains each m1 binding feature. Wire: none. ## Required - [API gaps](/quest/m1/c/api-gaps.md) - disabling pre-encoded simulcast rungs after the shared importer support lands -- [Every consumer cancels while pending](/quest/m1/c/consumer-cancel.md) - catalog, raw, datagram, and media consumers end cleanly on cancel before their subscription is accepted diff --git a/quest/m1/c/consumer-cancel.md b/quest/m1/c/consumer-cancel.md deleted file mode 100644 index f49e10e4731..00000000000 --- a/quest/m1/c/consumer-cancel.md +++ /dev/null @@ -1,18 +0,0 @@ -# [S] Every moq-c consumer cancels while its subscription is pending - -## Goal - -Cancelling a hand-written moq-c catalog, raw track, datagram, or media -consumer ends it with a clean final callback even while it waits for its -subscription to be accepted, as the JSON consumers do since -[moq-dev/moq#7082](https://github.com/moq-dev/moq/pull/7082). - -## Plan - -Decided 2026-10-30 (maintainer, `/quest-plan`): the hand-written crate ships -at the cut and the [generated C line](/quest/m2/c/README.md) follows it, so -fix this bug for the release, but skip converting the consumer loops to kio -polling and changing the producers: the generated binding replaces both. - -Reuse #7082's `Consume::json_subscribe` pattern for the other consumers, with -a test per consumer that cancels an unanswered subscription. diff --git a/rs/moq-c/src/consume.rs b/rs/moq-c/src/consume.rs index f3d9a461a2d..419d3b5675f 100644 --- a/rs/moq-c/src/consume.rs +++ b/rs/moq-c/src/consume.rs @@ -262,13 +262,14 @@ impl Consume { self.catalog_task.spawn( on_catalog, |state| &mut state.consume.catalog_task, - |close| async move { + |mut close| async move { driver .watch(async move { - let catalog = broadcast - .track(hang::catalog::Catalog::DEFAULT_NAME)? - .subscribe(hang::catalog::Catalog::default_subscription()) - .await?; + let subscription = hang::catalog::Catalog::default_subscription(); + let subscribe = Self::subscribe(&broadcast, hang::catalog::Catalog::DEFAULT_NAME, subscription); + let Some(catalog) = Self::until_closed(&mut close, subscribe).await? else { + return Ok(()); + }; Self::run_catalog(on_catalog, broadcast.clone(), origin, catalog.into(), close).await }) .await @@ -517,20 +518,22 @@ impl Consume { self.track_task.spawn( on_read, |state| &mut state.consume.track_task, - |close| async move { + |mut close| async move { driver .watch(async move { - let broadcast = resolve(broadcast, origin, reference).await?; - let track = broadcast - .track(&name)? - .subscribe( - moq_net::track::Subscription::default() - .with_priority(C::PRIORITY) - // The whole delay, as the container keeps it, so the first request - // already states the min. - .with_delay(delay), - ) - .await?; + let subscription = moq_net::track::Subscription::default() + .with_priority(C::PRIORITY) + // The whole delay, as the container keeps it, so the first request + // already states the min. + .with_delay(delay); + // Resolving a sibling broadcast can wait too, so the close races both steps. + let setup = async { + let broadcast = resolve(broadcast, origin, reference).await?; + Self::subscribe(&broadcast, &name, subscription).await + }; + let Some(track) = Self::until_closed(&mut close, setup).await? else { + return Ok(()); + }; let track = moq_mux::container::Consumer::new(track, container).with_delay(delay); Self::run_track(on_read, track, close).await }) @@ -603,6 +606,30 @@ impl Consume { Ok(()) } + /// Subscribe to `name`, waiting for SUBSCRIBE_OK. + async fn subscribe( + broadcast: &moq_net::broadcast::Consumer, + name: &str, + subscription: impl Into>, + ) -> Result { + Ok(broadcast.track(name)?.subscribe(subscription).await?) + } + + /// Run a consumer's `setup`, or return `None` once `close` fires first. + /// + /// A publisher can leave SUBSCRIBE_OK pending forever, so a cancel must not wait on it. + /// `close` is left unpolled once it fires, since a oneshot panics if polled again. + async fn until_closed( + close: &mut oneshot::Receiver<()>, + setup: impl Future>, + ) -> Result, Error> { + tokio::select! { + biased; + _ = close => Ok(None), + res = setup => res.map(Some), + } + } + /// Subscribe to a raw track by name, delivering each frame's payload as-is. /// /// No catalog lookup or container parsing. This is the moq-net primitive for @@ -624,14 +651,18 @@ impl Consume { let broadcast = context.broadcast.clone(); let name = name.to_string(); - let (task, close) = Task::new(on_frame); + let (task, mut close) = Task::new(on_frame); let control = RawControl::Pending(None); let id = self.raw_task.insert(RawTaskEntry { task, control })?; // `subscribe` blocks on SUBSCRIBE_OK, so run it inside the task. tokio::spawn(async move { let res = crate::ffi::run(driver.watch(async move { - let track = broadcast.track(&name)?.subscribe(subscription.clone()).await?.ordered(); + let subscribe = Self::subscribe(&broadcast, &name, subscription.clone()); + let Some(track) = Self::until_closed(&mut close, subscribe).await? else { + return Ok(()); + }; + let track = track.ordered(); let control = track.control(); Self::update_raw(&control, Self::raw_subscription(subscription))?; // Go live under the lock, so no later update lands before the pending one. @@ -794,10 +825,14 @@ impl Consume { self.datagram_task.spawn( on_datagram, |state| &mut state.consume.datagram_task, - |close| async move { + |mut close| async move { driver .watch(async move { - let track = broadcast.track(&name)?.subscribe(None).await?; + let Some(track) = + Self::until_closed(&mut close, Self::subscribe(&broadcast, &name, None)).await? + else { + return Ok(()); + }; Self::run_datagrams(on_datagram, track, close).await }) .await @@ -852,22 +887,6 @@ impl Consume { Ok(()) } - /// Subscribe a JSON consumer to `name`, or return `None` once `close` fires first. - /// - /// A publisher can leave SUBSCRIBE_OK pending forever, so a cancel must not wait on it. - async fn json_subscribe( - broadcast: &moq_net::broadcast::Consumer, - name: &str, - close: &mut oneshot::Receiver<()>, - ) -> Result, Error> { - let subscribe = broadcast.track(name)?.subscribe(None); - tokio::select! { - biased; - _ = close => Ok(None), - track = subscribe => Ok(Some(track?)), - } - } - /// Subscribe to a JSON snapshot track (lossy latest-value) by name. /// /// `on_value` is called with a value ID for each state, in order; a group superseded by a @@ -890,7 +909,9 @@ impl Consume { |mut close| async move { driver .watch(async move { - let Some(track) = Self::json_subscribe(&broadcast, &name, &mut close).await? else { + let Some(track) = + Self::until_closed(&mut close, Self::subscribe(&broadcast, &name, None)).await? + else { return Ok(()); }; let consumer = @@ -947,7 +968,9 @@ impl Consume { |mut close| async move { driver .watch(async move { - let Some(track) = Self::json_subscribe(&broadcast, &name, &mut close).await? else { + let Some(track) = + Self::until_closed(&mut close, Self::subscribe(&broadcast, &name, None)).await? + else { return Ok(()); }; let consumer = moq_json::stream::Consumer::::new(track, Default::default()); @@ -1001,7 +1024,9 @@ impl Consume { |mut close| async move { driver .watch(async move { - let Some(track) = Self::json_subscribe(&broadcast, &name, &mut close).await? else { + let Some(track) = + Self::until_closed(&mut close, Self::subscribe(&broadcast, &name, None)).await? + else { return Ok(()); }; let consumer = moq_json::window::Consumer::::new(track, Default::default()); diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index d917cc970f8..13ea2cf8c3c 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -2998,42 +2998,189 @@ fn json_window_refreshes_a_bounded_checkpoint() { assert_eq!(moq_origin_close(origin), 0); } -/// Cancelling a JSON consumer whose subscription the publisher has not answered still delivers -/// the terminal callback, for every JSON mode. -#[test] -fn json_cancel_while_subscribing() { - type Consumer = unsafe extern "C" fn(u32, *const c_char, usize, ffi::moq_status_callback, *mut c_void) -> i32; - let consumers: [(&[u8], Consumer); 3] = [ - (b"snapshot", moq_consume_json_snapshot), - (b"stream", moq_consume_json_stream), - (b"window", moq_consume_json_window), - ]; +/// Every consumer that subscribes by name, with its cancel. +type NamedConsumer = ( + &'static [u8], + fn(u32, &[u8], *mut c_void) -> i32, + extern "C" fn(u32) -> i32, +); +const NAMED_CONSUMERS: [NamedConsumer; 5] = [ + ( + b"raw", + |consume, name, user_data| unsafe { + moq_consume_track( + consume, + name.as_ptr() as *const c_char, + name.len(), + std::ptr::null(), + Some(channel_callback), + user_data, + ) + }, + moq_consume_track_cancel, + ), + ( + b"datagrams", + |consume, name, user_data| unsafe { + moq_consume_datagrams( + consume, + name.as_ptr() as *const c_char, + name.len(), + Some(channel_callback), + user_data, + ) + }, + moq_consume_datagrams_cancel, + ), + ( + b"snapshot", + |consume, name, user_data| unsafe { + moq_consume_json_snapshot( + consume, + name.as_ptr() as *const c_char, + name.len(), + Some(channel_callback), + user_data, + ) + }, + moq_consume_json_cancel, + ), + ( + b"stream", + |consume, name, user_data| unsafe { + moq_consume_json_stream( + consume, + name.as_ptr() as *const c_char, + name.len(), + Some(channel_callback), + user_data, + ) + }, + moq_consume_json_cancel, + ), + ( + b"window", + |consume, name, user_data| unsafe { + moq_consume_json_window( + consume, + name.as_ptr() as *const c_char, + name.len(), + Some(channel_callback), + user_data, + ) + }, + moq_consume_json_cancel, + ), +]; + +/// Cancelling a consumer whose subscription the publisher has not answered still delivers the +/// terminal callback. +#[test] +fn named_consumers_cancel_while_subscribing() { let origin = id(moq_origin_create()); - let broadcast = publish_broadcast(origin, b"json-cancel-subscribing"); + let broadcast = publish_broadcast(origin, b"cancel-subscribing"); // Unknown tracks become requests, which leave each subscribe pending until answered. let request_cb = Callback::new(); let dynamic = id(unsafe { moq_publish_requests(broadcast, Some(channel_callback), request_cb.ptr) }); let consume = consume_local(broadcast); - for (name, consumer) in consumers { + for (name, consumer, cancel) in NAMED_CONSUMERS { let cb = Callback::new(); - let task = id(unsafe { - consumer( - consume, - name.as_ptr() as *const c_char, - name.len(), - Some(channel_callback), - cb.ptr, - ) - }); + let task = id(consumer(consume, name, cb.ptr)); + let request = id(request_cb.recv()); + + assert_eq!(cancel(task), 0); + assert_eq!(cb.recv_terminal(), 0, "a cancelled subscribe ends cleanly"); + assert_eq!(moq_track_request_free(request), 0); + } + + assert_eq!(moq_publish_requests_cancel(dynamic), 0); + assert_eq!(request_cb.recv_terminal(), 0); + assert_eq!(moq_consume_close(consume), 0); + assert_eq!(moq_publish_close(broadcast), 0); + assert_eq!(moq_origin_close(origin), 0); +} + +#[test] +fn catalog_cancel_while_subscribing() { + // A bare moq-net broadcast has no catalog track, so its subscribe waits on the handler. + let broadcast = moq_net::broadcast::Info::new().produce(); + let mut requests = broadcast.requests(); + let consume = i32::from(State::lock().consume.start(broadcast.consume(), None).unwrap()) as u32; + + let cb = Callback::new(); + let catalog = id(unsafe { moq_consume_catalog(consume, Some(channel_callback), cb.ptr) }); + let _unanswered = crate::ffi::RUNTIME.block_on(requests.requested_track()).unwrap(); + + assert_eq!(moq_consume_catalog_cancel(catalog), 0); + assert_eq!(cb.recv_terminal(), 0, "a cancelled subscribe ends cleanly"); + assert_eq!(moq_consume_close(consume), 0); +} + +#[test] +fn media_consumers_cancel_while_subscribing() { + let origin = id(moq_origin_create()); + let broadcast = publish_broadcast(origin, b"media-cancel-subscribing"); + + // Catalog renditions with no track behind them, so each media subscribe becomes a request. + let (video_name, video_codec) = ("video", "vp8"); + let video = moq_video_config { + preference: 0, + name: video_name.as_ptr() as *const c_char, + name_len: video_name.len(), + label: std::ptr::null(), + label_len: 0, + codec: video_codec.as_ptr() as *const c_char, + codec_len: video_codec.len(), + description: std::ptr::null(), + description_len: 0, + coded_width: 0, + coded_height: 0, + container: moq_container::default(), + }; + assert_eq!(unsafe { moq_publish_video_config(broadcast, &video) }, 0); + let (audio_name, audio_codec) = ("audio", "opus"); + let audio = moq_audio_config { + name: audio_name.as_ptr() as *const c_char, + name_len: audio_name.len(), + label: std::ptr::null(), + label_len: 0, + codec: audio_codec.as_ptr() as *const c_char, + codec_len: audio_codec.len(), + description: std::ptr::null(), + description_len: 0, + sample_rate: 48000, + channel_count: 2, + container: moq_container::default(), + }; + assert_eq!(unsafe { moq_publish_audio_config(broadcast, &audio) }, 0); + + let request_cb = Callback::new(); + let dynamic = id(unsafe { moq_publish_requests(broadcast, Some(channel_callback), request_cb.ptr) }); + let consume = consume_local(broadcast); + let catalog_cb = Callback::new(); + let catalog_task = id(unsafe { moq_consume_catalog(consume, Some(channel_callback), catalog_cb.ptr) }); + let catalog = id(catalog_cb.recv()); + + type Media = unsafe extern "C" fn(u32, u32, *const moq_delay, ffi::moq_status_callback, *mut c_void) -> i32; + let consumers: [(Media, extern "C" fn(u32) -> i32); 2] = [ + (moq_consume_video, moq_consume_video_cancel), + (moq_consume_audio, moq_consume_audio_cancel), + ]; + for (consumer, cancel) in consumers { + let cb = Callback::new(); + let task = id(unsafe { consumer(catalog, 0, std::ptr::null(), Some(channel_callback), cb.ptr) }); let request = id(request_cb.recv()); - assert_eq!(moq_consume_json_cancel(task), 0); + assert_eq!(cancel(task), 0); assert_eq!(cb.recv_terminal(), 0, "a cancelled subscribe ends cleanly"); assert_eq!(moq_track_request_free(request), 0); } + assert_eq!(moq_consume_catalog_free(catalog), 0); + assert_eq!(moq_consume_catalog_cancel(catalog_task), 0); + assert_eq!(catalog_cb.recv_catalog_terminal(), 0); assert_eq!(moq_publish_requests_cancel(dynamic), 0); assert_eq!(request_cb.recv_terminal(), 0); assert_eq!(moq_consume_close(consume), 0);