Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 0 additions & 1 deletion Cargo.lock

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

2 changes: 1 addition & 1 deletion Cargo.toml
Original file line number Diff line number Diff line change
Expand Up @@ -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" }
Expand Down
1 change: 0 additions & 1 deletion rs/moq-cli/Cargo.toml
Original file line number Diff line number Diff line change
Expand Up @@ -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"] }
Expand Down
37 changes: 22 additions & 15 deletions rs/moq-tokio/tests/broadcast.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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
Expand All @@ -629,39 +627,47 @@ 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 {
let request = server.accept().await.expect("no incoming connection");
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
Expand Down Expand Up @@ -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
Expand Down
Loading