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/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" } 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"] } 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