From ae2d063f6cb87dd67cd9b323fdf43861617b59b5 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 4 Sep 2026 13:55:47 -0700 Subject: [PATCH 1/3] fix(tokio): repair the draft-20 current-group join test after the main merge `Merge main into dev` (6947217fc) brought main's new `broadcast_moq_transport_20_current_group_join` into `rs/moq-tokio/tests/broadcast.rs` verbatim. On main that test lives in `rs/moq-native/tests/broadcast.rs` and predates both #3225 (announcements are prefix routes) and the moq-native to moq-tokio split, so it does not compile on dev: `Origin::random()`, `moq_native::{Server,Client}Config`, `create_broadcast(path, Route)`, and `Update::broadcast` are all gone. The merge also glued `next_announce`'s doc comment onto the new test. Ported onto dev's API, matching the neighbouring tests: `origin::spawn` plus a separate `announce`, `moq_tokio::{listen,connect}::Config`, `connect_once`, and resolving the announce through `request_broadcast`. The assertions the test exists for are unchanged. Co-Authored-By: Claude Opus 5 --- rs/moq-tokio/tests/broadcast.rs | 37 ++++++++++++++++++++------------- 1 file changed, 22 insertions(+), 15 deletions(-) diff --git a/rs/moq-tokio/tests/broadcast.rs b/rs/moq-tokio/tests/broadcast.rs index 61b721158cc..d943705c2e9 100644 --- a/rs/moq-tokio/tests/broadcast.rs +++ b/rs/moq-tokio/tests/broadcast.rs @@ -602,7 +602,6 @@ async fn broadcast_moq_lite_05_default_timescale() { .expect("server task failed"); } -/// Wait for the next announce event, failing the test on a timeout or a closed origin. /// Draft-20's current-group join (section 5.1.6), which splits one group across two /// streams: the subscriber asks for the next Object plus a fill of the current group, and /// the publisher serves the head on a fill fetch stream and the rest on the subscription's @@ -614,10 +613,9 @@ async fn broadcast_moq_lite_05_default_timescale() { #[tracing_test::traced_test] #[tokio::test] async fn broadcast_moq_transport_20_current_group_join() { - let pub_origin = Origin::random().produce(); - let mut broadcast = pub_origin - .create_broadcast("test", moq_net::broadcast::Route::new().with_announce(true)) - .expect("create broadcast"); + let pub_origin = moq_tokio::origin::spawn(Hop::random()); + let mut broadcast = pub_origin.create_broadcast("test").expect("create broadcast"); + let announce_broadcast = pub_origin.announce("test", Default::default()).expect("announce"); let mut track = broadcast.create_track("video", None).expect("create track"); // The group is left open, so the subscriber joins part way through it: the two head @@ -629,20 +627,22 @@ async fn broadcast_moq_transport_20_current_group_join() { .expect("write head"); } - let mut server_config = moq_native::ServerConfig::default(); + let mut server_config = moq_tokio::listen::Config::default(); server_config.bind = Some("[::]:0".to_string()); server_config.tls.generate = vec!["localhost".into()]; server_config.version = vec!["moq-transport-20".parse().unwrap()]; - let mut server = server_config.init().expect("init server"); + let server = server_config.init(Default::default()).expect("init server"); + let mut server = server.listen().await.expect("failed to listen"); let addr = server.local_addr().expect("local addr"); - let sub_origin = Origin::random().produce(); - let mut announcements = sub_origin.consume().announced(); + let sub_origin = moq_tokio::origin::spawn(Hop::random()); + let sub_consumer = sub_origin.consume(); + let mut announcements = sub_consumer.announced(); - let mut client_config = moq_native::ClientConfig::default(); - client_config.tls.disable_verify = Some(true); + let mut client_config = moq_tokio::connect::Config::default(); + client_config.tls.insecure = Some(true); client_config.version = vec!["moq-transport-20".parse().unwrap()]; - let client = client_config.init().expect("init client"); + let client = client_config.init(Default::default()).expect("init client"); let url: url::Url = format!("moqt://localhost:{}", addr.port()).parse().unwrap(); let server_handle = tokio::spawn(async move { @@ -650,18 +650,24 @@ async fn broadcast_moq_transport_20_current_group_join() { let session = request.with_publisher(&pub_origin).ok().await?; let _broadcast = broadcast; let _track = track; + let _announce = announce_broadcast; let _ = session.closed().await; Ok::<_, anyhow::Error>(()) }); let client = client.with_subscriber(sub_origin); - let session = tokio::time::timeout(TIMEOUT, client.connect(url)) + let (_client, connection) = tokio::time::timeout(TIMEOUT, connect_once(client, url)) .await .expect("connect timed out") .expect("connect failed"); let announced = next_announce(&mut announcements).await; - let remote = announced.broadcast.expect("expected an announce"); + assert_eq!(announced.prefix.as_path().as_str(), "test"); + assert!(announced.active, "expected an announce"); + let remote = tokio::time::timeout(TIMEOUT, sub_consumer.request_broadcast("test")) + .await + .expect("request timed out") + .expect("announced broadcast resolves"); let mut subscriber = tokio::time::timeout(TIMEOUT, async { remote.track("video").unwrap().subscribe(None).await }) .await @@ -696,10 +702,11 @@ async fn broadcast_moq_transport_20_current_group_join() { assert_eq!(read(&mut joined).await.as_deref(), Some(b"tail-2".as_ref())); assert_eq!(read(&mut joined).await, None, "the stitched group ends once"); - drop(session); + drop(connection); server_handle.await.expect("server panicked").expect("server failed"); } +/// Wait for the next announce event, failing the test on a timeout or a closed origin. async fn next_announce(announcements: &mut moq_net::announce::Consumer) -> moq_net::announce::Update { tokio::time::timeout(TIMEOUT, announcements.next()) .await From 7cbb7774b10799bf87acec81338e3c9273a826dc Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 4 Sep 2026 14:18:17 -0700 Subject: [PATCH 2/3] fix(cli): drop the humantime dependency the main merge resurrected `cargo shear` fails on dev: `rs/moq-cli` declares `humantime` and no source file uses it, so `just check` fails for every branch based on dev whose diff reaches moq-cli. The usage-rs migration (#3030) replaced clap's `value_parser = humantime::parse_duration` with usage-rs' own duration parsing and removed the dependency in the same commit. main still had the clap spelling, so `Merge main into dev` (6947217fc) took main's side of the manifest and put the dependency back without any of the uses. Co-Authored-By: Claude Opus 5 --- Cargo.lock | 1 - rs/moq-cli/Cargo.toml | 1 - 2 files changed, 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 69be4b74a35..88b9b92de06 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4766,7 +4766,6 @@ dependencies = [ "axum-server", "bytes", "hang", - "humantime", "moq-audio", "moq-hls", "moq-msf", diff --git a/rs/moq-cli/Cargo.toml b/rs/moq-cli/Cargo.toml index 1aad26154ca..e87087908be 100644 --- a/rs/moq-cli/Cargo.toml +++ b/rs/moq-cli/Cargo.toml @@ -83,7 +83,6 @@ axum = { workspace = true } axum-server = { workspace = true } bytes = { workspace = true } hang = { workspace = true } -humantime = { workspace = true } moq-audio = { workspace = true, optional = true, features = ["aac"] } # `server` enables the HTTP egress server for `moq export hls`; the importer is always available. moq-hls = { workspace = true, features = ["server"] } From 14889606ed73cad3a084c9d77fb44d057edfcf61 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 4 Sep 2026 14:39:30 -0700 Subject: [PATCH 3/3] fix(deps): sort moq-sock into the workspace dependency list `cargo sort --workspace --check --no-format` fails on the root manifest: `moq-sock` sits above `moq-rtc` and `moq-rtmp` in `[workspace.dependencies]` instead of after them. Co-Authored-By: Claude Opus 5 --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 8071d552392..4a0523b3d34 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -130,9 +130,9 @@ moq-net = { version = "0.2.18", path = "rs/moq-net" } # driver at runtime. Compiles on any platform (macOS included) but only actually # used by moq-video on Linux. moq-nvenc = { version = "0.0.4", path = "rs/moq-nvenc" } -moq-sock = { version = "0.0.1", path = "rs/moq-sock" } moq-rtc = { version = "0.2.8", path = "rs/moq-rtc" } moq-rtmp = { version = "0.2.8", path = "rs/moq-rtmp" } +moq-sock = { version = "0.0.1", path = "rs/moq-sock" } moq-srt = { version = "0.2.8", path = "rs/moq-srt" } moq-stats = { version = "0.1.8", path = "rs/moq-stats" } moq-token = { version = "0.7.3", path = "rs/moq-token" }