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
23 changes: 18 additions & 5 deletions rs/moq-net/tests/idle_session.rs
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,13 @@

mod support;

use std::{sync::atomic::Ordering, time::Duration};
use std::{
sync::{
Arc,
atomic::{AtomicUsize, Ordering},
},
time::Duration,
};

use moq_net::{Hop, Version, bandwidth::Rate, origin};
use support::harness::{MockConnectOptions, MockPair, connect_mock};
Expand All @@ -24,11 +30,16 @@ const STATS: MockStats = MockStats {

/// A viewer session whose server publishes `origin`, with the viewer's PROBE
/// stream open (as a browser viewer keeps one) and its first report received.
async fn viewer(version: &str, origin: &origin::Producer) -> (MockPair, moq_net::bandwidth::Consumer) {
async fn viewer(
version: &str,
origin: &origin::Producer,
polls: Option<Arc<AtomicUsize>>,
) -> (MockPair, moq_net::bandwidth::Consumer) {
let mut options = MockConnectOptions::new(version.parse::<Version>().unwrap());
options.server_publish = Some(origin.consume());
options.client_subscribe = Some(origin::Producer::new(origin::Config::new(Hop::new(2).unwrap())).0);
options.stats = STATS;
options.server_polls = polls;
let pair = connect_mock(options).await;

let mut probe = pair.client.recv_bandwidth().expect("lite carries PROBE");
Expand All @@ -47,10 +58,12 @@ fn origin() -> origin::Producer {
async fn idle_viewer_does_not_wake_the_server() {
for version in VERSIONS {
let origin = origin();
let (pair, _probe) = viewer(version, &origin).await;
let polls = Arc::new(AtomicUsize::new(0));
let (pair, _probe) = viewer(version, &origin, Some(polls.clone())).await;

let (polls, reads) = (&pair.server_polls, &pair.server_transport);
let reads = &pair.server_transport;
let (start_polls, start_reads) = (polls.load(Ordering::Relaxed), reads.stats_reads());
assert!(start_polls > 0, "the requested poll counter must observe the handshake");
moq_net_sim::sleep(IDLE).await;
let polls = polls.load(Ordering::Relaxed) - start_polls;
let reads = reads.stats_reads() - start_reads;
Expand All @@ -69,7 +82,7 @@ async fn idle_viewer_does_not_wake_the_server() {
async fn busy_viewer_sees_the_estimate_move() {
for version in VERSIONS {
let origin = origin();
let (pair, mut probe) = viewer(version, &origin).await;
let (pair, mut probe) = viewer(version, &origin, None).await;

pair.server_transport.set_stats(MockStats {
estimated_send_rate: Some(2_000_000),
Expand Down
27 changes: 10 additions & 17 deletions rs/moq-net/tests/support/harness.rs
Original file line number Diff line number Diff line change
Expand Up @@ -26,24 +26,13 @@ pub fn now() -> moq_net::time::Instant {

/// Run a protocol driver in the background: on `moq_net_sim` in tests, on tokio in
/// the benches.
pub fn spawn<D: moq_net::time::Driver + Send + Unpin + 'static>(driver: D) {
spawn_counted(driver);
}

/// [`spawn`], returning how many times the driver has been polled.
pub fn spawn_counted<D: moq_net::time::Driver + Send + Unpin + 'static>(driver: D) -> Arc<AtomicUsize> {
let polls = Arc::new(AtomicUsize::new(0));
let mut driver = Counted {
driver,
polls: polls.clone(),
};
pub fn spawn<D: moq_net::time::Driver + Send + Unpin + 'static>(mut driver: D) {
match moq_net_sim::is_running() {
true => drop(moq_net_sim::spawn(moq_net_sim::drive(move |now, waiter| {
moq_net::time::Driver::poll(&mut driver, now, waiter)
}))),
false => drop(tokio::spawn(moq_net::time::run(driver))),
}
polls
}

struct Counted<D> {
Expand Down Expand Up @@ -93,6 +82,8 @@ pub struct MockConnectOptions {
pub cost: Option<u64>,
/// What both transports report as their connection statistics.
pub stats: MockStats,
/// Count server driver polls into this counter when supplied.
pub server_polls: Option<Arc<AtomicUsize>>,
}

impl MockConnectOptions {
Expand All @@ -110,6 +101,7 @@ impl MockConnectOptions {
server_extensions: Default::default(),
cost: None,
stats: MockStats::default(),
server_polls: None,
}
}
}
Expand All @@ -123,8 +115,6 @@ pub struct MockPair {
pub client_transport: MockSession,
/// The server's end of the mock transport, for steering delivery.
pub server_transport: MockSession,
/// How many times the server's driver has been polled.
pub server_polls: Arc<AtomicUsize>,
}

/// Run the MoQ handshake over the mock transport, returning connected sessions.
Expand Down Expand Up @@ -187,16 +177,19 @@ pub async fn connect_mock(opts: MockConnectOptions) -> MockPair {
.accept(now(), server_transport)
.await
.expect("server handshake failed");
(session, spawn_counted(driver))
match opts.server_polls {
Some(polls) => spawn(Counted { driver, polls }),
None => spawn(driver),
}
session
};
let (client_session, (server_session, server_polls)) = futures::join!(client_fut, server_fut);
let (client_session, server_session) = futures::join!(client_fut, server_fut);

MockPair {
client: client_session,
server: server_session,
client_transport: transports.0,
server_transport: transports.1,
server_polls,
}
}

Expand Down
Loading