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
70 changes: 68 additions & 2 deletions js/net/src/connection/pool.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -3,10 +3,10 @@ import { type Installed, Manual, Milli, Nano } from "@moq/clock";
import { Signal } from "@moq/signals";
import { SessionCode, SessionError } from "../error.ts";
import * as Lite from "../lite/index.ts";
import { createMockTransportPair } from "../mock.ts";
import { createMockTransportPair, type MockTransport } from "../mock.ts";
import { Producer as OriginProducer, type Table } from "../origin.ts";
import * as Path from "../path.ts";
import { Stream } from "../stream.ts";
import { Stream, Writer } from "../stream.ts";
import * as Time from "../time.ts";
import { connect } from "./connect.ts";
import { type AcceptProps, accept as acceptSession } from "./index.ts";
Expand Down Expand Up @@ -598,6 +598,72 @@ test("pooled probe readers share demand and carry it through reconnects", async
}
});

/**
* Play a lite-06 peer on `server` that advertises PROBE `Increase`, returning each PROBE
* target it reads, with 0 for a retraction.
*/
function increasePeer(server: MockTransport): number[] {
const version = Lite.Version.DRAFT_06;
const targets: number[] = [];
const readProbe = async (stream: Stream) => {
if ((await stream.reader.u53()) !== Lite.StreamId.Probe) return;
for (;;) {
const probe = await Lite.Probe.decodeMaybe(stream.reader, version);
if (!probe) return;
targets.push(probe.bitrate ?? 0);
}
};
const run = async () => {
const setup = await Writer.open(server, { version });
await setup.u53(Lite.DataType.Setup);
await new Lite.Setup({ probe: Lite.ProbeLevel.Increase }).encode(setup, version);
setup.close();
for (;;) {
const stream = await Stream.accept(server, version);
if (!stream) return;
// The session's end ends every read.
void readProbe(stream).catch(() => {});
}
};
void run().catch(() => {});
return targets;
}

test("pooled viewers send their summed target to an Increase peer across a reconnect", async () => {
const peers: { server: MockTransport; targets: number[] }[] = [];
const stub = function StubWebTransport() {
const pair = createMockTransportPair(Lite.ALPN_06);
peers.push({ server: pair.server, targets: increasePeer(pair.server) });
return pair.client;
};
globalThis.WebTransport = stub as unknown as typeof WebTransport;
const first = new Connection({ url });
const second = new Connection({ url });
try {
await advance();
const one = first.viewers.peek()?.watch(3_000_000);
const two = second.viewers.peek()?.watch(2_000_000);
await advance();
expect(peers).toHaveLength(1);
expect(peers[0].targets.at(-1)).toBe(5_000_000);

peers[0].server.close({ closeCode: SessionCode.Internal, reason: "reconnect" });
await advance(2_000);
expect(peers).toHaveLength(2);
expect(peers[1].targets).toEqual([5_000_000]);

// The new session follows the live handles, not a snapshot of them.
one?.close();
await advance();
expect(peers[1].targets).toEqual([5_000_000, 2_000_000]);
two?.close();
} finally {
first.close();
second.close();
await advance(linger);
}
});

test("a handle's announcements sync with the shared origin", async () => {
stubTransports();

Expand Down
50 changes: 47 additions & 3 deletions js/net/src/lite/subscriber.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -2937,6 +2937,8 @@ function probeTargetHarness(level: ProbeLevel, options?: { failTarget?: boolean;
let writes = 0;
let stall!: () => void;
const stalled = new Promise<void>((resolve) => (stall = resolve));
let release!: () => void;
const released = new Promise<void>((resolve) => (release = resolve));
let reset!: (reason: unknown) => void;
const aborted = new Promise<unknown>((resolve) => (reset = resolve));
const quic = {
Expand All @@ -2947,10 +2949,12 @@ function probeTargetHarness(level: ProbeLevel, options?: { failTarget?: boolean;
// Only the stream type precedes the first target.
if (writes++ > 0) {
if (options?.failTarget) throw new Error("write failed");
// A peer that never drains the stream: only a reset ends the write.
if (options?.stallTarget) {
// A peer that stops draining the stream at the first target: only `release`
// or a reset ends that write.
if (options?.stallTarget && writes === 2) {
stall();
await new Promise<void>((_, reject) => {
await new Promise<void>((resolve, reject) => {
void released.then(resolve);
controller.signal.addEventListener("abort", () => {
reset(controller.signal.reason);
reject(controller.signal.reason);
Expand All @@ -2971,6 +2975,7 @@ function probeTargetHarness(level: ProbeLevel, options?: { failTarget?: boolean;
sent,
version,
stalled,
release,
aborted,
finish: () => inbound.close(),
};
Expand All @@ -2979,6 +2984,9 @@ function probeTargetHarness(level: ProbeLevel, options?: { failTarget?: boolean;
// The viewers' sum reaches the peer as its PROBE target: only once nonzero, on every change,
// and retracted with a zero, while an opt-out sends nothing at all.
test("the PROBE stream sends the viewers' target to an Increase peer", async () => {
const clock = new Manual();
const installed = clock.install();
using _clock = { [Symbol.dispose]: () => installed.close() };
const { subscriber, sent, version, finish } = probeTargetHarness(ProbeLevel.Increase);
const viewers = new Viewers();
viewers.setTarget(0);
Expand All @@ -3000,6 +3008,9 @@ test("the PROBE stream sends the viewers' target to an Increase peer", async ()
second.close();
expect((await Probe.decode(sent, version)).bitrate).toBeUndefined();

// Reading the target back only proves its bytes were written: the writer may still be
// yielding its write budget, and a FIN then would reset the stream instead of closing it.
await clock.advance(Nano.zero);
finish();
await running;
expect(await sent.done()).toBe(true);
Expand Down Expand Up @@ -3041,6 +3052,39 @@ test("ending the probe resets a stalled PROBE target write", async () => {
viewers.close();
});

// A peer that stops reading holds one target: the changes made meanwhile queue nothing
// behind it, and only the latest is sent once the write drains.
test("a stalled PROBE writer sends only the latest target once it drains", async () => {
const clock = new Manual();
const installed = clock.install();
using _clock = { [Symbol.dispose]: () => installed.close() };
const { subscriber, sent, version, stalled, release, finish } = probeTargetHarness(ProbeLevel.Increase, {
stallTarget: true,
});
const viewers = new Viewers();
const viewer = viewers.watch(1_000_000);
const running = subscriber.runProbe(undefined, viewers.target);
expect(await sent.u53()).toBe(StreamId.Probe);
await stalled;

for (const rate of [2_000_000, 3_000_000, 4_000_000]) {
viewer.update(rate);
await drainReactions();
}
release();
expect((await Probe.decode(sent, version)).bitrate).toBe(1_000_000);
expect((await Probe.decode(sent, version)).bitrate).toBe(4_000_000);

// Let the last write finish yielding before the FIN, as in the test above.
await clock.advance(Nano.zero);
finish();
await running;
expect(await sent.done()).toBe(true);
Comment thread
kixelated marked this conversation as resolved.
Resolved
viewer.close();
subscriber.close();
viewers.close();
});

// A Report-level peer only measures, so it is never sent a target to ignore.
test("the PROBE stream sends no target to a Report peer", async () => {
const { subscriber, sent, finish } = probeTargetHarness(ProbeLevel.Report);
Expand Down
23 changes: 23 additions & 0 deletions py/moq-rs/docs/index.md
Original file line number Diff line number Diff line change
Expand Up @@ -87,6 +87,29 @@ asyncio.run(main())
GroupConsumer
```

## Bandwidth

A session's estimates, split among what shares the connection: an `Allocator`
divides the send estimate among tracks, which a `RateControl` turns into each sender's
`RateTarget`, and `Viewers` divides the receive estimate among watched broadcasts,
whose ceilings summed ask the peer to probe for more.

```{eval-rst}
.. currentmodule:: moq

.. autosummary::
:toctree: api
:nosignatures:

Allocator
Reservation
RateControl
RateTarget
BandwidthConsumer
Viewers
Viewer
Comment thread
kixelated marked this conversation as resolved.
Resolved
```

## Native codecs

```{eval-rst}
Expand Down
1 change: 0 additions & 1 deletion quest/m2/probe/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -102,7 +102,6 @@ This README's own work, once the children land:
- [JS rung disable](/quest/m2/probe/rung-disable-js.md) - `@moq/publish` applies the native rung rule, recovering through padding
- [Players set viewer targets](/quest/m2/probe/players.md) - players hold a viewer handle per watched broadcast at its highest enabled rendition's bitrate
- [Viewer up-switch](/quest/m2/probe/viewer-upswitch.md) - a viewer capped by its small rendition finds headroom through PROBE and moves up
- [Viewer targets are tested end to end and documented in Python](/quest/m2/probe/viewer-followups.md) - three gaps moq-dev/moq#7090 left are closed

## Related

Expand Down
39 changes: 0 additions & 39 deletions quest/m2/probe/viewer-followups.md

This file was deleted.

72 changes: 72 additions & 0 deletions rs/moq-net/src/lite/subscriber.rs
Original file line number Diff line number Diff line change
Expand Up @@ -6721,6 +6721,78 @@ mod tests {
}
}

/// A peer that stops reading holds one PROBE target, and once it drains, only the
/// latest is sent: the targets set while the writer was stalled never pile up behind it.
#[kio::test]
async fn a_stalled_probe_writer_sends_only_the_latest_target() {
use crate::transport::poll::{RecvStream as _, Session as _};
let version = Version::Lite06;
// One queued message per stream, so a peer that stops reading stalls the writer.
let config = crate::transport::memory::Config {
stream_buffer: 0,
..Default::default()
};
let (session, peer) = crate::transport::memory::pair(config);
let producer = bandwidth::Producer::new();
let _estimate = producer.consume();
let peer_setup = lite::PeerSetup::new(false, crate::transport::Address::Setup);
peer_setup
.set(lite::Setup {
probe: lite::ProbeLevel::Increase,
..Default::default()
})
.unwrap();
let subscriber = Subscriber::new(SubscriberConfig {
runtime: crate::time::sim(),
session: crate::driver::Transport::new(session.clone()),
origin: origin::Config::new(crate::Hop::new(1).unwrap()).produce(),
recv_bandwidth: Some(producer),
version,
peer_setup,
peer_hop: None,
cost: None,
going_away: Default::default(),
auth: crate::auth::Link::new(false),
});
let viewer = subscriber.viewers.watch(bandwidth::Rate::from_mbps(1)).unwrap();
let mut probe = RecvBandwidth::new(subscriber);

// The stream type fills the stream, so the first target waits in the writer.
let (_send, mut recv) = kio::wait(|waiter| {
let _ = probe.poll(waiter);
peer.poll_accept_bi(waiter)
})
.await
.unwrap();
assert!(probe.poll(&kio::Waiter::noop()).is_pending());
for mbps in 2..=4 {
viewer.update(bandwidth::Rate::from_mbps(mbps)).unwrap();
assert!(probe.poll(&kio::Waiter::noop()).is_pending());
}

let target = |mbps| lite::Probe {
bitrate: Some(bandwidth::Rate::from_mbps(mbps).as_bps()),
rtt: None,
};
let expected = [
lite::ControlType::Probe.encode_bytes(version).unwrap(),
target(1).encode_bytes(version).unwrap(),
target(4).encode_bytes(version).unwrap(),
];
for expected in expected {
let chunk = kio::wait(|waiter| {
let _ = probe.poll(waiter);
recv.poll_read_chunk(waiter, usize::MAX)
})
.await
.unwrap()
.expect("the stream stays open");
assert_eq!(chunk, expected);
}
assert!(probe.poll(&kio::Waiter::noop()).is_pending());
assert!(recv.poll_read_chunk(&kio::Waiter::noop(), usize::MAX).is_pending());
}

/// The model's groups map to wire ranges starting and ending at a group's first frame,
/// with empty ranges dropped. Off by one here would silently drop or duplicate a group
/// at every relay hop.
Expand Down
Loading