From 36df702f1fed9442b154b46821562cf807bcf544 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 21:02:23 -0800 Subject: [PATCH 1/8] chore(quest): claim quest/m2/outcome-enums/create-group.md Quest-Claim: f0d4b6f229bc8d76 From 4e49c3d1c305ae66269d6fb20506d165ca61d38d Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 21:23:23 -0800 Subject: [PATCH 2/8] feat(net)!: create_group reports a held start as None, not Err(Duplicate) Co-Authored-By: Claude Opus 5.5 --- js/e2ee/src/e2ee.test.ts | 12 +- js/e2ee/src/track.ts | 7 +- js/hang/bench/buffered.ts | 7 +- js/hang/bench/slow-group.ts | 3 +- .../src/container/consumer.backlog.test.ts | 9 +- .../container/consumer.backpressure.test.ts | 69 +- js/hang/src/container/consumer.holes.test.ts | 25 +- .../container/consumer.nonsequential.test.ts | 13 +- .../src/container/consumer.ordered.test.ts | 9 +- .../src/container/consumer.outoforder.test.ts | 7 +- js/hang/src/container/consumer.skips.test.ts | 23 +- .../src/container/consumer.startup.test.ts | 19 +- js/hang/src/container/consumer.test.ts | 89 +-- js/hang/src/container/consumer.warmup.test.ts | 3 +- js/json/src/snapshot/snapshot.test.ts | 1 + js/net/bench/drift.ts | 3 +- js/net/bench/fill-probe.ts | 4 +- js/net/bench/replay.ts | 3 +- js/net/bench/resume.ts | 2 +- js/net/bench/subscribe-drop.ts | 2 +- js/net/bench/track.ts | 3 +- js/net/src/broadcast.test.ts | 4 +- js/net/src/cache.test.ts | 13 +- js/net/src/fill.test.ts | 36 +- js/net/src/flate/group.test.ts | 3 +- js/net/src/group-id.test.ts | 10 +- js/net/src/group.test.ts | 3 +- js/net/src/ietf/join.test.ts | 10 +- js/net/src/ietf/publisher.test.ts | 24 +- js/net/src/ietf/subscriber.ts | 10 +- js/net/src/integration.test.ts | 12 +- js/net/src/lite/copy_fill.test.ts | 18 +- js/net/src/lite/drop_record.test.ts | 2 +- js/net/src/lite/fills.test.ts | 2 +- js/net/src/lite/publisher.test.ts | 86 +-- js/net/src/lite/subscriber.test.ts | 9 +- js/net/src/lite/widened_max_age.test.ts | 4 +- js/net/src/net-cleanups.test.ts | 3 +- js/net/src/ordered.test.ts | 5 +- js/net/src/origin.test.ts | 14 +- js/net/src/parked-expiry.test.ts | 4 +- js/net/src/resume.model.test.ts | 4 +- js/net/src/resume.test.ts | 28 +- js/net/src/track.test.ts | 303 ++++----- js/net/src/track.ts | 24 +- js/net/src/untimed.test.ts | 4 +- js/watch/src/audio/decoder.test.ts | 2 +- js/watch/src/audio/playout.test.ts | 3 +- js/watch/src/audio/replay.ts | 4 +- js/watch/src/video/decoder.test.ts | 10 +- rs/libmoq/src/api.rs | 3 +- rs/libmoq/src/consume.rs | 4 +- rs/libmoq/src/publish.rs | 5 +- rs/libmoq/src/test.rs | 4 +- rs/moq-archive/benches/producer.rs | 2 +- rs/moq-archive/src/consumer/tests.rs | 8 +- rs/moq-archive/src/consumer/track.rs | 6 +- rs/moq-archive/src/producer/backends.rs | 4 +- rs/moq-archive/src/producer/tests.rs | 20 +- rs/moq-audio/src/decode/consumer.rs | 8 +- rs/moq-cli/src/archive.rs | 6 +- rs/moq-cli/src/play/video.rs | 4 +- rs/moq-e2ee/src/tests.rs | 8 +- rs/moq-e2ee/src/track.rs | 6 +- rs/moq-ffi/src/media.rs | 8 +- rs/moq-ffi/src/producer.rs | 6 +- rs/moq-hls/src/export/mod.rs | 24 +- rs/moq-hls/src/server/include_tests.rs | 2 +- rs/moq-json/src/snapshot/mod.rs | 6 +- rs/moq-mux/src/codec/h264/export.rs | 6 +- rs/moq-mux/src/codec/h265/export.rs | 6 +- rs/moq-mux/src/container/consumer.rs | 174 ++--- rs/moq-mux/src/container/fmp4/import.rs | 5 +- rs/moq-mux/src/container/producer.rs | 10 +- rs/moq-mux/src/container/source.rs | 10 +- rs/moq-mux/src/container/ts/export_test.rs | 14 +- rs/moq-mux/src/container/ts/recovery_test.rs | 2 +- rs/moq-mux/src/container/ts/release_test.rs | 2 +- .../tests/integration/snapshot.rs | 2 +- rs/moq-net/benches/origin.rs | 4 +- rs/moq-net/benches/ranges.rs | 6 +- rs/moq-net/benches/tail.rs | 2 +- rs/moq-net/benches/track.rs | 20 +- rs/moq-net/src/fuzz/ingest.rs | 2 +- rs/moq-net/src/ietf/publisher.rs | 198 +++--- rs/moq-net/src/ietf/subscriber.rs | 47 +- rs/moq-net/src/ietf/subscriber/tracks.rs | 2 +- rs/moq-net/src/lite/ietf.rs | 8 +- rs/moq-net/src/lite/publisher.rs | 54 +- rs/moq-net/src/lite/subscriber.rs | 28 +- rs/moq-net/src/lite/subscriber/fills.rs | 2 +- rs/moq-net/src/model/broadcast.rs | 4 +- rs/moq-net/src/model/group.rs | 4 +- rs/moq-net/src/model/origin.rs | 14 +- rs/moq-net/src/model/resume.rs | 256 +++---- rs/moq-net/src/model/resume_model.rs | 2 +- rs/moq-net/src/model/track.rs | 629 +++++++++--------- rs/moq-net/src/model/track/miss.rs | 28 +- .../tests/integration/answer_behind_cache.rs | 8 +- rs/moq-net/tests/integration/compress.rs | 2 +- rs/moq-net/tests/integration/drop_record.rs | 10 +- .../tests/integration/fetch_from_feed.rs | 2 +- rs/moq-net/tests/integration/fetch_only.rs | 2 +- rs/moq-net/tests/integration/group_order.rs | 2 +- .../tests/integration/history_groups.rs | 8 +- .../tests/integration/idle_cancel_refetch.rs | 6 +- .../tests/integration/late_lower_group.rs | 2 +- rs/moq-net/tests/integration/model.rs | 2 +- rs/moq-net/tests/integration/range_anchors.rs | 8 +- rs/moq-net/tests/integration/range_fill.rs | 8 +- .../tests/integration/range_union_fit.rs | 2 +- .../tests/integration/received_rewind.rs | 2 +- .../tests/integration/route_audit/mod.rs | 2 +- rs/moq-net/tests/integration/route_change.rs | 4 +- rs/moq-net/tests/integration/route_cluster.rs | 2 +- .../tests/integration/shared_copy_start.rs | 2 +- rs/moq-net/tests/integration/slow_joiner.rs | 2 +- rs/moq-net/tests/integration/stream_credit.rs | 20 +- .../tests/integration/subscribe_ranges.rs | 20 +- .../integration/track_abort_over_session.rs | 4 +- rs/moq-net/tests/integration/warm_backfill.rs | 6 +- rs/moq-net/tests/integration/wide_key.rs | 6 +- .../tests/integration/widened_max_age.rs | 6 +- rs/moq-relay/tests/integration/connection.rs | 2 +- rs/moq-relay/tests/integration/quic_sim.rs | 2 +- rs/moq-tokio/tests/integration/broadcast.rs | 6 + rs/moq-tokio/tests/integration/relay_fill.rs | 4 +- rs/moq-tokio/tests/integration/sim.rs | 2 +- rs/moq-tokio/tests/integration/sim_client.rs | 2 +- rs/moq-transcode/src/lib.rs | 22 +- rs/moq-transcode/src/rung.rs | 48 +- rs/moq-video/src/decode/consumer.rs | 12 +- test/interop/clients/rust/control.rs | 4 +- 133 files changed, 1469 insertions(+), 1415 deletions(-) diff --git a/js/e2ee/src/e2ee.test.ts b/js/e2ee/src/e2ee.test.ts index 831b2787aab..6966ff84b3f 100644 --- a/js/e2ee/src/e2ee.test.ts +++ b/js/e2ee/src/e2ee.test.ts @@ -421,7 +421,7 @@ test("grouped authentication failure ends the track", async () => { group.finish(); // A forged second group, written straight to the net track. - const bad = p.net.createGroup(1n); + const bad = defined(p.net.createGroup(1n)); bad.writeFrame({ timestamp: ms(2), payload: await sealed(p, GROUP, 1n, 0, "ok", true) }); bad.finish(); @@ -439,9 +439,9 @@ test("grouped failure wakes pending reads and releases demand", async () => { expect(demand.wanted.peek()).toBe(true); // One authentic frame, then silence. The group and the track stay open. - const open = p.net.createGroup(0n); + const open = defined(p.net.createGroup(0n)); open.writeFrame({ timestamp: ms(1), payload: await sealed(p, GROUP, 0n, 0, "ok") }); - const bad = p.net.createGroup(1n); + const bad = defined(p.net.createGroup(1n)); const badDemand = bad.demand(); bad.writeFrame({ timestamp: ms(2), payload: await sealed(p, GROUP, 1n, 0, "nope", true) }); @@ -469,7 +469,7 @@ test("grouped failure wakes pending reads and releases demand", async () => { test("a grouped failure leaves the independent datagram track readable", async () => { const p = await pair("audio"); - const bad = p.net.createGroup(0n); + const bad = defined(p.net.createGroup(0n)); bad.writeFrame({ timestamp: ms(1), payload: await sealed(p, GROUP, 0n, 0, "nope", true) }); p.dg.net.insert({ sequence: 0n, timestamp: ms(2), payload: await sealed(p, DATAGRAM, 0n, 0, "late") }); const forged = await recvGroup(p.consumer); @@ -896,9 +896,9 @@ test("a timestamp out of range at the track's timescale spends nothing", async ( test("a grouped failure skips opens queued behind it", async () => { const p = await pair("video"); - const bad = p.net.createGroup(0n); + const bad = defined(p.net.createGroup(0n)); bad.writeFrame({ timestamp: ms(1), payload: await sealed(p, GROUP, 0n, 0, "nope", true) }); - const good = p.net.createGroup(1n); + const good = defined(p.net.createGroup(1n)); good.writeFrame({ timestamp: ms(2), payload: await sealed(p, GROUP, 1n, 0, "ok") }); p.dg.net.insert({ sequence: 0n, timestamp: ms(3), payload: await sealed(p, DATAGRAM, 0n, 0, "late") }); const forged = await recvGroup(p.consumer); diff --git a/js/e2ee/src/track.ts b/js/e2ee/src/track.ts index 2a69ccd402e..ffa2c7eb145 100644 --- a/js/e2ee/src/track.ts +++ b/js/e2ee/src/track.ts @@ -66,14 +66,15 @@ export class Producer { * Start a group at `start`, in the track's timescale, which must be at or above the next * unallocated one, as {@link NetTrack.Producer.createGroup} does. * - * Throws {@link Failure} `reuse` if `start` was already allocated, `identity` if it exceeds - * `2^53-1`, or a net error. + * Throws {@link Failure} `reuse` if `start` was already allocated or another group holds it, + * `identity` if it exceeds `2^53-1`, or a net error. */ createGroup(start: bigint): Group.Producer { this.#writable(); this.#reserve(start); - this.#next = start + 1n; const inner = this.#inner.createGroup(start); + if (inner === undefined) throw new Failure("reuse"); + this.#next = start + 1n; return Group.Producer.make(inner, this.#writer); } diff --git a/js/hang/bench/buffered.ts b/js/hang/bench/buffered.ts index 63bd1a9d1e8..48cb4b3c826 100644 --- a/js/hang/bench/buffered.ts +++ b/js/hang/bench/buffered.ts @@ -4,6 +4,7 @@ import { type Group, Time, Track, Varint } from "@moq/net"; import { Signal } from "@moq/signals"; import { Consumer } from "../src/container/consumer.ts"; import { Format } from "../src/container/legacy.ts"; +import { defined } from "../src/defined.test-util.ts"; // Far past every fixture's span, so only the burst case skips anything. const HOLD = Duration.millis(1_000_000_000); @@ -130,7 +131,7 @@ async function measure( if (scenario === "steady") { // The player reads each frame as it lands, so nothing builds up behind it. for (const i of order) { - const sources = tracks.map((track) => track.createGroup(BigInt(i))); + const sources = tracks.map((track) => defined(track.createGroup(BigInt(i)))); for (let frame = 0; frame < frames; frame++) { const reads = players.map((player) => player.consumer.next()); for (const source of sources) source.writeFrame(wire(i, frame)); @@ -145,7 +146,7 @@ async function measure( // Everything arrives before the player reads: a stalled reader, or history after a join. for (const i of order) { - const sources = tracks.map((track) => track.createGroup(BigInt(sequence(i)))); + const sources = tracks.map((track) => defined(track.createGroup(BigInt(sequence(i))))); for (let frame = 0; frame < frames; frame++) await arrive(sources, players, sequence(i), frame); for (const source of sources) source.finish(); } @@ -169,7 +170,7 @@ async function measure( // The budget drops to nothing, so the next arrival makes every older group too stale to keep. delay.set({ max: Duration.ZERO }); start = performance.now(); - const sources = tracks.map((track) => track.createGroup(BigInt(groups))); + const sources = tracks.map((track) => defined(track.createGroup(BigInt(groups)))); await arrive(sources, players, groups, 0); const elapsed = (performance.now() - start) * 1e6; const newest = timestamp(groups, 0) / 1000; diff --git a/js/hang/bench/slow-group.ts b/js/hang/bench/slow-group.ts index 4004d48f30d..8e9c25ae10a 100644 --- a/js/hang/bench/slow-group.ts +++ b/js/hang/bench/slow-group.ts @@ -5,6 +5,7 @@ import { Time, Track, Varint } from "@moq/net"; import { Signal } from "@moq/signals"; import { Consumer } from "../src/container/consumer.ts"; import { Format } from "../src/container/legacy.ts"; +import { defined } from "../src/defined.test-util.ts"; console.log("groups,warnings,bytes,catchup_ms"); for (const count of [1, 16, 256, 1024]) { @@ -15,7 +16,7 @@ for (const count of [1, 16, 256, 1024]) { delay, }); const write = (sequence: bigint) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: Varint.encode(Number(sequence) * 1000), timestamp: Time.Timestamp.now() }); }; const buffered = async (timestamp: number) => { diff --git a/js/hang/src/container/consumer.backlog.test.ts b/js/hang/src/container/consumer.backlog.test.ts index 6202f742375..688256de818 100644 --- a/js/hang/src/container/consumer.backlog.test.ts +++ b/js/hang/src/container/consumer.backlog.test.ts @@ -10,6 +10,7 @@ import { race } from "@moq/signals"; import { Consumer } from "./consumer.ts"; import { Jitter } from "./jitter.ts"; import { Format } from "./legacy.ts"; +import { defined } from "../defined.test-util.ts"; let clock: Manual; let installed: Installed; @@ -42,7 +43,7 @@ async function play(events: Event[], backlog: (group: number) => boolean): Promi try { for (const [at, sequence, media] of events) { await clock.advance(Duration.millis(base + at).saturatingSub(now().since(Instant.ZERO))); - const group = track.createGroup(BigInt(sequence)); + const group = defined(track.createGroup(BigInt(sequence))); const payload = new Uint8Array([...Varint.encode(media * 1000), 1]); group.writeFrame({ payload, timestamp: Time.Timestamp.fromMicros(media * 1000) }); group.finish(); @@ -151,7 +152,7 @@ test("the join's boundary is the publisher's answer, not a group that raced it", delay: { min: Duration.millis(100), max: Duration.millis(2000) }, }); const write = (sequence: number, media: number) => { - const group = track.createGroup(BigInt(sequence)); + const group = defined(track.createGroup(BigInt(sequence))); const payload = new Uint8Array([...Varint.encode(media * 1000), 1]); group.writeFrame({ payload, timestamp: Time.Timestamp.fromMicros(media * 1000) }); group.finish(); @@ -209,7 +210,7 @@ test("the join's boundary is the publisher's answer, not the largest by the firs delay: { max: Duration.millis(2000) }, }); const write = (sequence: number, media: number) => { - const group = track.createGroup(BigInt(sequence)); + const group = defined(track.createGroup(BigInt(sequence))); const payload = new Uint8Array([...Varint.encode(media * 1000), 1]); group.writeFrame({ payload, timestamp: Time.Timestamp.fromMicros(media * 1000) }); group.finish(); @@ -241,7 +242,7 @@ test("a range capped below the largest still delivers", async () => { // largest: the consumer reports no backlog, but delivers what it can read. const track = new Track.Producer("audio"); for (let sequence = 0; sequence <= 5; sequence++) { - const group = track.createGroup(BigInt(sequence)); + const group = defined(track.createGroup(BigInt(sequence))); const media = sequence * 20; group.writeFrame({ payload: new Uint8Array([...Varint.encode(media * 1000), 1]), diff --git a/js/hang/src/container/consumer.backpressure.test.ts b/js/hang/src/container/consumer.backpressure.test.ts index b99501fe943..f962bab2f45 100644 --- a/js/hang/src/container/consumer.backpressure.test.ts +++ b/js/hang/src/container/consumer.backpressure.test.ts @@ -5,6 +5,7 @@ import { Time, Track } from "@moq/net"; import { Consumer, type Read } from "./consumer.ts"; import { encodeFrame, Format } from "./legacy.ts"; import type { Frame } from "./types.ts"; +import { defined } from "../defined.test-util.ts"; // Counts decoded samples, so a test can tell how many the consumer holds ahead of its reads. class Counting extends Format { @@ -65,9 +66,9 @@ test("Consumer holds frames sharing a timestamp within the max buffer", async () // Frames packed into one timestamp have no span, so the age budget never skips the stalled // group they queue behind. They fill the max buffer instead, which skips it once its one frame // is read, so nothing decoded is dropped. - const stalled = track.createGroup(0n); + const stalled = defined(track.createGroup(0n)); write(stalled, 0); - const packed = track.createGroup(1n); + const packed = defined(track.createGroup(1n)); for (let i = 0; i < 2_000; i++) write(packed, 10_000); packed.finish(); track.finish(); @@ -97,10 +98,10 @@ test("Consumer holds many groups within the max buffer and reaches the live edge maxBuffer, }); try { - const stalled = track.createGroup(0n); + const stalled = defined(track.createGroup(0n)); write(stalled, 0); for (let g = 1n; g <= 500n; g++) { - const group = track.createGroup(g); + const group = defined(track.createGroup(g)); write(group, Number(g) * 1_000); group.finish(); } @@ -133,9 +134,9 @@ test("Consumer skips a stalled group once group overhead alone fills the max buf maxBuffer: 512, }); try { - const stalled = track.createGroup(0n); + const stalled = defined(track.createGroup(0n)); write(stalled, 0); - const next = track.createGroup(1n); + const next = defined(track.createGroup(1n)); write(next, 10_000); next.finish(); @@ -160,10 +161,10 @@ test("Consumer reaches a readable group past a stalled successor once group over maxBuffer: 768, }); try { - const stalled = track.createGroup(0n); + const stalled = defined(track.createGroup(0n)); write(stalled, 0); - track.createGroup(1n); - const readable = track.createGroup(2n); + defined(track.createGroup(1n)); + const readable = defined(track.createGroup(2n)); write(readable, 10_000); write(readable, 20_000); readable.finish(); @@ -190,7 +191,7 @@ test("Consumer admits reads completing together one at a time against the max bu try { // Ten open groups park on their first read with room to spare, then large frames land in all of // them at once. - const groups = Array.from({ length: 10 }, (_, sequence) => track.createGroup(BigInt(sequence))); + const groups = Array.from({ length: 10 }, (_, sequence) => defined(track.createGroup(BigInt(sequence)))); await flush(); const large = new Uint8Array(2_000); for (const group of groups) { @@ -223,9 +224,9 @@ test("Consumer charges a small view of a large wire frame the wire frame", async maxBuffer: 16 * 1024, }); try { - const stalled = track.createGroup(0n); + const stalled = defined(track.createGroup(0n)); write(stalled, 0); - const padded = track.createGroup(1n); + const padded = defined(track.createGroup(1n)); const padding = new Uint8Array(60_000); for (let i = 0; i < 8; i++) { padded.writeFrame({ @@ -266,7 +267,7 @@ test("Consumer stamps frames the max buffer held back with when they landed, not maxBuffer: 300, }); try { - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); write(group, 0); await clock.advance(Duration.millis(250)); write(group, 10_000); @@ -302,11 +303,11 @@ test("Consumer expires a hole behind a full max buffer from when the group past }); try { for (const sequence of [0n, 1n]) { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); write(group, Number(sequence) * 10_000); group.finish(); } - const marker = track.createGroup(3n); + const marker = defined(track.createGroup(3n)); marker.writeFrame({ payload: new Uint8Array(), timestamp: Time.Timestamp.fromMicros(30_000) }); marker.finish(); // The reader is slow: the hole before group 3 expired before anything is read. @@ -334,9 +335,9 @@ for (const maxBuffer of [0, 256]) { maxBuffer, }); try { - const stalled = track.createGroup(0n); + const stalled = defined(track.createGroup(0n)); write(stalled, 0); - const next = track.createGroup(1n); + const next = defined(track.createGroup(1n)); write(next, 10_000); next.finish(); @@ -364,12 +365,12 @@ test("Consumer moves past a stalled backlog group below the cursor once the max maxBuffer: 512, }); try { - const active = track.createGroup(3n); + const active = defined(track.createGroup(3n)); write(active, 30_000); expect(await consumer.next()).toMatchObject({ kind: "frame", group: 3n }); - track.createGroup(1n); - const newer = track.createGroup(4n); + defined(track.createGroup(1n)); + const newer = defined(track.createGroup(4n)); write(newer, 40_000); newer.finish(); @@ -395,14 +396,14 @@ test("Consumer reads what a promoted head already holds before skipping it under maxBuffer: 1024, }); try { - const stalled = track.createGroup(0n); + const stalled = defined(track.createGroup(0n)); write(stalled, 0); expect(await consumer.next()).toMatchObject({ kind: "frame", group: 0n }); // A later group's large frame fills the max buffer, then a frame lands in the group between, // stamped on the wire before the later group's. - const between = track.createGroup(1n); - const later = track.createGroup(2n); + const between = defined(track.createGroup(1n)); + const later = defined(track.createGroup(2n)); const early = Time.Timestamp.now(); later.writeFrame({ payload: encodeFrame(new Uint8Array(2_000), Duration.micros(20_000)), @@ -444,13 +445,13 @@ test("Consumer raises a malformed frame in a head promoted under pressure", asyn maxBuffer: 1024, }); try { - const stalled = track.createGroup(0n); + const stalled = defined(track.createGroup(0n)); write(stalled, 0); expect(await consumer.next()).toMatchObject({ kind: "frame", group: 0n }); // A later group's large frame fills the max buffer, then a malformed frame lands in the open group between. - const between = track.createGroup(1n); - const later = track.createGroup(2n); + const between = defined(track.createGroup(1n)); + const later = defined(track.createGroup(2n)); const early = Time.Timestamp.now(); later.writeFrame({ payload: encodeFrame(new Uint8Array(2_000), Duration.micros(20_000)), @@ -476,11 +477,11 @@ test("Consumer raises a malformed group an age skip passes after the track finis delay: { max: Duration.millis(500) }, }); try { - const first = track.createGroup(0n); + const first = defined(track.createGroup(0n)); write(first, 0); first.finish(); - const malformed = track.createGroup(1n); - const later = track.createGroup(2n); + const malformed = defined(track.createGroup(1n)); + const later = defined(track.createGroup(2n)); track.finish(); expect(await within(consumer.next())).toMatchObject({ kind: "frame", group: 0n }); await flush(); @@ -508,13 +509,13 @@ test("Consumer reads a finished marker group's end before skipping under pressur maxBuffer: 1024, }); try { - const stalled = track.createGroup(0n); + const stalled = defined(track.createGroup(0n)); write(stalled, 0); expect(await consumer.next()).toMatchObject({ kind: "frame", group: 0n }); // A later group's large frame fills the max buffer, then the group between finishes as a data marker. - const between = track.createGroup(1n); - const later = track.createGroup(2n); + const between = defined(track.createGroup(1n)); + const later = defined(track.createGroup(2n)); const early = Time.Timestamp.now(); later.writeFrame({ payload: encodeFrame(new Uint8Array(2_000), Duration.micros(20_000)), @@ -547,10 +548,10 @@ test("Consumer reads a group whose frame fails to read as cut short while the re delay: { max: Duration.millis(5_000) }, }); try { - const stalled = track.createGroup(0n); + const stalled = defined(track.createGroup(0n)); write(stalled, 0); expect(await consumer.next()).toMatchObject({ kind: "frame", group: 0n }); - const next = track.createGroup(1n); + const next = defined(track.createGroup(1n)); write(next, 10_000); next.finish(); diff --git a/js/hang/src/container/consumer.holes.test.ts b/js/hang/src/container/consumer.holes.test.ts index b6e8bd0e40e..af81f8edd15 100644 --- a/js/hang/src/container/consumer.holes.test.ts +++ b/js/hang/src/container/consumer.holes.test.ts @@ -5,6 +5,7 @@ import { Time, Track } from "@moq/net"; import { Signal } from "@moq/signals"; import { Consumer, type Read } from "./consumer.ts"; import { encodeFrame, Format } from "./legacy.ts"; +import { defined } from "../defined.test-util.ts"; const flush = () => new Promise((resolve) => setImmediate(resolve)); @@ -25,7 +26,7 @@ test.each([0, 100])("a sequence hole before a paused data marker expires at %sms } })(); try { - const first = track.createGroup(0n); + const first = defined(track.createGroup(0n)); first.writeFrame({ payload: encodeFrame(new Uint8Array([1]), Duration.micros(10_000)), timestamp: Time.Timestamp.fromMicros(10_000), @@ -33,7 +34,7 @@ test.each([0, 100])("a sequence hole before a paused data marker expires at %sms first.finish(); await flush(); expect(results).toHaveLength(1); - const marker = track.createGroup(2n); + const marker = defined(track.createGroup(2n)); // A data marker carries no container timestamp; its group's start still passes the first's. marker.writeFrame({ payload: new Uint8Array(), timestamp: Time.Timestamp.fromMicros(20_000) }); marker.finish(); @@ -77,7 +78,7 @@ test("a filled hole cancels its timer and the next hole gets a fresh budget", as } })(); const write = (sequence: bigint, timestamp?: number) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: timestamp === undefined @@ -135,7 +136,7 @@ test("the holes a stalled source left behind share one budget", async () => { } })(); const write = (sequence: bigint) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: encodeFrame(new Uint8Array([1]), Duration.micros(Number(sequence) * 10_000)), timestamp: Time.Timestamp.fromMicros(Number(sequence) * 10_000), @@ -179,7 +180,7 @@ test("a hole is late from the earliest arrival past it", async () => { } })(); const write = (sequence: bigint) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: encodeFrame(new Uint8Array([1]), Duration.micros(Number(sequence) * 10_000)), timestamp: Time.Timestamp.fromMicros(Number(sequence) * 10_000), @@ -214,14 +215,14 @@ test("a hole in a drained backlog is late from the earliest arrival past it, not const installed = clock.install(); const track = new Track.Producer("data"); const marker = (sequence: bigint) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: new Uint8Array(), timestamp: Time.Timestamp.fromMicros(Number(sequence) * 10_000), }); group.finish(); }; - const first = track.createGroup(0n); + const first = defined(track.createGroup(0n)); first.writeFrame({ payload: encodeFrame(new Uint8Array([1]), Duration.micros(0)), timestamp: Time.Timestamp.fromMicros(0), @@ -286,7 +287,7 @@ test.each([true, false])("the head after a declared end is waited for (arrives: } })(); const write = (sequence: bigint, ...frames: [number, Uint8Array?][]) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); for (const [timestamp, payload = new Uint8Array([1])] of frames) { group.writeFrame({ payload: encodeFrame(payload, Duration.micros(timestamp)), @@ -367,7 +368,7 @@ test("a newest-first flush past a hole delivers the groups landing behind its ne })(); // One 20ms frame per group, as a voice publisher writes them, all sent at once. const write = (sequence: number) => { - const group = track.createGroup(BigInt(sequence)); + const group = defined(track.createGroup(BigInt(sequence))); const timestamp = Duration.micros(sequence * 20_000); group.writeFrame({ payload: encodeFrame(new Uint8Array([1]), timestamp), @@ -419,7 +420,7 @@ test("a hole is waited for the wait while an arrived group plays up to the max d } })(); const write = (sequence: bigint, ms: number, finish = true) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: encodeFrame(new Uint8Array([1]), Duration.millis(ms)), timestamp: Time.Timestamp.fromMicros(ms * 1000), @@ -508,7 +509,7 @@ test.each([ } })(); const write = (sequence: bigint, millis: number) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: encodeFrame(new Uint8Array([1]), Duration.millis(millis)), timestamp: Time.Timestamp.fromMicros(millis * 1000), @@ -559,7 +560,7 @@ test("a hole ends once the playout clock jumps past the group past it", async () } })(); const write = (sequence: bigint, millis: number) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: encodeFrame(new Uint8Array([1]), Duration.millis(millis)), timestamp: Time.Timestamp.fromMicros(millis * 1000), diff --git a/js/hang/src/container/consumer.nonsequential.test.ts b/js/hang/src/container/consumer.nonsequential.test.ts index cce3350b1d0..687bef43271 100644 --- a/js/hang/src/container/consumer.nonsequential.test.ts +++ b/js/hang/src/container/consumer.nonsequential.test.ts @@ -5,6 +5,7 @@ import { type Group, Time, Track, Varint } from "@moq/net"; import { AudioConfigSchema } from "../catalog/audio.ts"; import { Consumer } from "./consumer.ts"; import { Format as LegacyFormat } from "./legacy.ts"; +import { defined } from "../defined.test-util.ts"; // Standalone from consumer.test.ts so it only pulls the Legacy format, not the CMAF decoder. @@ -64,7 +65,7 @@ test("Consumer waits on a non-sequential hang group because it has no per-frame }); // Group A at a large sequence, completed so the cursor advances past it. - const a = track.createGroup(1_000_000n); + const a = defined(track.createGroup(1_000_000n)); a.writeFrame({ payload: encodeLegacyFrame(0, new Uint8Array([0x01])), timestamp: Time.Timestamp.fromMicros(0), @@ -81,7 +82,7 @@ test("Consumer waits on a non-sequential hang group because it has no per-frame // Open group B at a large jump (+90_000, NOT +1) with a frame far past A's last PTS, and leave it // open. Legacy has no duration, so A's end is unknown -- B could be continuous, or group 1_000_001 // could still be coming. We cannot tell, so B must NOT surface yet. - const b = track.createGroup(1_090_000n); + const b = defined(track.createGroup(1_090_000n)); b.writeFrame({ payload: encodeLegacyFrame(1_000_000, new Uint8Array([0x02])), timestamp: Time.Timestamp.fromMicros(1_000_000), @@ -113,7 +114,7 @@ test("Consumer reads on without a gap past a group it skipped", async () => { } }; - const first = track.createGroup(0n); + const first = defined(track.createGroup(0n)); write(first, [0, 100_000, 200_000, 300_000, 400_000]); for (let i = 0; i < 5; i++) expect((await nextFrame(consumer))?.group).toBe(0n); // The first group finishes, read to its end but not yet passed, followed by an adjacent empty group @@ -121,9 +122,9 @@ test("Consumer reads on without a gap past a group it skipped", async () => { // frame, so the age skip passes the first group cleanly, then the empty one, which ends without a // frame and leaves only the skipped group's end to show the timeline goes on. first.finish(); - const empty = track.createGroup(1n); + const empty = defined(track.createGroup(1n)); await clock.advance(Duration.ZERO); - const last = track.createGroup(20n); + const last = defined(track.createGroup(20n)); write(last, [400_000, 1_000_000]); last.finish(); empty.finish(); @@ -155,7 +156,7 @@ test("Consumer reads one-packet Opus groups at sparse sequences back to back", a // never arrives. const packet = new Uint8Array([31 << 3, 0]); const publish = (start: number) => { - const group = track.createGroup(BigInt(start)); + const group = defined(track.createGroup(BigInt(start))); group.writeFrame({ payload: encodeLegacyFrame(start, packet), timestamp: Time.Timestamp.fromMicros(start) }); group.finish(); }; diff --git a/js/hang/src/container/consumer.ordered.test.ts b/js/hang/src/container/consumer.ordered.test.ts index 09c721befb1..1239a201912 100644 --- a/js/hang/src/container/consumer.ordered.test.ts +++ b/js/hang/src/container/consumer.ordered.test.ts @@ -7,6 +7,7 @@ import { Time, Track } from "@moq/net"; import { u53 } from "../catalog/integers.ts"; import { Consumer, type Read } from "./consumer.ts"; import { encodeFrame, Format } from "./legacy.ts"; +import { defined } from "../defined.test-util.ts"; const flush = () => new Promise((resolve) => setImmediate(resolve)); @@ -44,7 +45,7 @@ function setup(wait: number, opus = false) { })(); // One finished group holding a 20 ms frame at `ms`. const write = (sequence: bigint, ms: number) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: encodeFrame(opus ? OPUS : new Uint8Array([1]), Duration.millis(ms)), timestamp: Time.Timestamp.fromMillis(ms), @@ -104,7 +105,7 @@ test("a gap the reader reports before an empty group still reads as a gap before t.write(0n, 0); // Group 2 holds nothing. The hole at 1 ages from group 2's arrival, while group 2 ages from // group 3's later one, so the reader hands out the empty group 2 with the gap on it. - t.track.createGroup(2n).finish(); + defined(t.track.createGroup(2n)).finish(); await t.clock.advance(Duration.millis(90)); t.write(3n, 60); await t.clock.advance(Duration.millis(10)); @@ -159,7 +160,7 @@ test("a gap over keys that held no media is no loss", async () => { // Keyed by timestamp in microseconds, with the keys between never declared skipped. The group // past them opens before its frame lands, and the reader gives the keys up while it waits. t.write(0n, 0); - const group = t.track.createGroup(20_000n); + const group = defined(t.track.createGroup(20_000n)); await t.clock.advance(Duration.millis(100)); // A later group the reader hands out at once wakes the consumer before the frame says nothing // was missing. @@ -193,7 +194,7 @@ test("an open group that never delivers a frame is passed once the reader's wait try { t.write(0n, 0); // Opened, never written or finished. - t.track.createGroup(1n); + defined(t.track.createGroup(1n)); // Group 2 lands at 20 ms. The reader expires the open group a wait after its successor landed. for (let i = 2; i <= 6; i++) { await t.clock.advance(Duration.millis(20)); diff --git a/js/hang/src/container/consumer.outoforder.test.ts b/js/hang/src/container/consumer.outoforder.test.ts index e20ab70d2de..bc1cde7ff6f 100644 --- a/js/hang/src/container/consumer.outoforder.test.ts +++ b/js/hang/src/container/consumer.outoforder.test.ts @@ -4,6 +4,7 @@ import { Manual } from "@moq/clock/test"; import { type Group, Time, Track, Varint } from "@moq/net"; import { Consumer } from "./consumer.ts"; import { Format as LegacyFormat } from "./legacy.ts"; +import { defined } from "../defined.test-util.ts"; // Standalone from consumer.test.ts so it only pulls the Legacy format, not the CMAF decoder. @@ -54,7 +55,7 @@ function publishFrame(group: Group.Producer, millis: number, tag: number) { /** Publish one closed group carrying a single frame at `millis`. */ function publish(track: Track.Producer, sequence: bigint, millis: number) { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); publishFrame(group, millis, Number(sequence)); group.finish(); } @@ -124,9 +125,9 @@ test("a head group still downloading is not truncated", async () => { ); // The live edge group arrives first (still open), and the head after it, one frame at a time. - const live = track.createGroup(3n); + const live = defined(track.createGroup(3n)); publishFrame(live, 3000, 30); - const head = track.createGroup(1n); + const head = defined(track.createGroup(1n)); publishFrame(head, 1000, 10); const first = await nextFrame(consumer); expect(first?.group).toBe(1n); diff --git a/js/hang/src/container/consumer.skips.test.ts b/js/hang/src/container/consumer.skips.test.ts index b4bf2c25c93..4b1ef4b737f 100644 --- a/js/hang/src/container/consumer.skips.test.ts +++ b/js/hang/src/container/consumer.skips.test.ts @@ -4,6 +4,7 @@ import { Time, Track, Varint } from "@moq/net"; import { Signal } from "@moq/signals"; import { Consumer } from "./consumer.ts"; import { Format } from "./legacy.ts"; +import { defined } from "../defined.test-util.ts"; const flush = () => new Promise((resolve) => setImmediate(resolve)); @@ -17,7 +18,7 @@ for (const count of [1, 16, 256]) { delay, }); const write = (sequence: bigint, timestamp: number) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: Varint.encode(timestamp), timestamp: Time.Timestamp.now() }); return group; }; @@ -68,11 +69,11 @@ for (const open of [true, false]) { const frame = (micros: number) => ({ payload: Varint.encode(micros), timestamp: Time.Timestamp.now() }); try { for (let g = 0n; g < 5n; g++) { - const group = track.createGroup(g); + const group = defined(track.createGroup(g)); for (let f = 0; f < 10; f++) group.writeFrame(frame(Number(g) * 1_000_000 + f * 100_000)); group.finish(); } - const last = track.createGroup(5n); + const last = defined(track.createGroup(5n)); last.writeFrame(frame(5_000_000)); if (!open) last.finish(); while (consumer.buffered.peek().at(-1)?.end.asMillis() !== 5000) await consumer.buffered.changed(); @@ -117,14 +118,14 @@ test("a backlog start waits on a successor without frames", async () => { }; try { for (let g = 0n; g < 4n; g++) { - const group = track.createGroup(g); + const group = defined(track.createGroup(g)); for (const micros of frames(g)) group.writeFrame(frame(micros)); group.finish(); } - const fifth = track.createGroup(4n); + const fifth = defined(track.createGroup(4n)); // The fifth group's frames left before the sixth's, though they land after it. const sent = Time.Timestamp.now(); - const last = track.createGroup(5n); + const last = defined(track.createGroup(5n)); last.writeFrame(frame(5_000_000)); last.finish(); while (consumer.buffered.peek().at(-1)?.end.asMillis() !== 5000) await consumer.buffered.changed(); @@ -151,7 +152,7 @@ test("Consumer measures each skip's span over every group left, not just the new delay, }); const write = (sequence: bigint, timestamp: number) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: Varint.encode(timestamp), timestamp: Time.Timestamp.now() }); }; const buffered = async (timestamp: number) => { @@ -198,7 +199,7 @@ test("a blocking group is kept until its successor starts a budget behind the ne delay: { min: null, max: Duration.millis(150) }, }); const write = (sequence: bigint, timestamp: number) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: Varint.encode(timestamp), timestamp: Time.Timestamp.fromMicros(timestamp) }); return group; }; @@ -236,11 +237,11 @@ test("a blocking group ages out past an unstamped successor", async () => { delay: { max: Duration.millis(150) }, }); try { - const blocking = track.createGroup(0n); + const blocking = defined(track.createGroup(0n)); blocking.writeFrame({ payload: Varint.encode(0), timestamp: Time.Timestamp.fromMicros(0) }); expect(await consumer.next()).toMatchObject({ kind: "frame", group: 0n }); - track.createGroup(1n).finish(); - const later = track.createGroup(2n); + defined(track.createGroup(1n)).finish(); + const later = defined(track.createGroup(2n)); for (const timestamp of [1_000_000, 2_000_000]) later.writeFrame({ payload: Varint.encode(timestamp), timestamp: Time.Timestamp.fromMicros(timestamp) }); await flush(); diff --git a/js/hang/src/container/consumer.startup.test.ts b/js/hang/src/container/consumer.startup.test.ts index 024d1d8f5ba..091edb9d3d9 100644 --- a/js/hang/src/container/consumer.startup.test.ts +++ b/js/hang/src/container/consumer.startup.test.ts @@ -4,6 +4,7 @@ import { Manual } from "@moq/clock/test"; import { type Group, Error as NetError, StreamCode, Time, Track } from "@moq/net"; import { Consumer, type Read } from "./consumer.ts"; import { encodeFrame, Format } from "./legacy.ts"; +import { defined } from "../defined.test-util.ts"; function setup(maxDelay = 100) { const clock = new Manual(); @@ -65,10 +66,10 @@ for (const emptySuccessor of [false, true]) { `Consumer starts across a hole after an empty reset (empty successor: ${emptySuccessor}, maxDelay: %s)`, async (maxDelay) => { const { track, results, warn, flush } = setup(maxDelay); - const stale = track.createGroup(16n); + const stale = defined(track.createGroup(16n)); await flush(); if (emptySuccessor) { - const empty = track.createGroup(17n); + const empty = defined(track.createGroup(17n)); empty.finish(); await flush(); } @@ -77,7 +78,7 @@ for (const emptySuccessor of [false, true]) { expect(results).toEqual([]); const sequence = emptySuccessor ? 19n : 18n; - const live = track.createGroup(sequence); + const live = defined(track.createGroup(sequence)); for (let i = 0; i < 5; i++) write(live, 1_000_000 + i * 33_333); await flush(); @@ -95,13 +96,13 @@ for (const emptySuccessor of [false, true]) { test("Consumer preserves a declared marker before its first media across a hole", async () => { const { track, results, warn, flush } = setup(); - const marker = track.createGroup(16n); + const marker = defined(track.createGroup(16n)); write(marker, 0, true); marker.finish(); await flush(); expect(items(results)).toEqual(["end 16@0"]); - const live = track.createGroup(18n); + const live = defined(track.createGroup(18n)); write(live, 50_000); await flush(); // Group 17 never arrived, so the media after the marker is past a gap. It spans the declared @@ -113,28 +114,28 @@ test("Consumer preserves a declared marker before its first media across a hole" test.each([false, true])("Consumer still waits for a gap after media (playhead reset: %s)", async (reset) => { const { track, consumer, results, warn, flush } = setup(1000); - const first = track.createGroup(16n); + const first = defined(track.createGroup(16n)); write(first, 0); first.finish(); await flush(); expect(items(results)).toEqual(["16@0"]); if (reset) { - const marker = track.createGroup(17n); + const marker = defined(track.createGroup(17n)); write(marker, 0, true); marker.finish(); await flush(); expect(items(results)).toEqual(["16@0", "end 17@0"]); } const sequence = reset ? 20n : 19n; - const later = track.createGroup(sequence); + const later = defined(track.createGroup(sequence)); write(later, 50_000); await flush(); expect(consumer.buffered.peek().length).toBeGreaterThan(0); expect(frames(results)).toHaveLength(1); // Supply the missing, timestamp-contiguous bridge and prove the queued frame survives. - const bridge = track.createGroup(sequence - 1n); + const bridge = defined(track.createGroup(sequence - 1n)); write(bridge, 0); bridge.finish(); await flush(); diff --git a/js/hang/src/container/consumer.test.ts b/js/hang/src/container/consumer.test.ts index c89a62a1798..7b9836e4a66 100644 --- a/js/hang/src/container/consumer.test.ts +++ b/js/hang/src/container/consumer.test.ts @@ -10,6 +10,7 @@ import { Consumer, type Read } from "./consumer.ts"; import type { Format as ContainerFormat } from "./format.ts"; import { Format as LegacyFormat, Producer as LegacyProducer } from "./legacy.ts"; import type { Frame } from "./types.ts"; +import { defined } from "../defined.test-util.ts"; const FIXTURES = JSON.parse(readFileSync(new URL("../cmaf/fixtures.json", import.meta.url), "utf8")); function fragment(name: string): Uint8Array { @@ -547,7 +548,7 @@ function writeGroupWithLegacyFrames( timestamps: number[], stamp: (ts: number) => Time.Timestamp = (ts) => Time.Timestamp.fromMicros(ts), ) { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); for (const ts of timestamps) { group.writeFrame({ payload: encodeLegacy(ts), timestamp: stamp(ts) }); } @@ -555,7 +556,7 @@ function writeGroupWithLegacyFrames( } function writeMarkerGroup(track: Track.Producer, sequence: bigint, timestamp: number) { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: encodeLegacyFrame(timestamp, new Uint8Array()), timestamp: Time.Timestamp.fromMicros(timestamp), @@ -603,7 +604,7 @@ test("Consumer delivers frames from a single group, finished once it ends", asyn // The end is declared while the group below it is still arriving, and the track stays open // serving its cache: finished waits for the group, not for a release or for the reader. - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: encodeLegacy(0), timestamp: Time.Timestamp.fromMicros(0) }); track.finish(); expect(frameOf(await poll(consumer.next())).timestamp.asMicros()).toBe(0); @@ -625,7 +626,7 @@ test("Consumer delivers frames from a single group, finished once it ends", asyn format: new LegacyFormat("data"), delay: { max: Duration.millis(500) }, }); - other.createGroup(0n).writeFrame({ payload: encodeLegacy(0), timestamp: Time.Timestamp.fromMicros(0) }); + defined(other.createGroup(0n)).writeFrame({ payload: encodeLegacy(0), timestamp: Time.Timestamp.fromMicros(0) }); other.finish(); expect(frameOf(await poll(abandoned.next())).timestamp.asMicros()).toBe(0); abandoned.close(); @@ -666,7 +667,7 @@ test("Consumer index spans MoQ frames for keyframe detection", async () => { const track = new Track.Producer("test"); const consumer = new Consumer(replay(track), { format: multiFormat, delay: { max: Duration.millis(500) } }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: new Uint8Array([0x01]), timestamp: Time.Timestamp.now() }); // first MoQ frame → 3 samples group.writeFrame({ payload: new Uint8Array([0x02]), timestamp: Time.Timestamp.now() }); // second MoQ frame → 3 samples group.finish(); @@ -699,13 +700,13 @@ for (const [where, payloads] of [ const track = new Track.Producer("test"); const consumer = new Consumer(replay(track), { format: failingFormat, delay: { max: Duration.millis(500) } }); - const g0 = track.createGroup(0n); + const g0 = defined(track.createGroup(0n)); for (const byte of payloads) g0.writeFrame({ payload: new Uint8Array([byte]), timestamp: Time.Timestamp.fromMicros(0) }); g0.finish(); // A later group that decodes cleanly is never reached. - const g1 = track.createGroup(1n); + const g1 = defined(track.createGroup(1n)); g1.writeFrame({ payload: new Uint8Array([0x04]), timestamp: Time.Timestamp.fromMicros(1) }); g1.finish(); track.finish(); @@ -735,7 +736,7 @@ test("Consumer delivers everything ahead of a decode error", async () => { writeGroupWithLegacyFrames(track, 0n, [0]); writeGroupWithLegacyFrames(track, 2n, [100_000]); - const malformed = track.createGroup(3n); + const malformed = defined(track.createGroup(3n)); // A truncated timestamp varint. malformed.writeFrame({ payload: new Uint8Array([0x80]), timestamp: Time.Timestamp.fromMicros(200_000) }); malformed.finish(); @@ -763,7 +764,7 @@ test("Consumer keeps the first of several decode errors", async () => { const consumer = new Consumer(replay(track), { format: failingFormat, delay: { max: Duration.millis(500) } }); for (const sequence of [0n, 1n]) { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload: new Uint8Array([Number(sequence)]), timestamp: Time.Timestamp.fromMicros(Number(sequence)), @@ -796,10 +797,10 @@ test("Consumer releases its open groups when an error ends it", async () => { const track = new Track.Producer("test"); const consumer = new Consumer(replay(track), { format: failingFormat, delay: { max: Duration.millis(500) } }); - const malformed = track.createGroup(0n); + const malformed = defined(track.createGroup(0n)); malformed.writeFrame({ payload: new Uint8Array([0xff]), timestamp: Time.Timestamp.fromMicros(0) }); malformed.finish(); - const later = track.createGroup(1n); + const later = defined(track.createGroup(1n)); later.writeFrame({ payload: new Uint8Array([0x01]), timestamp: Time.Timestamp.fromMicros(1) }); await open; expect(later.demand().wanted.peek()).toBe(true); @@ -828,7 +829,7 @@ test("Consumer keeps frames decoded before a group reset (truncated GoP)", async const track = new Track.Producer("test"); const consumer = new Consumer(replay(track), { format, delay: { max: Duration.millis(500) } }); - const g0 = track.createGroup(0n); + const g0 = defined(track.createGroup(0n)); for (const timestamp of [1, 2]) { g0.writeFrame({ payload: encodeLegacyFrame(timestamp, new Uint8Array([1])), @@ -1092,7 +1093,7 @@ test("Consumer keeps a trailing duration marker internal", async () => { delay: { max: Duration.millis(500) }, }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: encodeLegacyFrame(0, new Uint8Array([0xde, 0xad])), timestamp: Time.Timestamp.now(), @@ -1122,7 +1123,7 @@ test("Consumer reads a leading marker as an end and keeps the first media keyfra delay: { max: Duration.millis(500) }, }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: encodeLegacyFrame(20_000, new Uint8Array()), timestamp: Time.Timestamp.now(), @@ -1255,7 +1256,7 @@ test("Consumer throws the first error in delivery order", async () => { }); writeGroupWithLegacyFrames(track, 0n, [10_000_000], wallClock); - const malformed = track.createGroup(1n); + const malformed = defined(track.createGroup(1n)); // A truncated timestamp varint. malformed.writeFrame({ payload: new Uint8Array([0x80]), timestamp: wallClock() }); malformed.finish(); @@ -1288,7 +1289,7 @@ test("Consumer checks a whole decoded batch before a skip drops its group", asyn }, }; const write = (sequence: bigint, timestamps: number[]) => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); // Transport stamps follow the sequence, so a lower group may land after a higher one. group.writeFrame({ payload: new TextEncoder().encode(JSON.stringify(timestamps)), @@ -1415,7 +1416,7 @@ test("Consumer reads no gap when retiring a group holding only its endpoint", as delay: { max: Duration.millis(150) }, }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: encodeLegacy(0), timestamp: Time.Timestamp.fromMicros(0) }); group.writeFrame({ payload: encodeLegacyFrame(33_000, new Uint8Array()), @@ -1443,7 +1444,7 @@ test("Consumer reads a gap when retiring a truncated group", async () => { delay: { max: Duration.millis(150) }, }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: encodeLegacy(0), timestamp: Time.Timestamp.fromMicros(0) }); await flush(); expect(frameOf(await consumer.next()).timestamp.asMicros()).toBe(0); @@ -1472,7 +1473,7 @@ test("Consumer reads a gap when retiring an open group", async () => { delay: { max: Duration.millis(150) }, }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: encodeLegacy(0), timestamp: Time.Timestamp.fromMicros(0) }); await flush(); expect(frameOf(await consumer.next()).timestamp.asMicros()).toBe(0); @@ -1560,7 +1561,7 @@ test("Consumer handles empty decode result without deadlock", async () => { const track = new Track.Producer("test"); const consumer = new Consumer(replay(track), { format: emptyThenValid, delay: { max: Duration.millis(500) } }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: new Uint8Array([0x01]), timestamp: Time.Timestamp.now() }); // empty decode group.writeFrame({ payload: new Uint8Array([0x02]), timestamp: Time.Timestamp.now() }); // valid decode group.finish(); @@ -1585,7 +1586,7 @@ test("Consumer preserves empty media from formats without endpoint markers", asy }; const track = new Track.Producer("test"); const consumer = new Consumer(track.subscribe(), { format, delay: { max: Duration.millis(500) } }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: new Uint8Array([1]), timestamp: Time.Timestamp.now() }); group.finish(); track.finish(); @@ -1604,7 +1605,7 @@ test("Consumer with CmafFormat delivers correct timestamps", async () => { delay: { max: Duration.millis(500) }, }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: fragment("key"), timestamp: at(0), @@ -1633,7 +1634,7 @@ test("Consumer with CmafFormat times an untimed track from tfdt", async () => { delay: { max: Duration.millis(500) }, }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload: fragment("untimedKey"), timestamp: Time.Timestamp.unscaled(0n) }); group.writeFrame({ payload: fragment("untimedDelta"), timestamp: Time.Timestamp.unscaled(0n) }); group.finish(); @@ -1676,11 +1677,11 @@ test("Consumer duration-skips a stalled group once it is covered", async () => { const consumer = new Consumer(replay(track), { format: durationFormat, delay: { max: Duration.millis(10_000) } }); // Group.Producer 0: one frame at ts=0 lasting 33ms, never closed (stalled). - const g0 = track.createGroup(0n); + const g0 = defined(track.createGroup(0n)); g0.writeFrame({ payload: new Uint8Array([0]), timestamp: Time.Timestamp.fromMicros(0) }); // Group.Producer 1: closed, starts exactly where group 0's frame ends. - const g1 = track.createGroup(1n); + const g1 = defined(track.createGroup(1n)); g1.writeFrame({ payload: new Uint8Array([33]), timestamp: Time.Timestamp.fromMicros(33_000) }); g1.finish(); @@ -1713,10 +1714,10 @@ test("Consumer does not duration-skip when the gap is not covered", async () => // Group.Producer 0 stays open and later receives a second frame; nothing covers the gap, // so that late frame must survive rather than being skipped. - const g0 = track.createGroup(0n); + const g0 = defined(track.createGroup(0n)); g0.writeFrame({ payload: new Uint8Array([0]), timestamp: Time.Timestamp.fromMicros(0) }); - const g1 = track.createGroup(1n); + const g1 = defined(track.createGroup(1n)); g1.writeFrame({ payload: new Uint8Array([33]), timestamp: Time.Timestamp.fromMicros(33_000) }); g1.finish(); @@ -1746,7 +1747,7 @@ test("Consumer delivers a PTS-contiguous next group whose sequence jumped (Legac }); // Group A (seq 1_000_000): one 3000-tick sample, so its content ends at 33_333µs (3000/90000 * 1e6). - const a = track.createGroup(1_000_000n); + const a = defined(track.createGroup(1_000_000n)); a.writeFrame({ payload: encodeLegacyFrame(Math.round((0 / TIMESCALE) * 1_000_000) as number, new Uint8Array([0x01])), timestamp: at(0), @@ -1761,7 +1762,7 @@ test("Consumer delivers a PTS-contiguous next group whose sequence jumped (Legac // A.end (33_333µs) -- the sub-millisecond skew a genuinely contiguous CMAF boundary shows because // per-sample durations and base-decode-times round to µs independently. It's within the contiguity // tolerance, so the timeline is unbroken and B must deliver immediately even while still open. - const b = track.createGroup(1_090_000n); + const b = defined(track.createGroup(1_090_000n)); b.writeFrame({ payload: encodeLegacyFrame(Math.round((3045 / TIMESCALE) * 1_000_000) as number, new Uint8Array([0x02])), timestamp: at(3045), @@ -1785,7 +1786,7 @@ test("Consumer waits on a PTS gap instead of skipping to a later buffered group }); // Group A (seq 1_000_000): content ends at 33_333µs. - const a = track.createGroup(1_000_000n); + const a = defined(track.createGroup(1_000_000n)); a.writeFrame({ payload: encodeLegacyFrame(Math.round((0 / TIMESCALE) * 1_000_000) as number, new Uint8Array([0x01])), timestamp: at(0), @@ -1798,7 +1799,7 @@ test("Consumer waits on a PTS gap instead of skipping to a later buffered group // Group C (seq 1_090_000) starts at 90_000 ticks (1_000_000µs) -- far past A.end (33_333µs), a real // gap. An intermediate group may still be in transit, so C must NOT be delivered yet. - const c = track.createGroup(1_090_000n); + const c = defined(track.createGroup(1_090_000n)); c.writeFrame({ payload: encodeLegacyFrame(Math.round((90_000 / TIMESCALE) * 1_000_000) as number, new Uint8Array([0x03])), timestamp: at(90_000), @@ -1810,7 +1811,7 @@ test("Consumer waits on a PTS gap instead of skipping to a later buffered group // The missing group B arrives, contiguous with A (first PTS 3000 ticks = 33_333µs = A.end); it // continues the timeline, so delivery resumes with B's frame. - const b = track.createGroup(1_045_000n); + const b = defined(track.createGroup(1_045_000n)); b.writeFrame({ payload: encodeLegacyFrame(Math.round((3000 / TIMESCALE) * 1_000_000) as number, new Uint8Array([0x02])), timestamp: at(3000), @@ -1834,7 +1835,7 @@ test("Consumer delivers a contiguous group after one that completed out of order }); // A (seq 1_000_000) stays open so it remains the active group. - const a = track.createGroup(1_000_000n); + const a = defined(track.createGroup(1_000_000n)); a.writeFrame(timedFrame(0x01, 0, 0)); expect(frameOf(await nextFrame(consumer)).payload).toEqual(new Uint8Array([0x01])); @@ -1845,7 +1846,7 @@ test("Consumer delivers a contiguous group after one that completed out of order // B (seq 1_045_000) starts at A's end and is CLOSED while A is still active, so B's own finally // block sees sequence !== #active and never records anything. B ends at 9000 ticks (100_000µs). - const b = track.createGroup(1_045_000n); + const b = defined(track.createGroup(1_045_000n)); b.writeFrame(timedFrame(0x03, 6000, 2)); b.finish(); await flush(); @@ -1856,7 +1857,7 @@ test("Consumer delivers a contiguous group after one that completed out of order // C (seq 1_090_000) starts at B's end, so it continues the timeline and must deliver. const pending = consumer.next(); - const c = track.createGroup(1_090_000n); + const c = defined(track.createGroup(1_090_000n)); c.writeFrame(timedFrame(0x04, 9000, 3)); const result = await poll(pending); @@ -1877,7 +1878,7 @@ test("Consumer plays the head once a waited-out gap exceeds the budget (Legacy)" }); // A (seq 1000): one frame, ends at 3000 ticks (33_333µs). - const a = track.createGroup(1000n); + const a = defined(track.createGroup(1000n)); a.writeFrame(timedFrame(0x01, 0, 0)); expect(frameOf(await nextFrame(consumer)).payload).toEqual(new Uint8Array([0x01])); a.finish(); @@ -1887,12 +1888,12 @@ test("Consumer plays the head once a waited-out gap exceeds the budget (Legacy)" // B (seq 2000) starts at 90_000 ticks (1_000_000µs), a second past A's end. The missing groups end // where B starts, so B alone proves nothing: one may hold media just before it. - const b = track.createGroup(2000n); + const b = defined(track.createGroup(2000n)); b.writeFrame(timedFrame(0x02, 90_000, 1)); expect(await poll(pending)).toBe("pending"); // C (seq 2001) carries on live 200ms past B's start, so anything missing below B is too old to play. - const c = track.createGroup(2001n); + const c = defined(track.createGroup(2001n)); c.writeFrame(timedFrame(0x03, 108_000, 2)); // The missing group's span was never delivered, so a gap from A's end to B comes first. @@ -1912,13 +1913,13 @@ test("Consumer waits on a gap within the budget, then plays the head once it exc }); // A (seq 1000): one frame, ends at 3000 ticks (33_333µs). - const a = track.createGroup(1000n); + const a = defined(track.createGroup(1000n)); a.writeFrame(timedFrame(0x01, 0, 0)); expect(frameOf(await nextFrame(consumer)).payload).toEqual(new Uint8Array([0x01])); a.finish(); // B (seq 2000) starts at 6000 ticks (66_667µs): a gap, but only 33ms past A's end. - const b = track.createGroup(2000n); + const b = defined(track.createGroup(2000n)); b.writeFrame(timedFrame(0x02, 6000, 1)); // Waited out until just short of the budget. @@ -1993,7 +1994,7 @@ test("Consumer empty groups mean nothing", async () => { }); writeGroupWithLegacyFrames(track, 0n, [0]); - const empty = track.createGroup(1n); + const empty = defined(track.createGroup(1n)); empty.finish(); writeGroupWithLegacyFrames(track, 2n, [1_000]); await flush(); @@ -2059,7 +2060,7 @@ test("Consumer reads a shed marker group as a gap", async () => { delay: { max: Duration.millis(0) }, }); - const group0 = track.createGroup(0n); + const group0 = defined(track.createGroup(0n)); group0.writeFrame({ payload: encodeLegacy(0), timestamp: Time.Timestamp.fromMicros(0), @@ -2091,14 +2092,14 @@ test("Consumer yields no gap across a PTS-contiguous group id jump (Legacy)", as delay: { max: Duration.millis(10_000) }, }); - const a = track.createGroup(1_000_000n); + const a = defined(track.createGroup(1_000_000n)); a.writeFrame(timedFrame(0x01, 0, 0)); a.finish(); expect(frameOf(await nextFrame(consumer)).payload).toEqual(new Uint8Array([0x01])); // Sequence jumps +90_000 but the first PTS meets A's end, so nothing is missing. - const b = track.createGroup(1_090_000n); + const b = defined(track.createGroup(1_090_000n)); b.writeFrame(timedFrame(0x02, 3000, 1)); expect(frameOf(await consumer.next()).payload).toEqual(new Uint8Array([0x02])); diff --git a/js/hang/src/container/consumer.warmup.test.ts b/js/hang/src/container/consumer.warmup.test.ts index 5436cc9eb50..cdc9738aa99 100644 --- a/js/hang/src/container/consumer.warmup.test.ts +++ b/js/hang/src/container/consumer.warmup.test.ts @@ -4,6 +4,7 @@ import { Manual } from "@moq/clock/test"; import { type Group, Time, Track } from "@moq/net"; import { Consumer, type Read } from "./consumer.ts"; import { encodeFrame, Format } from "./legacy.ts"; +import { defined } from "../defined.test-util.ts"; const BUDGET = 500; @@ -61,7 +62,7 @@ function write(group: Group.Producer, timestamp: number) { } function group(track: Track.Producer, sequence: bigint, timestamps: number[]): Group.Producer { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); for (const timestamp of timestamps) write(group, timestamp); return group; } diff --git a/js/json/src/snapshot/snapshot.test.ts b/js/json/src/snapshot/snapshot.test.ts index 02b5dba6b82..81a2121dde2 100644 --- a/js/json/src/snapshot/snapshot.test.ts +++ b/js/json/src/snapshot/snapshot.test.ts @@ -222,6 +222,7 @@ test("reads skip a group the subscription still owes", async () => { const next = new Consumer({ track }); const put = (sequence: bigint) => { const group = track.createGroup(sequence); + if (!group) throw new Error(`group ${sequence} is already held`); group.writeFrame({ payload: new TextEncoder().encode(`{"n":${sequence}}`), timestamp: Time.Timestamp.unscaled(sequence), diff --git a/js/net/bench/drift.ts b/js/net/bench/drift.ts index 639c21c5e89..9db1427db29 100644 --- a/js/net/bench/drift.ts +++ b/js/net/bench/drift.ts @@ -3,6 +3,7 @@ import { Duration } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { type Group, Time, Track } from "@moq/net"; import { hooks } from "../src/internal.ts"; +import { defined } from "../src/defined.test-util.ts"; /** Read live frames after a retained window, checking every delivered payload. */ export async function run(): Promise { @@ -87,7 +88,7 @@ export async function run(): Promise { } // A frameless candidate beyond one owed group keeps the ordered // cursor parked while frames advance its presentation edge. - track.createGroup(BigInt(retained + 2)); + defined(track.createGroup(BigInt(retained + 2))); waiting.push(...ordered); } let start = 0; diff --git a/js/net/bench/fill-probe.ts b/js/net/bench/fill-probe.ts index ceae737024e..d51e9c44ba5 100644 --- a/js/net/bench/fill-probe.ts +++ b/js/net/bench/fill-probe.ts @@ -16,7 +16,7 @@ for (const runs of [250, 1000, 4000, 16000]) { const track = defined(broadcast.createTrack("video", { maxAge: null })); // 2 and 3 are read up front, so the only gaps any fill is asked for are the drops below. for (const sequence of [2n, 3n]) { - const live = track.createGroup(sequence); + const live = defined(track.createGroup(sequence)); live.writeFrame({ payload: new Uint8Array([0]), timestamp: Timestamp.unscaled(live.start) }); live.finish(); } @@ -44,7 +44,7 @@ for (const runs of [250, 1000, 4000, 16000]) { const sequence = BigInt(4 + 2 * i); hooks.dropTrackGroups(track, sequence, sequence + 1n, staleHole(60_000)); for (const sub of subs) sub.tryRecvGroup(); - const group = track.createGroup(sequence + 1n); + const group = defined(track.createGroup(sequence + 1n)); group.writeFrame({ payload: new Uint8Array([0]), timestamp: Timestamp.unscaled(group.start) }); group.finish(); for (const sub of subs) { diff --git a/js/net/bench/replay.ts b/js/net/bench/replay.ts index baad13569ee..ac4c93b8656 100644 --- a/js/net/bench/replay.ts +++ b/js/net/bench/replay.ts @@ -2,6 +2,7 @@ import { Duration } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { Time, Track } from "@moq/net"; +import { defined } from "../src/defined.test-util.ts"; type Order = "monotonic" | "reverse" | "mixed"; const ORDERS: Order[] = ["monotonic", "reverse", "mixed"]; @@ -30,7 +31,7 @@ function arrivals(count: number, order: Order): number[] { // Write one finished group whose payload names its sequence, so delivery can be checked. function publish(track: Track.Producer, sequence: number): void { - const group = track.createGroup(BigInt(sequence)); + const group = defined(track.createGroup(BigInt(sequence))); const payload = new Uint8Array(PAYLOAD); new DataView(payload.buffer).setUint32(0, sequence); group.writeFrame({ payload, timestamp: Time.Timestamp.unscaled(group.start) }); diff --git a/js/net/bench/resume.ts b/js/net/bench/resume.ts index c5f8411bd57..a89466925a7 100644 --- a/js/net/bench/resume.ts +++ b/js/net/bench/resume.ts @@ -50,7 +50,7 @@ async function measure(readers: number, swaps: number | undefined, fork = false) const track = defined(broadcast.createTrack("seq")); // Every route's copy holds the same groups under the same sequences. const write = () => { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame({ payload, timestamp: Timestamp.unscaled(group.start) }); group.finish(); }; diff --git a/js/net/bench/subscribe-drop.ts b/js/net/bench/subscribe-drop.ts index 31c8af53c0d..96fb5920550 100644 --- a/js/net/bench/subscribe-drop.ts +++ b/js/net/bench/subscribe-drop.ts @@ -28,7 +28,7 @@ try { const broadcast = broadcastRoute.broadcast; const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); for (let sequence = 0n; sequence < BigInt(groups); sequence++) { - const group = track.createGroup(sequence); + const group = defined(track.createGroup(sequence)); group.writeFrame(textFrame("frame")); group.finish(); } diff --git a/js/net/bench/track.ts b/js/net/bench/track.ts index bcfabf27c67..bebc8e13ef8 100644 --- a/js/net/bench/track.ts +++ b/js/net/bench/track.ts @@ -6,6 +6,7 @@ import type { Consumer as GroupConsumer, Producer as GroupProducer } from "../sr import { Timescale, Timestamp } from "../src/time.ts"; import { Producer, type Subscriber } from "../src/track.ts"; import { GivenUp } from "../src/util/given_up.ts"; +import { defined } from "../src/defined.test-util.ts"; const retainedCounts = [25, 100, 400, 1500]; const subscriberCounts = [1, 4, 16]; @@ -61,7 +62,7 @@ async function measure( // Inserted by sequence, the way the wire hands a subscribed track its groups. const publish = (close: boolean) => { clock += held > 0 ? 1 : DEFAULT_EXPIRY.asMillis() / retained; - const group = producer.createGroup(BigInt(sequence)); + const group = defined(producer.createGroup(BigInt(sequence))); group.writeFrame({ payload, timestamp: Timestamp.fromMillis(sequence++) }); if (close) group.finish(); return group; diff --git a/js/net/src/broadcast.test.ts b/js/net/src/broadcast.test.ts index cd000bdeb16..c3b90680682 100644 --- a/js/net/src/broadcast.test.ts +++ b/js/net/src/broadcast.test.ts @@ -68,7 +68,7 @@ test("a staged track resolves its subscribers at commit, with what was written", const staged = hooks.stageRequest(request, { timescale: Timescale.MILLI }); // The staged track has no timescale until commit, so the group is created at its key. - const group = staged.producer.createGroup(0n); + const group = defined(staged.producer.createGroup(0n)); group.writeFrame(textFrame("hello", Timestamp.fromMillis(0))); group.finish(); const pending = Symbol("pending"); @@ -90,7 +90,7 @@ test("a replacement producer starts over", async () => { const firstRequest = await firstPull; if (!firstRequest) throw new Error("expected first request"); const first = firstRequest.accept({ timescale: Timescale.MILLI }); - const group = first.createGroup(8n); + const group = defined(first.createGroup(8n)); group.writeFrame(textFrame("a", Timestamp.fromMillis(1000))); group.finish(); firstSubscriber.close(); diff --git a/js/net/src/cache.test.ts b/js/net/src/cache.test.ts index 09527874c9f..6eea6e2d09b 100644 --- a/js/net/src/cache.test.ts +++ b/js/net/src/cache.test.ts @@ -7,6 +7,7 @@ import { hooks, staleHole } from "./internal.ts"; import { groupsOf } from "./mock.ts"; import { Timestamp } from "./time.ts"; import { Producer as TrackProducer } from "./track.ts"; +import { defined } from "./defined.test-util.ts"; // Run `fn` on a manual clock, stepped in milliseconds. async function withClock(fn: (clock: { advance: (ms: number) => Promise }) => Promise | void) { @@ -138,7 +139,7 @@ test("a kept local skip expires once the edge passes it or the track closes", as expect(dropsHeld(closed)).toEqual([0n]); // The write's own expiry scan finds the skip. - passed.createGroup(10n).finish(); + defined(passed.createGroup(10n)).finish(); expect(dropsHeld(passed)).toEqual([]); closed.close(); @@ -152,8 +153,8 @@ test("a kept local skip expires once the edge passes it or the track closes", as test("a final drop leaves a finished group", async () => { const producer = pooled(new cache.Pool()); hooks.receiveTrack(producer); - producer.createGroup(0n).finish(); - const open = producer.createGroup(1n); + defined(producer.createGroup(0n)).finish(); + const open = defined(producer.createGroup(1n)); hooks.dropTrackGroups(producer, 0n, 2n, { error: new StreamError(StreamCode.Cancel) }); expect(dropsHeld(producer)).toEqual([1n]); @@ -170,9 +171,9 @@ test("a forgotten stale run is asked of a fill", async () => { const producer = pooled(pool); hooks.receiveTrack(producer); const requests = producer.requests(); - producer.createGroup(0n).finish(); + defined(producer.createGroup(0n)).finish(); hooks.dropTrackGroups(producer, 1n, 3n, staleHole(500)); - producer.createGroup(3n).finish(); + defined(producer.createGroup(3n)).finish(); await clock.advance(2_000); const reader = producer.subscribe({ @@ -245,7 +246,7 @@ test("a reached end outlives its forgotten skip", async () => { const pool = new cache.Pool({ expiry: Duration.millis(1_000) }); const producer = pooled(pool); hooks.receiveTrack(producer); - producer.createGroup(0n).finish(); + defined(producer.createGroup(0n)).finish(); hooks.skipTrackGroups(producer, 1n, 3n); hooks.endTrack(producer, { group: 3n, frame: 0 }); const done = (reader: ReturnType) => { diff --git a/js/net/src/fill.test.ts b/js/net/src/fill.test.ts index 75e115cd760..1c66c725527 100644 --- a/js/net/src/fill.test.ts +++ b/js/net/src/fill.test.ts @@ -74,7 +74,7 @@ async function drain(reader: { recvGroup(): Promise } function resumed(first: bigint): { broadcast: BroadcastProducer; track: Producer } { const broadcast = new BroadcastProducer(); const track = defined(broadcast.createTrack("video", { maxAge: null })); - const group = track.createGroup(first); + const group = defined(track.createGroup(first)); group.writeFrame({ payload: enc.encode(`live ${first}`), timestamp: Timestamp.unscaled(group.start) }); group.finish(); return { broadcast, track }; @@ -136,7 +136,7 @@ test("fill: a fetch of a group about to be written asks the handler at once, and expect(fill.wanted()).toBe(7n); // The producer gets there before the handler answers: the live write is the answer. - const group = track.createGroup(7n); + const group = defined(track.createGroup(7n)); group.writeFrame({ payload: enc.encode("written"), timestamp: Timestamp.unscaled(group.start) }); group.finish(); expect(fill.wanted()).toBeUndefined(); @@ -412,8 +412,8 @@ test("fill: a gap below a group that fails after a probe is asked", async () => const requests = track.requests(); const reader = track.subscribe({ ranges: [{ start: { time: 0n } }], delay: { max: Duration.millis(0) } }); const ordered = reader.ordered(); - const failed = track.createGroup(2n); - const group = track.createGroup(4n); + const failed = defined(track.createGroup(2n)); + const group = defined(track.createGroup(4n)); group.writeFrame({ payload: enc.encode("live 4"), timestamp: Timestamp.unscaled(group.start) }); failed.abort(new StreamError(StreamCode.Cancel)); await yieldNow(); @@ -439,7 +439,7 @@ test("fill: a gap the newest group rises over after a probe is asked", async () const reader = track.subscribe({ ranges: [{ start: { time: 2n } }], delay: { max: null } }); expect(reader.tryRecvGroup()?.start).toBe(2n); expect(reader.tryRecvGroup()).toBeUndefined(); - const group = track.createGroup(5n); + const group = defined(track.createGroup(5n)); group.writeFrame({ payload: enc.encode("live 5"), timestamp: Timestamp.unscaled(group.start) }); group.finish(); expect(reader.tryRecvGroup()?.start).toBe(5n); @@ -463,7 +463,7 @@ test("fill: a miss judged with no handler open is asked once one opens", async ( const out = await requestedGroups(first); expect(out && [out.start, out.end]).toEqual([0n, 2n]); first.close(); - const group = track.createGroup(5n); + const group = defined(track.createGroup(5n)); group.finish(); expect(reader.tryRecvGroup()?.start).toBe(5n); reader.tryRecvGroup(); @@ -591,7 +591,7 @@ test("fill: a group arriving after a refusal reaches the reader the refusal name if (fill?.kind !== "groups") throw new Error("no fill of groups"); fill.refuseGroups(2n, 3n, new StreamError(StreamCode.Cancel, { message: "storage busy" })); // Before the waiting fetch looks again. - const group = track.createGroup(2n); + const group = defined(track.createGroup(2n)); group.writeFrame({ payload: enc.encode("late"), timestamp: Timestamp.unscaled(group.start) }); group.finish(); fill.close(); @@ -658,7 +658,7 @@ test("fill: a stale verdict leaves an outstanding fill owed", async () => { const broadcast = new BroadcastProducer(); const track = defined(broadcast.createTrack("video", { maxAge: null })); const requests = track.requests(); - track.createGroup(3n).finish(); + defined(track.createGroup(3n)).finish(); const fetching = wireOf(broadcast).fetchGroup("video", 2n); const fill = await requestedGroups(requests); if (fill?.kind !== "groups") throw new Error("no fill of groups"); @@ -680,14 +680,14 @@ test("fill: a group arriving live answers the fill", async () => { const broadcast = new BroadcastProducer(); const track = defined(broadcast.createTrack("video", { maxAge: null })); const requests = track.requests(); - const late = track.createGroup(3n); + const late = defined(track.createGroup(3n)); late.finish(); const fetching = wireOf(broadcast).fetchGroup("video", 1n); const fill = await requestedGroups(requests); if (fill?.kind !== "groups") throw new Error("no fill of groups"); // The producer writes it itself before the handler gets to it. - const live = track.createGroup(1n); + const live = defined(track.createGroup(1n)); live.writeFrame({ payload: enc.encode("live"), timestamp: Timestamp.unscaled(live.start) }); live.finish(); expect(fill.wanted()).toBeUndefined(); @@ -800,7 +800,7 @@ test("fill: a bounded reader keeps waiting on a fresh fill once an older one goe const broadcast = new BroadcastProducer(); const track = defined(broadcast.createTrack("video", { maxAge: null })); const write = (key: bigint) => { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); group.writeFrame({ payload: enc.encode(`live ${key}`), timestamp: Timestamp.unscaled(group.start), @@ -1221,7 +1221,7 @@ test("fill: a cache-miss fetch of a dynamic track serves the one track the broad if (!request) throw new Error("no track request"); const track = request.accept({ maxAge: null }); const requests = track.requests(); - const group = track.createGroup(4n); + const group = defined(track.createGroup(4n)); group.finish(); const fill = await requestedGroups(requests); @@ -1256,7 +1256,7 @@ async function session(alpn: string) { const broadcast = publication.broadcast; const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); // Groups 0 to 2 were published before this producer existed. - const live = track.createGroup(3n); + const live = defined(track.createGroup(3n)); live.writeFrame({ payload: enc.encode("live 3"), timestamp: Timestamp.fromMillis(3000) }); live.finish(); const requests = track.requests(); @@ -1350,7 +1350,7 @@ test("fill: a lite-07 ranged subscription reads history the publisher never cach test("fill: an OLD answer under the max age is held as stale until forgotten", async () => { const broadcast = new BroadcastProducer(); const track = defined(broadcast.createTrack("video", { maxAge: Duration.millis(10_000) })); - const live = track.createGroup(3n); + const live = defined(track.createGroup(3n)); live.writeFrame({ payload: enc.encode("live 3"), timestamp: Timestamp.unscaled(live.start) }); live.finish(); const requests = track.requests(); @@ -1411,7 +1411,7 @@ function headless(): { broadcast: BroadcastProducer; track: Producer } { for (const frame of ["c3", "c4"]) tail.writeFrame({ payload: enc.encode(frame), timestamp: Timestamp.unscaled(2n) }); tail.finish(); - const next = track.createGroup(3n); + const next = defined(track.createGroup(3n)); next.writeFrame({ payload: enc.encode("d0"), timestamp: Timestamp.unscaled(3n) }); next.finish(); return { broadcast, track }; @@ -1571,7 +1571,7 @@ test("fill: a fetch of a headless group asks its head, as a fetch from frame 0 d function timed(): { broadcast: BroadcastProducer; track: Producer } { const broadcast = new BroadcastProducer(); const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); - const group = track.createGroup(5n); + const group = defined(track.createGroup(5n)); group.writeFrame({ payload: enc.encode("g5"), timestamp: Timestamp.fromMillis(5) }); group.finish(); return { broadcast, track }; @@ -1643,14 +1643,14 @@ test("fill: a lookup answered below the eviction watermark starts the range ther const requests = track.requests(); const times = lookups(requests, (ms) => ms); for (let n = 0n; n < 3n; n++) { - const group = track.createGroup(n); + const group = defined(track.createGroup(n)); group.writeFrame({ payload: enc.encode(`g${n}`), timestamp: Timestamp.fromMillis(Number(n)) }); group.finish(); } // Idle past the cache window, so the next write evicts every group but the new edge: the // answer and the fills below it land at or below the watermark, unverified. clock.jump(Duration.millis(DEFAULT_EXPIRY.asMillis() + 1000)); - const edge = track.createGroup(5n); + const edge = defined(track.createGroup(5n)); edge.writeFrame({ payload: enc.encode("g5"), timestamp: Timestamp.fromMillis(5) }); edge.finish(); diff --git a/js/net/src/flate/group.test.ts b/js/net/src/flate/group.test.ts index 7d573d345bd..ce0f5603853 100644 --- a/js/net/src/flate/group.test.ts +++ b/js/net/src/flate/group.test.ts @@ -7,6 +7,7 @@ import { Producer as Track } from "../track.ts"; import { Decoder } from "./decoder.ts"; import { Encoder } from "./encoder.ts"; import { encodable } from "./group.ts"; +import { defined } from "../defined.test-util.ts"; const payload = new TextEncoder().encode("one shared compression window ".repeat(100)); @@ -99,7 +100,7 @@ for (const readPlain of [false, true]) { test("empty frames preserve the window", async () => { const track = new Track("compressed").accept({ compression: "deflate" }); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame({ payload, timestamp: Timestamp.unscaled(group.start) }); group.writeFrame({ payload: new Uint8Array(), timestamp: Timestamp.unscaled(group.start) }); const reader = group.mirror(); diff --git a/js/net/src/group-id.test.ts b/js/net/src/group-id.test.ts index be3bb30dd46..1a60ec12908 100644 --- a/js/net/src/group-id.test.ts +++ b/js/net/src/group-id.test.ts @@ -66,7 +66,7 @@ async function forward(input: BroadcastConsumer, carriesDatagrams: boolean): Pro const video = defined(copy.createTrack("video", await subscription.info())); void (async () => { for (let group = await subscription.recvGroup(); group; group = await subscription.recvGroup()) { - const out = video.createGroup(group.start); + const out = defined(video.createGroup(group.start)); for (let frame = await group.readFrame(); frame; frame = await group.readFrame()) out.writeFrame(frame); out.finish(); } @@ -110,7 +110,7 @@ for (const wire of WIRES) { while (!demand.wanted.peek()) await demand.wanted.changed(); for (const key of [PAST_SAFE, MAX_QUIC]) { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); group.writeFrame({ payload: enc.encode(`first ${key}`), timestamp: Timestamp.unscaled(group.start), @@ -157,9 +157,9 @@ for (const wire of WIRES) { test("a group sequence that is not a non-negative bigint is refused where a caller passes one", async () => { const track = defined(new BroadcastProducer().createTrack("video")); // A plain JS caller can still pass a number, which would otherwise mix with bigints later. - expect(() => track.createGroup(1 as unknown as bigint)).toThrow(TypeError); - expect(() => track.createGroup(-1n)).toThrow(RangeError); - expect(track.createGroup(MAX_QUIC).start).toBe(MAX_QUIC); + expect(() => defined(track.createGroup(1 as unknown as bigint))).toThrow(TypeError); + expect(() => defined(track.createGroup(-1n))).toThrow(RangeError); + expect(defined(track.createGroup(MAX_QUIC)).start).toBe(MAX_QUIC); const consumer = new BroadcastProducer().consume().track("video"); await expect(consumer.fetchGroup(1 as unknown as bigint)).rejects.toThrow(TypeError); }); diff --git a/js/net/src/group.test.ts b/js/net/src/group.test.ts index 7e080608e93..09ab7958cce 100644 --- a/js/net/src/group.test.ts +++ b/js/net/src/group.test.ts @@ -9,6 +9,7 @@ import { hooks, type Replacement } from "./internal.ts"; import { textFrame } from "./mock.ts"; import { Timestamp } from "./time.ts"; import { Producer as TrackProducer } from "./track.ts"; +import { defined } from "./defined.test-util.ts"; const dec = new TextDecoder(); @@ -138,7 +139,7 @@ test("a group read late keeps the instant it joined, alone, on a track, or resum const alone = new Producer(0n); const track = new TrackProducer("test"); const subscriber = track.subscribe(); - const live = track.createGroup(0n); + const live = defined(track.createGroup(0n)); live.writeFrame(textFrame("a")); clock.jump(Duration.millis(1000)); diff --git a/js/net/src/ietf/join.test.ts b/js/net/src/ietf/join.test.ts index d29fed1cba6..9cb657d4e48 100644 --- a/js/net/src/ietf/join.test.ts +++ b/js/net/src/ietf/join.test.ts @@ -558,7 +558,7 @@ for (const version of VERSIONS) { test("a clean end finishes a head nothing claimed", () => { const t = new Tail(); const j = new Join(0n, t); - const producer = new track.Producer("catalog").createGroup(0n); + const producer = defined(new track.Producer("catalog").createGroup(0n)); expect(j.open(() => producer)).toBe(producer); producer.writeFrame({ payload: text("c"), timestamp: Timestamp.unscaled(producer.start) }); j.wrote(); @@ -671,9 +671,9 @@ test("an evicted joined group is fetched again as standalone history", async () test("a second fetch stream after the track ended leaves the first head to its own stream", () => { const j = new Join(0n, new Tail()); j.end(); - const first = new track.Producer("catalog").createGroup(0n); + const first = defined(new track.Producer("catalog").createGroup(0n)); expect(j.open(() => first)).toBe(first); - const second = new track.Producer("catalog").createGroup(0n); + const second = defined(new track.Producer("catalog").createGroup(0n)); expect(j.open(() => second)).toBeUndefined(); // The second stream, discarding, ends first: the head is still the first stream's. j.finish(undefined); @@ -685,9 +685,9 @@ test("a second fetch stream after the track ended leaves the first head to its o test("a discarding second fetch stream leaves a head being written alone", () => { const j = new Join(0n, new Tail()); - const first = new track.Producer("catalog").createGroup(0n); + const first = defined(new track.Producer("catalog").createGroup(0n)); expect(j.open(() => first)).toBe(first); - expect(j.open(() => new track.Producer("catalog").createGroup(0n))).toBeUndefined(); + expect(j.open(() => defined(new track.Producer("catalog").createGroup(0n)))).toBeUndefined(); j.fail(new Error("reset"), undefined); expect(first.closed.peek()).toBeUndefined(); expect(j.pending).toBe(false); diff --git a/js/net/src/ietf/publisher.test.ts b/js/net/src/ietf/publisher.test.ts index e27a2c6f2a5..875637405a4 100644 --- a/js/net/src/ietf/publisher.test.ts +++ b/js/net/src/ietf/publisher.test.ts @@ -243,7 +243,7 @@ test("TRACK_STATUS is answered on every draft without subscribing", async () => priority: 2, }), ); - const group = track.createGroup(4n); + const group = defined(track.createGroup(4n)); group.writeFrame({ payload: new Uint8Array([1]), timestamp: Timestamp.fromMillis(0) }); group.writeFrame({ payload: new Uint8Array([2]), timestamp: Timestamp.fromMillis(1) }); const subscribed = spyOn(track, "subscribe"); @@ -881,19 +881,19 @@ test("a blocked group header is reset when the group expires", async () => { server, ); - const old = track.createGroup(0n); + const old = defined(track.createGroup(0n)); old.writeFrame({ payload: new TextEncoder().encode("old"), timestamp: Timestamp.fromMillis(0) }); old.finish(); await headerStarted; - const edge = track.createGroup(1n); + const edge = defined(track.createGroup(1n)); edge.writeFrame({ payload: new TextEncoder().encode("edge"), timestamp: Timestamp.fromMillis(10_000) }); edge.finish(); // A group beyond the edge, so group 0's reach (10s, where group 1 begins) is // provably past the budget. A group is bounded by where its successor starts, so // the successor alone never convicts it: nothing yet proves group 0 ends sooner. - const later = track.createGroup(2n); + const later = defined(track.createGroup(2n)); later.writeFrame({ payload: new TextEncoder().encode("later"), timestamp: Timestamp.fromMillis(20_000) }); later.finish(); @@ -960,7 +960,7 @@ test("a group stream whose FIN never completes is reset when the group expires", ); const write = (key: bigint) => { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); group.writeFrame({ payload: new TextEncoder().encode("frame"), timestamp: Timestamp.fromMillis(Number(key)), @@ -1047,7 +1047,7 @@ test("a group stream whose FIN never completes is reset after the cache evicts i // Timestamps a millisecond apart, so only the wall clock since group 1 arrived convicts group 0. const write = (key: bigint) => { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); group.writeFrame({ payload: new TextEncoder().encode("frame"), timestamp: Timestamp.fromMillis(Number(key)), @@ -1137,7 +1137,7 @@ test("a group that goes stale while its stream opens writes nothing", async () = ); const write = (key: bigint, ms: number) => { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); group.writeFrame({ payload: new TextEncoder().encode("frame"), timestamp: Timestamp.fromMillis(ms) }); group.finish(); }; @@ -2838,7 +2838,7 @@ test.each(["ascending", "descending"] as const)("draft-22: a wider fill is refus // live group supersedes it, racing this test's read of the refused fill. const track = defined(fx.broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); for (const key of [0n, 3n, 9n]) { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); for (let i = 0; i < 2; i++) group.writeFrame({ payload: new TextEncoder().encode(`${key}.${i}`), @@ -2914,7 +2914,7 @@ async function subscribeOkLargest(version: IetfVersion): Promise track.createGroup(join.key)); + producer = join.open(() => created(track.createGroup(join.key), join.key)); if (!producer) { discarding = true; if (!object.payload) await skipPayload(stream, object.size); @@ -2408,3 +2408,9 @@ class ConsumeBroadcast extends broadcast.Consumer { return new ConsumeBroadcast(this.shareState()); } } + +// A stream for a group the copy already holds is refused: the model has one producer per group. +function created(group: netGroup.Producer | undefined, key: bigint): netGroup.Producer { + if (group === undefined) throw new Error(`duplicate group: key=${key}`); + return group; +} diff --git a/js/net/src/integration.test.ts b/js/net/src/integration.test.ts index c0ef48e1dcc..2b359910c91 100644 --- a/js/net/src/integration.test.ts +++ b/js/net/src/integration.test.ts @@ -589,7 +589,7 @@ test("integration: lite-07 keeps a covered bounded subscription open", async () const broadcast = publish(origin, Path.from("test")); const producer = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); - for (const key of [0n, 1n, 2n, 4n, 5n]) producer.createGroup(key).finish(); + for (const key of [0n, 1n, 2n, 4n, 5n]) defined(producer.createGroup(key)).finish(); const remote = wireOf(client).consume(Path.from("test")); const bounded = (end: bigint) => @@ -643,7 +643,7 @@ test("integration: lite-07 serves a time range", async () => { const producer = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); // Keyed by start, as the wire names a group: one per second. for (let start = 0n; start < 10_000n; start += 1000n) { - const group = producer.createGroup(start); + const group = defined(producer.createGroup(start)); group.writeFrame(textFrame(`${start}`, Timestamp.fromMillis(Number(start)))); group.finish(); } @@ -1041,7 +1041,7 @@ test.each(["gap", "end"])("integration: lite fetch rejects coalesced misses at % let serving: Promise | undefined; if (missing === "gap") { const producer = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI })); - const group = producer.createGroup(1n); + const group = defined(producer.createGroup(1n)); group.finish(); } else { serving = (async () => { @@ -3150,16 +3150,16 @@ for (const alpn of [Lite.ALPN_06, Lite.ALPN_07_WIP]) { // Unfinished, so its stream holds the only credit. // Each group stamped in sequence order, since the track checks a late group's start. const at = (key: bigint) => Timestamp.fromMillis(1_000 + Number(key)); - const held = producer.createGroup(2n); + const held = defined(producer.createGroup(2n)); held.writeFrame(textFrame("held", at(2n))); expect((await settled(subscriber.recvGroup(), "the held group"))?.start).toBe(2n); // Late and below the held stream: it waits for credit it cannot make room for. - const late = producer.createGroup(0n); + const late = defined(producer.createGroup(0n)); late.writeFrame(textFrame("late", at(0n))); late.finish(); - const newer = producer.createGroup(3n); + const newer = defined(producer.createGroup(3n)); newer.writeFrame(textFrame("new", at(3n))); newer.finish(); // lite-07 may fill the late group by a fetch first; only group 3 must not wait behind it. diff --git a/js/net/src/lite/copy_fill.test.ts b/js/net/src/lite/copy_fill.test.ts index 8f5f69f0c47..67a6c7fa839 100644 --- a/js/net/src/lite/copy_fill.test.ts +++ b/js/net/src/lite/copy_fill.test.ts @@ -71,7 +71,7 @@ async function peers(alpn: string) { } // Group `sequence` presents at `sequence` seconds, with its origin in its payload. -function write(group: ReturnType, key: bigint, kind: string): void { +function write(group: NonNullable>, key: bigint, kind: string): void { group.writeFrame({ payload: enc.encode(`${kind} ${key}`), timestamp: Timestamp.fromMillis(Number(key) * 1000), @@ -114,7 +114,7 @@ const NARROW: Subscription = { delay: { max: Duration.millis(500) } }; const WIDE: Subscription = { delay: { max: null }, order: "ascending" }; function populate(track: Producer): void { - for (let key = 0n; key < 5n; key++) write(track.createGroup(key), key, "live"); + for (let key = 0n; key < 5n; key++) write(defined(track.createGroup(key)), key, "live"); } // What `take` read, in sequence order. @@ -205,7 +205,7 @@ test.each([Lite.ALPN_05, Lite.ALPN_06, Lite.ALPN_07_WIP])( order: "ascending", }; const first = peer.remote.track("video").subscribe(history); - for (let key = 0n; key < 4n; key++) write(peer.track.createGroup(key), key, "live"); + for (let key = 0n; key < 4n; key++) write(defined(peer.track.createGroup(key)), key, "live"); // Before lite-07 a subscription carries no order and is served newest first, so only // the set of groups is fixed. expect(sorted(await take(first, 4)).map(([key]) => key)).toEqual([0n, 1n, 2n, 3n]); @@ -213,7 +213,7 @@ test.each([Lite.ALPN_05, Lite.ALPN_06, Lite.ALPN_07_WIP])( // Both caches age out what nobody touched, a prune slice past the window; only the // live edge stays. await clock.advance(DEFAULT_EXPIRY.add(Duration.millis(10_000))); - write(peer.track.createGroup(4n), 4n, "live"); + write(defined(peer.track.createGroup(4n)), 4n, "live"); expect((await first.recvGroup())?.start).toBe(4n); const before = peer.fetches(); @@ -252,7 +252,7 @@ test("copy fill: a filled group stops downloading once every reader left or pass ]); const publication = origin.route(Path.from("room")); const track = defined(publication.broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); - write(track.createGroup(1n), 1n, "live"); + write(defined(track.createGroup(1n)), 1n, "live"); // The archive answers group 0 with one frame and keeps it open. const requests = track.requests(); const fills: FillGroups[] = []; @@ -319,7 +319,7 @@ test("copy fill: a filled group nobody holds any more stops downloading", async ]); const publication = origin.route(Path.from("room")); const track = defined(publication.broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); - write(track.createGroup(1n), 1n, "live"); + write(defined(track.createGroup(1n)), 1n, "live"); // The archive answers group 0 with one frame and never finishes it. const requests = track.requests(); const fills: FillGroups[] = []; @@ -353,7 +353,7 @@ test("copy fill: a filled group nobody holds any more stops downloading", async // source loses its last reader. group?.close(); history.close(); - write(track.createGroup(2n), 2n, "live"); + write(defined(track.createGroup(2n)), 2n, "live"); expect((await live.nextGroup())?.start).toBe(2n); await clock.drive( timeout( @@ -390,7 +390,7 @@ test("copy fill: a group reset to make room ends", async () => { ]); const publication = origin.route(Path.from("room")); const track = defined(publication.broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); - write(track.createGroup(2n), 2n, "live"); + write(defined(track.createGroup(2n)), 2n, "live"); // The archive answers group 0 with one frame and keeps it open, so its stream is still open, and // group 1 whole. const requests = track.requests(); @@ -493,7 +493,7 @@ test.each([Lite.ALPN_05, Lite.ALPN_06, Lite.ALPN_07_WIP])( ]); const broadcast = origin.route(Path.from("room")).broadcast; const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); - write(track.createGroup(3n), 3n, "live"); + write(defined(track.createGroup(3n)), 3n, "live"); // The archive has group 2 once `archived`, and never refuses it as lost. let archived = false; const requests = track.requests(); diff --git a/js/net/src/lite/drop_record.test.ts b/js/net/src/lite/drop_record.test.ts index d7e079e0abb..893f582814a 100644 --- a/js/net/src/lite/drop_record.test.ts +++ b/js/net/src/lite/drop_record.test.ts @@ -151,7 +151,7 @@ async function chain(up: Version, down: Version) { remote, /** Write group `sequence` presenting at `millis`, with `size` bytes of payload. */ write(key: bigint, millis: number, size = 1) { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); group.writeFrame({ payload: new Uint8Array(size), timestamp: Timestamp.fromMillis(millis) }); group.finish(); }, diff --git a/js/net/src/lite/fills.test.ts b/js/net/src/lite/fills.test.ts index 3f947721c5d..9fb2b8c6886 100644 --- a/js/net/src/lite/fills.test.ts +++ b/js/net/src/lite/fills.test.ts @@ -20,7 +20,7 @@ const enc = new TextEncoder(); async function missing(): Promise<{ broadcast: BroadcastProducer; track: Producer; fill: FillGroups; close(): void }> { const broadcast = new BroadcastProducer(); const track = defined(broadcast.createTrack("video", { maxAge: null })); - const group = track.createGroup(4n); + const group = defined(track.createGroup(4n)); group.writeFrame({ payload: enc.encode("live 4"), timestamp: Timestamp.unscaled(group.start) }); group.finish(); const requests = track.requests(); diff --git a/js/net/src/lite/publisher.test.ts b/js/net/src/lite/publisher.test.ts index 7912e4b62c4..e8ef6700e3a 100644 --- a/js/net/src/lite/publisher.test.ts +++ b/js/net/src/lite/publisher.test.ts @@ -222,7 +222,7 @@ async function subscribeEnd( // Finish the track only once it's being served, so the publisher observes a live // track ending rather than resolving a subscribe against an already-closed one. for (const key of keys) { - const group = track.createGroup(BigInt(key)); + const group = defined(track.createGroup(BigInt(key))); group.writeFrame(textFrame("hello", Timestamp.fromMillis(key))); group.finish(); @@ -311,7 +311,7 @@ async function groupSendOrders(options: { while (track.subscription.peek()?.priority !== update) await track.subscription.changed(); } - const group = track.createGroup(BigInt(key)); + const group = defined(track.createGroup(BigInt(key))); groups.push(group); group.writeFrame(textFrame("hello", Timestamp.fromMillis(Number(key)))); @@ -394,7 +394,7 @@ test("lite draft-05: a subscribe update re-ranks a group already on the wire", a void publisher.runSubscribe(msg, server); // Leave the group open, so its stream is still being served when the update lands. - const group = track.createGroup(4n); + const group = defined(track.createGroup(4n)); group.writeFrame(textFrame("hello")); const opened = pair.client.incomingUnidirectionalStreams.getReader(); @@ -455,7 +455,7 @@ test("lite draft-05: a subscribe update during the stream open still ranks the g }); void publisher.runSubscribe(msg, server); - const group = track.createGroup(4n); + const group = defined(track.createGroup(4n)); group.writeFrame(textFrame("hello")); try { @@ -508,7 +508,7 @@ test("lite draft-05: many concurrent groups share one subscription listener", as try { for (let key = 0n; key < BigInt(count); key++) { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); groups.push(group); group.writeFrame(textFrame("hello", Timestamp.fromMillis(Number(key)))); await servingNextGroup(opened); @@ -542,7 +542,7 @@ test("lite draft-05: the fetch response ranks the publisher's own writes", async const broadcast = publish(origin, Path.from("test")); const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI })); - const group = track.createGroup(7n); + const group = defined(track.createGroup(7n)); group.writeFrame(textFrame("hello")); group.finish(); @@ -621,7 +621,7 @@ test("lite draft-06: an unchecked track's fetched frames carry their own timesta const broadcast = publish(origin, Path.from("test")); const track = defined(broadcast.createTrack("video", { timescale: Timescale.MICRO, unchecked: true })); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame(textFrame("hello", Timestamp.fromMillis(36_000_000))); group.finish(); @@ -746,7 +746,7 @@ async function servedSubscription( let track = options.pending ? undefined : defined(broadcast.createTrack("video", info)); for (const key of options.prefill ?? []) { if (!track) throw new Error("a pending track holds nothing to prefill"); - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); for (const frame of frames) group.writeFrame(textFrame(frame, Timestamp.fromMillis(Number(key)))); group.finish(); } @@ -812,7 +812,7 @@ async function servedSubscription( const staged = hooks.stageRequest(pulled, info); if (reported !== undefined) hooks.reportedGroup(staged.producer, reported); for (const key of held) { - const group = staged.producer.createGroup(key); + const group = defined(staged.producer.createGroup(key)); for (const frame of frames) group.writeFrame(textFrame(frame, Timestamp.fromMillis(Number(key)))); group.finish(); } @@ -820,7 +820,7 @@ async function servedSubscription( }, // Stamped by sequence, so a group served out of order still starts in order. serve(key: bigint) { - const group = resolved().createGroup(key); + const group = defined(resolved().createGroup(key)); for (const frame of frames) group.writeFrame(textFrame(frame, Timestamp.fromMillis(Number(key)))); group.finish(); }, @@ -952,7 +952,7 @@ test.each([ ])("$name drops a group reset to make room", async ({ version }) => { const sub = await servedSubscription({ version, startGroup: 0n }); try { - const group = sub.track.createGroup(0n); + const group = defined(sub.track.createGroup(0n)); group.writeFrame(textFrame("a", Timestamp.fromMillis(0))); expect(await sub.servedHeader()).toBe(0n); expect("start" in (await decodeSubscribeResponse(sub.client.reader, version))).toBe(true); @@ -1102,7 +1102,7 @@ test("lite draft-06: a cut group is dropped early, once", async () => { expect(await sub.servedSequence()).toBe(0n); expect("start" in (await decodeSubscribeResponse(sub.client.reader, Version.DRAFT_06))).toBe(true); - const cut = sub.track.createGroup(1n); + const cut = defined(sub.track.createGroup(1n)); cut.abort(new Error("cut")); const resp = await decodeSubscribeResponse(sub.client.reader, Version.DRAFT_06); if (!("drop" in resp)) throw new Error("expected SUBSCRIBE_DROP"); @@ -1128,7 +1128,7 @@ for (const version of [Version.DRAFT_06, Version.DRAFT_07]) { expect(await sub.servedSequence()).toBe(0n); expect("start" in (await decodeSubscribeResponse(sub.client.reader, version))).toBe(true); - const cut = sub.track.createGroup(1n); + const cut = defined(sub.track.createGroup(1n)); cut.abort(new StreamError(StreamCode(70), { message: "cut" })); const resp = await decodeSubscribeResponse(sub.client.reader, version); if (!("drop" in resp)) throw new Error("expected SUBSCRIBE_DROP"); @@ -1148,7 +1148,7 @@ for (const version of [Version.DRAFT_06, Version.DRAFT_07]) { const sub = await servedSubscription({ version, startGroup: 0n }); try { // Left open, so only the stop ends its stream. - const group = sub.track.createGroup(0n); + const group = defined(sub.track.createGroup(0n)); group.writeFrame(textFrame("hello", Timestamp.fromMillis(0))); await sub.stopServed(StreamCode.Evicted); for (;;) { @@ -1304,7 +1304,7 @@ async function holesToFinish(reader: Reader, count = Number.POSITIVE_INFINITY): test("lite-07 ends a finished group with GROUP_END and a closed one with a bare FIN", async () => { const sub = await servedSubscription({ version: Version.DRAFT_07, startGroup: 0n }); try { - const whole = sub.track.createGroup(0n); + const whole = defined(sub.track.createGroup(0n)); whole.writeFrame(textFrame("x", Timestamp.fromMillis(0))); whole.finishAt(500n); expect(await sub.servedGroup()).toMatchObject({ key: 0n, payloads: ["x"], end: 500n }); @@ -1343,7 +1343,7 @@ test("lite-07 sends a passed-over skip ahead of a drop of the group above it", a sub.serve(0n); expect(await sub.servedSequence()).toBe(0n); // Left open, so only the stop ends its stream. - const above = sub.track.createGroup(3n); + const above = defined(sub.track.createGroup(3n)); above.writeFrame(textFrame("hello", Timestamp.fromMillis(3))); sub.track.skipGroups(1n, 3n); await sub.stopServed(StreamCode.Cancel); @@ -1391,7 +1391,7 @@ test("lite draft-06: a reported cut stays dropped when re-created", async () => expect(await sub.servedSequence()).toBe(0n); expect("start" in (await decodeSubscribeResponse(sub.client.reader, Version.DRAFT_06))).toBe(true); - const cut = sub.track.createGroup(1n); + const cut = defined(sub.track.createGroup(1n)); cut.abort(new Error("cut")); const resp = await decodeSubscribeResponse(sub.client.reader, Version.DRAFT_06); if (!("drop" in resp)) throw new Error("expected SUBSCRIBE_DROP"); @@ -1498,7 +1498,7 @@ test.each([ void sub.stall().then((reason) => { reset = reason; }); - if (arriving) sub.track.createGroup(1n).writeFrame(textFrame("hello", Timestamp.fromMillis(1))); + if (arriving) defined(sub.track.createGroup(1n)).writeFrame(textFrame("hello", Timestamp.fromMillis(1))); else sub.serve(1n); expect(await sub.servedHeader()).toBe(1n); await flush(); @@ -1546,7 +1546,7 @@ test("lite draft-07: a stream expiring mid-frame resets at once", async () => { void sub.stall().then((reason) => { reset = reason; }); - const group = sub.track.createGroup(1n); + const group = defined(sub.track.createGroup(1n)); const frame = group.createFrame({ size: 10, timestamp: Timestamp.fromMillis(1) }); frame.write(new Uint8Array(5)); expect(await sub.servedHeader()).toBe(1n); @@ -1779,7 +1779,7 @@ for (const skipped of ["failed", "stale"] as const) { try { hooks.receiveTrack(sub.track); hooks.startTrack(sub.track, { start: 5n, requested: 5n }); - const group = sub.track.createGroup(5n); + const group = defined(sub.track.createGroup(5n)); group.writeFrame(textFrame("old", Timestamp.fromMillis(5))); if (skipped === "failed") group.abort(new Error("cut")); else group.finish(); @@ -2368,7 +2368,7 @@ test("lite draft-07: subscribe end precedes groups below a declared finish", asy ); try { - const first = track.createGroup(0n); + const first = defined(track.createGroup(0n)); first.writeFrame(textFrame("hello", Timestamp.fromMillis(0))); first.finish(); track.finishAt({ group: 2n, frame: 0 }); @@ -2379,7 +2379,7 @@ test("lite draft-07: subscribe end precedes groups below a declared finish", asy const early = await pending; expect("finish" in early).toBe(true); - const second = track.createGroup(1n); + const second = defined(track.createGroup(1n)); second.writeFrame(textFrame("hello", Timestamp.fromMillis(1))); second.finish(); track.finish(); @@ -2413,7 +2413,7 @@ test("lite draft-06: an errored end is not declared early", async () => { ); try { - const first = track.createGroup(0n); + const first = defined(track.createGroup(0n)); first.writeFrame(textFrame("hello", Timestamp.fromMillis(0))); first.finish(); // An errored end past the live edge, which only a received copy forwards: group 1 is still @@ -2425,7 +2425,7 @@ test("lite draft-06: an errored end is not declared early", async () => { const pending = decodeSubscribeResponse(client.reader, Version.DRAFT_06); expect(await settlesWithin(pending, clock, Duration.millis(20))).toBe(false); - const second = track.createGroup(1n); + const second = defined(track.createGroup(1n)); second.writeFrame(textFrame("hello", Timestamp.fromMillis(1))); second.finish(); await expect(pending).rejects.toBeDefined(); @@ -2479,7 +2479,7 @@ async function heldOpenEnd() { server, ); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame(textFrame("hello")); group.finish(); track.finish(); @@ -2561,7 +2561,7 @@ test("lite draft-07: a group whose close fails is dropped", async () => { ); try { - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame(textFrame("hello")); group.finish(); track.finish(); @@ -2611,7 +2611,7 @@ test("blocked DROP responses stop opening later groups", async () => { await write(chunk); }); const append = (key: number) => { - const group = track.createGroup(BigInt(key)); + const group = defined(track.createGroup(BigInt(key))); group.writeFrame(textFrame("frame", Timestamp.fromMillis(key))); group.finish(); }; @@ -2694,7 +2694,7 @@ async function serve( const start = received[Number(key)]; const group = start === undefined - ? track.createGroup(BigInt(key)) + ? defined(track.createGroup(BigInt(key))) : hooks.receiveGroup(track, { start: BigInt(key), offset: start }); for (const frame of frames) group.writeFrame(textFrame(frame, Timestamp.fromMillis(Number(key)))); group.finish(); @@ -2878,7 +2878,7 @@ async function saturatedGroup() { void publisher.runSubscribe(msg, server); // A finished group still has frames to send, so its own close must not drop it. - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame(textFrame("hello")); group.finish(); @@ -2957,12 +2957,12 @@ test("lite draft-05: a blocked group header is reset when the group expires", as server, ); - const old = track.createGroup(0n); + const old = defined(track.createGroup(0n)); old.writeFrame({ payload: new TextEncoder().encode("old"), timestamp: Timestamp.fromMillis(0) }); old.finish(); await headerStarted; - const edge = track.createGroup(1n); + const edge = defined(track.createGroup(1n)); edge.writeFrame({ payload: new TextEncoder().encode("edge"), timestamp: Timestamp.fromMillis(1000) }); edge.finish(); @@ -3078,7 +3078,7 @@ test("lite draft-05: a group parked at its tail resets as too old when it expire if (!server) throw new Error("publisher never accepted the subscribe stream"); const opened = pair.client.incomingUnidirectionalStreams.getReader(); // Left open: its producer never finishes it. - const open = track.createGroup(0n); + const open = defined(track.createGroup(0n)); try { void publisher.runSubscribe( @@ -3097,7 +3097,7 @@ test("lite draft-05: a group parked at its tail resets as too old when it expire // The track runs a second past group 0's successor while group 0 waits for more. for (const ms of [1000, 2000]) { - const group = track.createGroup(BigInt(ms / 1000)); + const group = defined(track.createGroup(BigInt(ms / 1000))); group.writeFrame(frame(ms)); group.finish(); } @@ -3162,7 +3162,7 @@ test("lite draft-05: a group that goes stale while its stream opens writes nothi ); const write = (key: bigint, ms: number) => { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); group.writeFrame({ payload: new TextEncoder().encode("frame"), timestamp: Timestamp.fromMillis(ms) }); group.finish(); }; @@ -3442,7 +3442,7 @@ test("lite draft-06: a grant that shrinks mid-fetch resets the fetch", async () const broadcast = publish(origin, Path.from("live")); const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI })); // Left open, so the fetch is still serving when the grant shrinks. - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame(textFrame("first")); const client = await Stream.open(pair.client, { version: Version.DRAFT_06 }); @@ -3479,7 +3479,7 @@ test("lite draft-07: a fetch whose budget gives up partway resets as too old", a const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI })); const frame = (ms: number) => ({ payload: new TextEncoder().encode("x"), timestamp: Timestamp.fromMillis(ms) }); // Left open, so the fetch is still serving when the track runs on. - const open = track.createGroup(0n); + const open = defined(track.createGroup(0n)); open.writeFrame(frame(0)); const client = await Stream.open(pair.client, { version: Version.DRAFT_07 }); @@ -3499,7 +3499,7 @@ test("lite draft-07: a fetch whose budget gives up partway resets as too old", a // The first frame is on the wire before the track runs a second past its successor. await client.reader.u8(); for (const ms of [1000, 2000]) { - const group = track.createGroup(BigInt(ms / 1000)); + const group = defined(track.createGroup(BigInt(ms / 1000))); group.writeFrame(frame(ms)); group.finish(); } @@ -3525,7 +3525,7 @@ test("lite draft-07: a fetch sent whole resets as too old when it goes stale una const broadcast = publish(origin, Path.from("live")); const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); const frame = (ms: number) => ({ payload: new TextEncoder().encode("x"), timestamp: Timestamp.fromMillis(ms) }); - const whole = track.createGroup(0n); + const whole = defined(track.createGroup(0n)); whole.writeFrame(frame(0)); whole.finish(); @@ -3568,7 +3568,7 @@ test("lite draft-07: a fetch sent whole resets as too old when it goes stale una // Then the track runs a second past its successor, with the FIN still unacknowledged. for (const ms of [1000, 2000]) { - const group = track.createGroup(BigInt(ms / 1000)); + const group = defined(track.createGroup(BigInt(ms / 1000))); group.writeFrame(frame(ms)); group.finish(); } @@ -3592,7 +3592,7 @@ test("lite draft-07: a relayed fetch sent whole resets as too old when it goes s const broadcast = publish(source, Path.from("live")); const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); const frame = (ms: number) => ({ payload: new TextEncoder().encode("x"), timestamp: Timestamp.fromMillis(ms) }); - const whole = track.createGroup(0n); + const whole = defined(track.createGroup(0n)); whole.writeFrame(frame(0)); whole.finish(); const url = new URL("https://localhost:4443/test"); @@ -3647,7 +3647,7 @@ test("lite draft-07: a relayed fetch sent whole resets as too old when it goes s // Then the track runs a second past its successor upstream, with the FIN still unacknowledged. for (const ms of [1000, 2000]) { - const group = track.createGroup(BigInt(ms / 1000)); + const group = defined(track.createGroup(BigInt(ms / 1000))); group.writeFrame(frame(ms)); group.finish(); } @@ -3675,7 +3675,7 @@ test.each([0, 1])("lite draft-07 reports the cached largest position when starti const publisher = new Publisher(pair.server, version, randomHop(), origin.consume()); const broadcast = publish(origin, Path.from("quiet")); const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI })); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame(textFrame("cached")); group.finish(); const client = await Stream.open(pair.client, { version }); @@ -3723,7 +3723,7 @@ test.each([false, true])( const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI })); // The source answered with group 4 as its largest; only group 0 has landed. hooks.reportedLargest(track, { group: 4n, frame: 0 }, ended); - const group = track.createGroup(0n); + const group = defined(track.createGroup(0n)); group.writeFrame(textFrame("oldest")); group.finish(); const client = await Stream.open(pair.client, { version }); diff --git a/js/net/src/lite/subscriber.test.ts b/js/net/src/lite/subscriber.test.ts index b4012c01a12..95928a8868e 100644 --- a/js/net/src/lite/subscriber.test.ts +++ b/js/net/src/lite/subscriber.test.ts @@ -63,6 +63,7 @@ import { import { Minted, Subscriber } from "./subscriber.ts"; import { Track, TrackInfo } from "./track.ts"; import { hasLengthFirst, Version, versionName } from "./version.ts"; +import { defined } from "../defined.test-util.ts"; test("closing the subscriber suppresses probe stream warnings", async () => { let readable!: ReadableStreamDefaultController; @@ -3057,7 +3058,7 @@ test("a skip or final drop replaces an earlier stale one on lite-07", async () = expect(entry.tail.covers(1n, 3n)).toBe(true); expect(entry.tail.covers(4n, 5n)).toBe(true); // Still skipped after the update. - expect(() => entry?.track.createGroup(1n)).toThrow(Skipped); + expect(() => defined(entry?.track.createGroup(1n))).toThrow(Skipped); } finally { responses.mockRestore(); track.close(); @@ -3106,7 +3107,7 @@ test("a skip replaces a final drop but not a cached group on lite-07", async () { drop: new SubscribeDrop({ start: 1n, end: 3n, error: StreamCode.NotFound }) }, ]); if (!entry) throw new Error("no subscription"); - entry.track.createGroup(5n).finish(); + defined(entry.track.createGroup(5n)).finish(); await send([ { skip: new SubscribeSkip({ start: 1n, end: 3n }) }, @@ -3115,8 +3116,8 @@ test("a skip replaces a final drop but not a cached group on lite-07", async () // Group 5 arrived, so the skip names only 4 and 6. { skip: new SubscribeSkip({ start: 4n, end: 7n }) }, ]); - expect(() => entry?.track.createGroup(1n)).toThrow(Skipped); - expect(() => entry?.track.createGroup(2n)).toThrow(Skipped); + expect(() => defined(entry?.track.createGroup(1n))).toThrow(Skipped); + expect(() => defined(entry?.track.createGroup(2n))).toThrow(Skipped); expect(entry.tail.covers(4n, 7n)).toBe(true); expect(warn).toHaveBeenCalledTimes(1); diff --git a/js/net/src/lite/widened_max_age.test.ts b/js/net/src/lite/widened_max_age.test.ts index 57e0b37deec..ab07c1d4612 100644 --- a/js/net/src/lite/widened_max_age.test.ts +++ b/js/net/src/lite/widened_max_age.test.ts @@ -76,7 +76,7 @@ for (const [version, alpn] of [ const broadcast = publication.broadcast; const producer = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); const write = (key: number, millis: number) => { - const group = producer.createGroup(BigInt(key)); + const group = defined(producer.createGroup(BigInt(key))); group.writeFrame({ payload: new Uint8Array([key]), timestamp: Timestamp.fromMillis(millis) }); group.finish(); }; @@ -126,7 +126,7 @@ test("a widening recovers the stale groups for a bounded lite-07 reader", async const broadcast = publication.broadcast; const producer = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); const write = (key: number, millis: number) => { - const group = producer.createGroup(BigInt(key)); + const group = defined(producer.createGroup(BigInt(key))); group.writeFrame({ payload: new Uint8Array([key]), timestamp: Timestamp.fromMillis(millis) }); group.finish(); }; diff --git a/js/net/src/net-cleanups.test.ts b/js/net/src/net-cleanups.test.ts index f3172f883ae..cd6d3ff2b6f 100644 --- a/js/net/src/net-cleanups.test.ts +++ b/js/net/src/net-cleanups.test.ts @@ -10,6 +10,7 @@ import { ALPN_03, ALPN_04, Version } from "./lite/version.ts"; import { createMockTransportPair } from "./mock.ts"; import { Timestamp } from "./time.ts"; import { Producer as TrackProducer } from "./track.ts"; +import { defined } from "./defined.test-util.ts"; test("group read handles independently replay buffered and future frames", async () => { const group = new GroupProducer(0n); @@ -41,7 +42,7 @@ test("group read handles independently replay buffered and future frames", async test.each(["group", "track"] as const)("%s JSON rejects an empty frame without treating it as EOF", async (kind) => { const producer = new TrackProducer("json"); const subscriber = kind === "track" ? producer.subscribe().ordered() : undefined; - const group = kind === "track" ? producer.createGroup(0n) : new GroupProducer(0n); + const group = kind === "track" ? defined(producer.createGroup(0n)) : new GroupProducer(0n); const reader = subscriber ?? group.consume(); group.writeFrame({ payload: new Uint8Array(), timestamp: Timestamp.unscaled(group.start) }); for (const value of [null, false, 0, ""]) diff --git a/js/net/src/ordered.test.ts b/js/net/src/ordered.test.ts index b29bdcf5b2f..41899056591 100644 --- a/js/net/src/ordered.test.ts +++ b/js/net/src/ordered.test.ts @@ -8,6 +8,7 @@ import { hooks, staleHole } from "./internal.ts"; import { textFrame } from "./mock.ts"; import { Timestamp } from "./time.ts"; import { type Ordered, Producer as TrackProducer } from "./track.ts"; +import { defined } from "./defined.test-util.ts"; // A session-fed copy owes holes; an in-process producer does not. function receivedTrack() { @@ -18,7 +19,7 @@ function receivedTrack() { // A finished one-frame group, presenting at its key in milliseconds on a timed track. function put(producer: TrackProducer, key: bigint, timed = true) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.writeFrame(textFrame("x", timed ? Timestamp.fromMillis(Number(key)) : Timestamp.unscaled(key))); group.finish(); } @@ -71,7 +72,7 @@ test("an ordered read reports what it gives up, in key order, but no skip", () = expect(items(ordered)).toEqual(["group 0", "gap 1..3 (delivery timeout)", "group 3", "group 6"]); // A group handed out and then dropped is never reported again. - const cut = producer.createGroup(7n); + const cut = defined(producer.createGroup(7n)); const read = ordered.tryNextItem(); expect(read?.group?.start).toBe(7n); drop(producer, 7n, 8n); diff --git a/js/net/src/origin.test.ts b/js/net/src/origin.test.ts index 21242ebcc5a..703e1b0e314 100644 --- a/js/net/src/origin.test.ts +++ b/js/net/src/origin.test.ts @@ -73,11 +73,11 @@ for (const via of ["direct", "request", "follow"] as const) { const consumed = request ? request.active.peek() : broadcast.consume(); if (!consumed) throw new Error("expected a broadcast"); const sub = consumed.track("video").subscribe(); - const history = track.createGroup(0n); + const history = defined(track.createGroup(0n)); history.writeFrame({ payload: new Uint8Array([1]), timestamp: Timestamp.unscaled(history.start) }); history.finish(); const finished = await sub.recvGroup(); - const live = track.createGroup(1n); + const live = defined(track.createGroup(1n)); live.writeFrame({ payload: new Uint8Array([2]), timestamp: Timestamp.unscaled(live.start) }); const group = await sub.recvGroup(); if (!finished || !group) throw new Error("expected both groups"); @@ -2857,7 +2857,7 @@ test("demand held across an instance change asks again, unless it named the old const track = defined(next.createTrack("video")); (await it.next()).value.serve(next); const subscription = (await unpinned)?.track("video").subscribe(); - track.createGroup(7n); + defined(track.createGroup(7n)); expect((await subscription?.recvGroup())?.start).toBe(7n); subscription?.close(); @@ -2905,7 +2905,7 @@ test("demand held across an instance round trip still asks again", async () => { const track = defined(next.createTrack("video")); (await it.next()).value.serve(next); const subscription = (await demanded)?.track("video").subscribe(); - track.createGroup(7n); + defined(track.createGroup(7n)); expect((await subscription?.recvGroup())?.start).toBe(7n); subscription?.close(); @@ -3075,7 +3075,7 @@ test.each([ expect(fresh.active.peek()?.instance).toBe(to); const subscription = fresh.active.peek()?.track("video").subscribe(); const forwarded = (await demanded)?.track("video").subscribe(); - nextTrack.createGroup(7n); + defined(nextTrack.createGroup(7n)); expect((await subscription?.recvGroup())?.start).toBe(7n); expect((await forwarded?.recvGroup())?.start).toBe(7n); @@ -3170,7 +3170,7 @@ test("a session's re-request after an instance update asks the handler again", a const track = defined(next.createTrack("video")); (await requests.next()).value.serve(next); const subscription = (await after)?.track("video").subscribe(); - track.createGroup(7n); + defined(track.createGroup(7n)); expect((await subscription?.recvGroup())?.start).toBe(7n); subscription?.close(); @@ -3208,7 +3208,7 @@ test("an update does not override route selection: another claim at the instance expect(held.active.peek()?.instance).toBe(INSTANCE); expect(fresh.active.peek()?.instance).toBe(INSTANCE); const subscription = fresh.active.peek()?.track("video").subscribe(); - track.createGroup(7n); + defined(track.createGroup(7n)); expect((await subscription?.recvGroup())?.start).toBe(7n); subscription?.close(); diff --git a/js/net/src/parked-expiry.test.ts b/js/net/src/parked-expiry.test.ts index 6784edfd285..95c9e6b0c34 100644 --- a/js/net/src/parked-expiry.test.ts +++ b/js/net/src/parked-expiry.test.ts @@ -40,7 +40,7 @@ for (const protocol of protocols) { const maxAge = protocol.kind === "ietf" && mode === "expires" ? Duration.millis(budget) : null; const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge })); const write = (key: bigint) => { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); group.writeFrame({ payload: new Uint8Array([1]), timestamp: Timestamp.fromMillis(Number(key)) }); group.finish(); }; @@ -160,7 +160,7 @@ for (const protocol of protocols) { // closes the stream of a group gone stale instead of resetting it. const track = defined(broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null })); const write = (key: bigint, frames: number) => { - const group = track.createGroup(key); + const group = defined(track.createGroup(key)); for (let frame = 0; frame < frames; frame++) { group.writeFrame({ payload: new Uint8Array([frame]), diff --git a/js/net/src/resume.model.test.ts b/js/net/src/resume.model.test.ts index 12a67e8f69b..ac524b454cf 100644 --- a/js/net/src/resume.model.test.ts +++ b/js/net/src/resume.model.test.ts @@ -490,7 +490,7 @@ class Model { } if (entry.written === 0 && !entry.writer) { try { - entry.writer = copy.track.createGroup(BigInt(group)); + entry.writer = defined(copy.track.createGroup(BigInt(group))); } catch { return; } @@ -534,7 +534,7 @@ class Model { if (copy.groups.has(key)) return local(); const written = publisher.written.get(key) ?? 0; if (key >= GROUPS || written === 0) throw new NotFound(`group ${key}`); - const writer = copy.track.createGroup(BigInt(key)); + const writer = defined(copy.track.createGroup(BigInt(key))); copy.groups.set(key, { written: 0, writer }); const group = writer.consume(); this.write(instance, slot, key, written); diff --git a/js/net/src/resume.test.ts b/js/net/src/resume.test.ts index 85c11e25370..3a605ba3b5c 100644 --- a/js/net/src/resume.test.ts +++ b/js/net/src/resume.test.ts @@ -68,7 +68,7 @@ function copy(source: BroadcastProducer) { return { producer, write(key: bigint, frames = 1, close = true) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); for (let frame = 0; frame < frames; frame++) group.writeFrame({ payload: enc.encode(`${key}.${frame}`), @@ -175,7 +175,7 @@ test("a pending refresh moves to the next copy when the one it asked closes", as const handles = sources.map((source) => source.consume()); const tracks = sources.map((source) => { const producer = defined(source.createTrack("seq", { maxAge: null, refresh: { interval: Duration.secs(5) } })); - const group = producer.createGroup(0n); + const group = defined(producer.createGroup(0n)); group.writeFrame({ payload: enc.encode("0"), timestamp: Timestamp.unscaled(group.start) }); group.finish(); return producer; @@ -196,7 +196,7 @@ test("a pending refresh moves to the next copy when the one it asked closes", as expect(tracks[1].demand().refresh.peek()).toBe(true); await refresh; - const group = tracks[1].createGroup(1n); + const group = defined(tracks[1].createGroup(1n)); group.writeFrame({ payload: enc.encode("1"), timestamp: Timestamp.unscaled(group.start) }); group.finish(); drain(sub); @@ -837,7 +837,7 @@ test("a lagging same-instance replica resumes from one publisher's bytes exactly for (;;) { const group = await input.recvGroup(); if (!group) return; - const copy = output.createGroup(group.start); + const copy = defined(output.createGroup(group.start)); try { for (let index = 0; ; index++) { const frame = await group.readFrame(); @@ -1419,10 +1419,10 @@ test("a fetched group continued from an empty, already-closed copy releases that const sub = front.consumer.track("seq").subscribe(); // Group 5 is empty: the first route fails it, the next holds it closed. - const failing = defined(a.createTrack("fetch")).createGroup(5n); + const failing = defined(defined(a.createTrack("fetch")).createGroup(5n)); const group = await front.consumer.track("fetch").fetchGroup(5n); const read = group.readFrame(); - const whole = defined(b.createTrack("fetch")).createGroup(5n); + const whole = defined(defined(b.createTrack("fetch")).createGroup(5n)); whole.finish(); front.serve(b.consume()); await settle(); @@ -1461,7 +1461,7 @@ test("a fetched group failing as it is handed out releases its route once", asyn expect(drain(sub)).toEqual([0n]); const fa = defined(a.createTrack("fetch")); - const failing = fa.createGroup(5n); + const failing = defined(fa.createGroup(5n)); failing.writeFrame({ payload: enc.encode("5.0"), timestamp: Timestamp.unscaled(failing.start) }); const fetching = front.consumer.track("fetch").fetchGroup(5n); for (let turn = 0; turn < turns; turn++) await Promise.resolve(); @@ -1471,7 +1471,7 @@ test("a fetched group failing as it is handed out releases its route once", asyn // The next route holds the fetched group whole; the old one still feeds the reader a // group the new route never has. const fb = defined(b.createTrack("fetch")); - const whole = fb.createGroup(5n); + const whole = defined(fb.createGroup(5n)); whole.writeFrame({ payload: enc.encode("5.0"), timestamp: Timestamp.unscaled(whole.start) }); whole.writeFrame({ payload: enc.encode("5.1"), timestamp: Timestamp.unscaled(whole.start) }); whole.finish(); @@ -2323,7 +2323,7 @@ test("a resumed reader drops a taken group outside its window when the offered o tail.writeFrame({ payload: enc.encode("10.1"), timestamp: Timestamp.unscaled(10n) }); tail.finish(); for (const key of [80n, 120n]) { - const group = tb.createGroup(key); + const group = defined(tb.createGroup(key)); group.writeFrame({ payload: enc.encode(`${key}.0`), timestamp: Timestamp.unscaled(key) }); group.finish(); } @@ -2859,7 +2859,7 @@ test("a failed group on a route whose replacement was refused ends with the refu defined(b.createTrack("seq", { priority: 2 })); front.serve(a.consume()); const sub = front.consumer.track("seq").subscribe(); - const stalled = ta.createGroup(0n); + const stalled = defined(ta.createGroup(0n)); stalled.writeFrame({ payload: enc.encode("0.0"), timestamp: Timestamp.unscaled(stalled.start) }); const group = sub.tryRecvGroup(); if (!group) throw new Error("expected group 0"); @@ -2935,7 +2935,7 @@ test("a fetch never reads a replacement refused for its track properties", async const b = new BroadcastProducer(); defined(a.createTrack("seq", { priority: 1 })); const tb = defined(b.createTrack("seq", { priority: 2 })); - const group = tb.createGroup(0n); + const group = defined(tb.createGroup(0n)); group.writeFrame({ payload: enc.encode("b"), timestamp: Timestamp.unscaled(group.start) }); group.finish(); front.serve(a.consume()); @@ -2957,7 +2957,7 @@ test("the first fetch of a track says what the track is for later routes", async [b, 2], ] as const) { const producer = defined(source.createTrack("seq", { priority })); - const group = producer.createGroup(0n); + const group = defined(producer.createGroup(0n)); group.writeFrame({ payload: enc.encode(`${priority}`), timestamp: Timestamp.unscaled(group.start) }); group.finish(); } @@ -3014,7 +3014,7 @@ test("a fetch never hands out a group from a route refused for its properties", const b = new BroadcastProducer(); defined(a.createTrack("seq", { priority: 1 })); const tb = defined(b.createTrack("seq", { priority: 2 })); - const group = tb.createGroup(0n); + const group = defined(tb.createGroup(0n)); group.writeFrame({ payload: enc.encode("b"), timestamp: Timestamp.unscaled(group.start) }); group.finish(); front.serve(a.consume()); @@ -3424,7 +3424,7 @@ test("a fetch waits for the copy being read to say what the track is", async () // a answers what the track is only when told to. const requests = wireOf(a).requested(); const tb = defined(b.createTrack("seq", { priority: 2 })); - const group = tb.createGroup(0n); + const group = defined(tb.createGroup(0n)); group.writeFrame({ payload: enc.encode("b"), timestamp: Timestamp.unscaled(group.start) }); group.finish(); front.serve(a.consume()); diff --git a/js/net/src/track.test.ts b/js/net/src/track.test.ts index 904877b6258..7b1f52140ad 100644 --- a/js/net/src/track.test.ts +++ b/js/net/src/track.test.ts @@ -21,6 +21,7 @@ import { } from "./track.ts"; import { unwanted } from "./util/demand.ts"; import { LIVE, rangesStart, union } from "./window.ts"; +import { defined } from "./defined.test-util.ts"; const enc = new TextEncoder(); const dec = new TextDecoder(); @@ -79,7 +80,7 @@ function receivedTrack(info: Parameters[0] = {}) { } function putGroup(producer: TrackProducer, key: bigint, millis?: number) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); if (millis !== undefined) group.writeFrame(textFrame("x", Timestamp.fromMillis(millis))); group.finish(); } @@ -195,7 +196,7 @@ test("an ordered owed hole follows media time and a lower successor", async () = try { putGroup(producer, 0n, 0); expect(drainOrdered(reader)).toEqual([0n]); - const edge = producer.createGroup(4n); + const edge = defined(producer.createGroup(4n)); edge.writeFrame(textFrame("edge", Timestamp.fromMillis(4000))); expect(drainOrdered(reader)).toEqual([]); let resolved = false; @@ -231,7 +232,7 @@ test("an ordered owed hole wakes when its ledger gap folds", async () => { try { putGroup(producer, 0n); expect(drainOrdered(reader)).toEqual([0n]); - const opener = producer.createGroup(2n); + const opener = defined(producer.createGroup(2n)); await clock.advance(40); putGroup(producer, 3n); opener.abort(new StreamError(StreamCode.Cancel)); @@ -1026,7 +1027,7 @@ test("each reader reads only its own ranges, whatever the union asks for", () => { start: { time: 1n }, end: { time: 2n } }, { start: { time: 4n } }, ]); - for (let key = 0n; key < 7n; key++) producer.createGroup(key).finish(); + for (let key = 0n; key < 7n; key++) defined(producer.createGroup(key)).finish(); const read = (subscriber: typeof sparse) => { const got: bigint[] = []; @@ -1059,13 +1060,13 @@ test("a bounded read ends once its window is read, unless a cap or a wire publis const capped = producer.subscribe({ delay: { max: null }, ranges }).withRange({ end: { excluded: 3n } }); const parked = hooks.parked(producer.subscribe({ delay: { max: null }, ranges })); const open = producer.subscribe({ delay: { max: null }, ranges: [{ start: { time: 1n } }] }); - for (const key of [0n, 1n, 2n]) producer.createGroup(key).finish(); + for (const key of [0n, 1n, 2n]) defined(producer.createGroup(key)).finish(); expect(read(reader)).toEqual([1n, 2n]); // Groups 3 and 4 may still arrive. expect(hooks.tryRecvGroup(reader, false)).toEqual({ kind: "idle" }); hooks.dropTrackGroups(producer, 3n, 4n, { error: DROPPED }); - producer.createGroup(4n).finish(); + defined(producer.createGroup(4n)).finish(); expect(read(reader)).toEqual([4n]); expect(hooks.tryRecvGroup(reader, false)).toEqual({ kind: "done" }); expect(drainOrdered(ordered)).toEqual([1n, 2n, 4n]); @@ -1086,7 +1087,7 @@ test("a bounded read ends once its window is read, unless a cap or a wire publis reader.update({ delay: { max: null }, ranges: [{ start: { time: 0n }, end: { time: 5n } }] }); expect(read(reader)).toEqual([0n]); expect(hooks.tryRecvGroup(reader, false)).toEqual({ kind: "idle" }); - producer.createGroup(5n).finish(); + defined(producer.createGroup(5n)).finish(); expect(read(reader)).toEqual([5n]); expect(hooks.tryRecvGroup(reader, false)).toEqual({ kind: "done" }); }); @@ -1127,7 +1128,7 @@ test("an ordered reader keeps a group between its ranges until the cursor passes ], }) .ordered(); - for (const key of [0n, 1n]) producer.createGroup(key).finish(); + for (const key of [0n, 1n]) defined(producer.createGroup(key)).finish(); expect(track.tryNextGroup()?.start).toBe(0n); expect(track.tryNextGroup()).toBeUndefined(); @@ -1140,7 +1141,7 @@ test("an ordered reader keeps a group between its ranges until the cursor passes test("a relative range counts back from the latest group, or waits for the first", () => { const producer = new TrackProducer("test"); - for (let key = 0n; key < 5n; key++) producer.createGroup(key).finish(); + for (let key = 0n; key < 5n; key++) defined(producer.createGroup(key)).finish(); const back = producer.subscribe({ delay: { max: null }, ranges: [{ start: { relative: 2n }, end: { relative: 1n } }], @@ -1149,9 +1150,9 @@ test("a relative range counts back from the latest group, or waits for the first const empty = new TrackProducer("test"); const live = empty.subscribe({ delay: { max: null }, ranges: [{ start: { relative: 0n } }] }); - empty.createGroup(7n).finish(); - empty.createGroup(6n).finish(); - empty.createGroup(8n).finish(); + defined(empty.createGroup(7n)).finish(); + defined(empty.createGroup(6n)).finish(); + defined(empty.createGroup(8n)).finish(); // Resolved at the first group to arrive: group 6 sits below where it started. expect([live.tryRecvGroup()?.start, live.tryRecvGroup()?.start, live.tryRecvGroup()]).toEqual([7n, 8n, undefined]); }); @@ -1161,7 +1162,7 @@ test("a copy over a wire without ranges refuses a relative anchor it cannot carr const back = producer.subscribe({ ranges: [{ start: { relative: 3n } }] }); const live = producer.subscribe({ ranges: [{ start: { relative: 0n } }] }); hooks.dropAnchors(producer); - producer.createGroup(0n).finish(); + defined(producer.createGroup(0n)).finish(); expect(() => back.tryRecvGroup()).toThrow("moq-lite-07"); expect(live.tryRecvGroup()?.start).toBe(0n); }); @@ -1170,7 +1171,7 @@ test("a time range reads the groups containing its times, by their starts", () = const producer = new TrackProducer("test"); producer.accept({ timescale: Timescale.MILLI, maxAge: null }); const start = (key: bigint) => { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.writeFrame(textFrame(`${key}`, Timestamp.fromMillis(Number(key)))); return group; }; @@ -1187,9 +1188,9 @@ test("a time range reads the groups containing its times, by their starts", () = // Group 1000 contains 1500, and a group may still start inside the end. expect(read()).toEqual([1000n, 2000n]); // A group's key is its start, so the end places it before any frame arrives. - producer.createGroup(3000n); + defined(producer.createGroup(3000n)); expect(read()).toEqual([3000n]); - producer.createGroup(4000n); + defined(producer.createGroup(4000n)); expect(read()).toEqual([]); expect(hooks.servingEnd(reader)).toBe(3501n); }); @@ -1211,7 +1212,7 @@ function halfSecondGroups(): TrackProducer { // Append the `n`th 500 ms group, starting and presenting at `n` half seconds. function appendHalfSecond(producer: TrackProducer, n: bigint): void { - const group = producer.createGroup(n * 500n); + const group = defined(producer.createGroup(n * 500n)); group.writeFrame(textFrame(`${n}`, Timestamp.fromMillis(Number(n) * 500))); group.finish(); } @@ -1266,7 +1267,7 @@ test("a live join reads nothing until the groups held measure the live edge", () // A copy whose wire keys groups by sequence measures by first frames, not keys. hooks.startsAtKeys(producer); // Groups written before accept say nothing yet of whether the track is timed. - const groups = Array.from({ length: 11 }, (_, key) => producer.createGroup(BigInt(key))); + const groups = Array.from({ length: 11 }, (_, key) => defined(producer.createGroup(BigInt(key)))); const reader = producer.subscribe({ delay: { min: Duration.secs(2), max: Duration.secs(30) }, ranges: [LIVE] }); expect(readable(reader)).toEqual([]); producer.accept({ timescale: Timescale.MILLI, maxAge: null }); @@ -1286,7 +1287,7 @@ test("a live join reaches back by ticks rounded up, at any timestamp the track a const base = 10_000_000_000_000; const starts = [0, 1, 2].map((offset) => BigInt(base + offset)); for (const start of starts) { - const group = producer.createGroup(start); + const group = defined(producer.createGroup(start)); group.writeFrame(textFrame(`${start}`, Timestamp.fromMillis(Number(start)))); group.finish(); } @@ -1302,7 +1303,7 @@ test("a live join measures timestamps between ticks, floored", () => { const producer = new TrackProducer("test"); producer.accept({ timescale: Timescale.MILLI, maxAge: null }); for (const [key, ms] of [0.5, 1.5, 2.5].entries()) { - const group = producer.createGroup(BigInt(key)); + const group = defined(producer.createGroup(BigInt(key))); group.writeFrame(textFrame(`${key}`, Timestamp.fromMillis(ms))); group.finish(); } @@ -1318,7 +1319,7 @@ test("a scale-less join reaches back by arrival", () => { producer.accept({ maxAge: null }); // Group N arrives N seconds in, and the join comes at 5 s. for (let key = 0n; key < 5n; key++) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.writeFrame(textFrame(`${key}`, Timestamp.unscaled(key))); group.finish(); clock.set(Number(key + 1n) * 1000); @@ -1340,7 +1341,7 @@ test("a time start resolves on keys alone, before any group's first frame", () = for (const order of ["ascending", "descending"] as const) { const producer = new TrackProducer("test"); producer.accept({ timescale: Timescale.MILLI, maxAge: null }); - for (const key of [0n, 1000n, 2000n]) producer.createGroup(key); + for (const key of [0n, 1000n, 2000n]) defined(producer.createGroup(key)); producer.finishAt({ group: 3000n, frame: 0 }); const subscription = { delay: { max: null }, order, ranges: [{ start: { time: 1500n } }] }; const reader = producer.subscribe(subscription); @@ -1358,7 +1359,7 @@ test("a time start resolves on keys alone, before any group's first frame", () = test("a drop a time end covers is reported", () => { const producer = new TrackProducer("test"); producer.accept({ timescale: Timescale.MILLI }); - const zero = producer.createGroup(0n); + const zero = defined(producer.createGroup(0n)); const reader = producer.subscribe({ delay: { max: null }, order: "ascending", @@ -1426,15 +1427,15 @@ test("nextGroup skips late arrivals", async () => { const producer = new TrackProducer("test"); const track = producer.subscribe().ordered(); - producer.createGroup(5n); + defined(producer.createGroup(5n)); const first = await track.nextGroup(); expect(first?.start).toBe(5n); // Late arrivals with sequence <= last returned are skipped. - producer.createGroup(3n); - producer.createGroup(4n); - producer.createGroup(7n); + defined(producer.createGroup(3n)); + defined(producer.createGroup(4n)); + defined(producer.createGroup(7n)); const next = await track.nextGroup(); expect(next?.start).toBe(7n); @@ -1444,8 +1445,8 @@ test("nextGroup returns buffered groups in sequence", async () => { const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }).ordered(); - producer.createGroup(3n); - producer.createGroup(5n); + defined(producer.createGroup(3n)); + defined(producer.createGroup(5n)); expect((await track.nextGroup())?.start).toBe(3n); expect((await track.nextGroup())?.start).toBe(5n); @@ -1565,7 +1566,7 @@ test("a late-arriving successor bounds a group's reach", async () => { [2n, 3000], [1n, 200], ] as const) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.writeFrame({ payload: enc.encode(`${ms}`), timestamp: Timestamp.fromMillis(ms) }); group.finish(); } @@ -1602,16 +1603,16 @@ for (const take of ["nextGroup", "tryNextGroup"] as const) { const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }).ordered(); - const zero = producer.createGroup(0n); + const zero = defined(producer.createGroup(0n)); zero.writeFrame(textFrame("0.0", Timestamp.fromMillis(Number(zero.start)))); zero.writeFrame(textFrame("0.1", Timestamp.fromMillis(Number(zero.start)))); zero.finish(); - const one = producer.createGroup(1n); + const one = defined(producer.createGroup(1n)); one.writeFrame(textFrame("1.0", Timestamp.fromMillis(Number(one.start)))); one.finish(); - const two = producer.createGroup(2n); + const two = defined(producer.createGroup(2n)); two.writeFrame(textFrame("2.0", Timestamp.fromMillis(Number(two.start)))); two.finish(); @@ -1632,16 +1633,16 @@ test("ordered frame reads skip a late lower-sequence group", async () => { const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }).ordered(); - const five = producer.createGroup(5n); + const five = defined(producer.createGroup(5n)); five.writeFrame(textFrame("five", Timestamp.fromMillis(5))); five.finish(); expect(await track.readString()).toBe("five"); - const three = producer.createGroup(3n); + const three = defined(producer.createGroup(3n)); three.writeFrame(textFrame("three", Timestamp.fromMillis(3))); three.finish(); - const six = producer.createGroup(6n); + const six = defined(producer.createGroup(6n)); six.writeFrame(textFrame("six", Timestamp.fromMillis(6))); six.finish(); @@ -1716,7 +1717,7 @@ test("a late lower group within the budget is delivered", async () => { [6n, 2000], [7n, 3000], ] as const) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.writeFrame({ payload: enc.encode(`${timestamp}`), timestamp: Timestamp.fromMillis(timestamp) }); group.finish(); } @@ -1729,7 +1730,7 @@ test("a late lower group within the budget is delivered", async () => { // Arriving below everything already delivered is not what makes content stale: the // budget is the only gate, and this straggler's timestamp is within it. A consumer // that needs sequence order reorders (or drops) it itself. - const late = producer.createGroup(4n); + const late = defined(producer.createGroup(4n)); late.writeFrame({ payload: enc.encode("late"), timestamp: Timestamp.fromMillis(500) }); late.finish(); @@ -2269,7 +2270,7 @@ test("a live track retains its newest closed group through idle expiry", async ( try { // A late older group must not replace the protected newest snapshot. for (const key of [2n, 1n]) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.writeFrame({ payload: enc.encode("snapshot"), timestamp: Timestamp.fromMillis(Number(key)) }); group.finish(); } @@ -2499,12 +2500,12 @@ test("latency budget retains a consumed live-edge anchor", async () => { const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI, maxAge: Duration.millis(5000) }); const track = producer.subscribe(); - const edge = producer.createGroup(2n); + const edge = defined(producer.createGroup(2n)); edge.writeFrame({ payload: enc.encode("edge"), timestamp: Timestamp.fromMillis(2000) }); edge.finish(); expect((await track.recvGroup())?.start).toBe(2n); - const late = producer.createGroup(1n); + const late = defined(producer.createGroup(1n)); late.writeFrame({ payload: enc.encode("late"), timestamp: Timestamp.fromMillis(0) }); late.finish(); producer.finish(); @@ -2517,11 +2518,11 @@ test("an aborted live-edge anchor does not make older content stale", async () = const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI, maxAge: Duration.millis(5000) }); const track = producer.subscribe(); - const edge = producer.createGroup(2n); + const edge = defined(producer.createGroup(2n)); edge.writeFrame({ payload: enc.encode("edge"), timestamp: Timestamp.fromMillis(2000) }); edge.abort(new Error("aborted")); - const older = producer.createGroup(1n); + const older = defined(producer.createGroup(1n)); older.writeFrame({ payload: enc.encode("older"), timestamp: Timestamp.fromMillis(0) }); older.finish(); @@ -2539,7 +2540,7 @@ test.each(["arrival", "ordered"] as const)("subscription bounds stay reader-loca const ordered = order === "ordered" ? subscriber.ordered() : undefined; const read = () => (ordered ? ordered.nextGroup() : subscriber.recvGroup()); try { - for (let key = 0n; key < 5n; key++) producer.createGroup(key); + for (let key = 0n; key < 5n; key++) defined(producer.createGroup(key)); expect((await everything.recvGroup())?.start).toBe(0n); expect((await read())?.start).toBe(1n); expect((await read())?.start).toBe(2n); @@ -2577,7 +2578,7 @@ test("subscription updates narrow the cursor before its first read", async () => const everything = producer.subscribe({ delay: { max: Duration.millis(5000) } }); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }); try { - for (let key = 0n; key < 5n; key++) producer.createGroup(key); + for (let key = 0n; key < 5n; key++) defined(producer.createGroup(key)); track.update({ delay: { max: Duration.millis(5000) }, ranges: [{ start: { time: 3n }, end: { time: 3n } }], @@ -2615,7 +2616,7 @@ test("withRange with an excluded end of 0 is the empty range and does not ride a const everything = producer.subscribe({ delay: { max: Duration.millis(5000) } }); const empty = producer.subscribe({ delay: { max: Duration.millis(5000) } }).withRange({ end: { excluded: 0n } }); - for (let key = 0n; key < 3n; key++) producer.createGroup(key); + for (let key = 0n; key < 3n; key++) defined(producer.createGroup(key)); expect((await everything.recvGroup())?.start).toBe(0n); const pending = empty.recvGroup(); @@ -2637,7 +2638,7 @@ for (const ordered of [false, true]) { const subscriber = producer.subscribe({ delay: { max: null } }).withRange({ end: { excluded: end } }); if (ordered) subscriber.ordered(); const read = () => (ordered ? hooks.tryNextGroup(subscriber) : hooks.tryRecvGroup(subscriber, false)); - for (const key of [0n, 2n, 4n]) producer.createGroup(key).finish(); + for (const key of [0n, 2n, 4n]) defined(producer.createGroup(key)).finish(); producer.finish(); producer.close(); @@ -2694,7 +2695,7 @@ test("local cursor bounds can skip, pause, and release buffered groups", async ( const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }).ordered(); - for (let key = 0n; key < 5n; key++) producer.createGroup(key); + for (let key = 0n; key < 5n; key++) defined(producer.createGroup(key)); track.withRange({ start: { included: 1n }, end: { excluded: 3n } }); expect((await track.nextGroup())?.start).toBe(1n); @@ -2714,11 +2715,11 @@ test("recvGroup serves a late arrival after a newer group", async () => { const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }); - producer.createGroup(2n); + defined(producer.createGroup(2n)); expect((await track.recvGroup())?.start).toBe(2n); // Group 1 lands after group 2 was already served. - producer.createGroup(1n); + defined(producer.createGroup(1n)); expect((await track.recvGroup())?.start).toBe(1n); // Staleness is the latency window's job, not arrival order's: the track @@ -2733,7 +2734,7 @@ test("withRange parks recvGroup beyond the cap and a raised cap re-offers", asyn const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }); - for (let key = 0n; key < 3n; key++) producer.createGroup(key).finish(); + for (let key = 0n; key < 3n; key++) defined(producer.createGroup(key)).finish(); track.withRange({ end: { excluded: 2n } }); expect((await track.recvGroup())?.start).toBe(0n); @@ -2761,9 +2762,9 @@ test("recvGroup serves in-range groups that arrive behind a capped one", async ( track.withRange({ end: { excluded: 2n } }); // Reordered burst: the beyond-cap group arrives first. - producer.createGroup(2n); - producer.createGroup(0n); - producer.createGroup(1n); + defined(producer.createGroup(2n)); + defined(producer.createGroup(0n)); + defined(producer.createGroup(1n)); expect((await track.recvGroup())?.start).toBe(0n); expect((await track.recvGroup())?.start).toBe(1n); @@ -2782,37 +2783,37 @@ test("withRange drops groups recvGroup parked at the cap", async () => { const track = producer.subscribe(); track.withRange({ end: { excluded: 1n } }); - producer.createGroup(1n); + defined(producer.createGroup(1n)); const pending = track.recvGroup(); expect(await Promise.race([pending, Promise.resolve("pending")])).toBe("pending"); track.withRange({ start: { included: 2n } }); - producer.createGroup(2n); + defined(producer.createGroup(2n)); // The overtaken parked group is dropped, not re-offered. expect((await pending)?.start).toBe(2n); }); // A live duplicate would fan out to every subscriber twice (recvGroup has no sequence -// cursor to hide it), so createGroup rejects it like Rust's claim_sequence. An aborted -// incarnation is evicted so a fresh group can serve the sequence again. -test("createGroup rejects a duplicate live sequence", async () => { +// cursor to hide it), so createGroup returns nothing for it, as Rust's create_group does. An +// aborted incarnation is evicted so a fresh group can serve the sequence again. +test("createGroup refuses a duplicate live sequence", async () => { const producer = new TrackProducer("test"); const track = producer.subscribe(); - const first = producer.createGroup(7n); + const first = defined(producer.createGroup(7n)); first.writeFrame(textFrame("first", Timestamp.fromMillis(Number(first.start)))); first.finish(); // A peer re-sending a live sequence is rejected, not fanned out again. - expect(() => producer.createGroup(7n)).toThrow("duplicate group"); + expect(producer.createGroup(7n)).toBeUndefined(); expect((await track.recvGroup())?.start).toBe(7n); // An aborted incarnation is replaceable: the retry serves the sequence fresh. - const aborted = producer.createGroup(8n); + const aborted = defined(producer.createGroup(8n)); aborted.abort(new Error("upstream reset")); - const retry = producer.createGroup(8n); + const retry = defined(producer.createGroup(8n)); retry.writeFrame(textFrame("retry", Timestamp.fromMillis(Number(retry.start)))); retry.finish(); @@ -2828,7 +2829,7 @@ test("closing the subscriber releases a group retained across a clean close", as const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }); track.withRange({ end: { excluded: 1n } }); - producer.createGroup(1n).finish(); + defined(producer.createGroup(1n)).finish(); const pending = track.recvGroup(); expect(await Promise.race([pending, Promise.resolve("pending")])).toBe("pending"); @@ -2849,7 +2850,7 @@ test("closing the subscriber releases a recvGroup parked while the producer is l const track = producer.subscribe(); track.withRange({ end: { excluded: 1n } }); - producer.createGroup(1n); + defined(producer.createGroup(1n)); const pending = track.recvGroup(); expect(await Promise.race([pending, Promise.resolve("pending")])).toBe("pending"); @@ -2863,12 +2864,12 @@ test("the ordered and arrival cursors are independent", async () => { const ordered = producer.subscribe({ delay: { max: Duration.millis(5000) } }).ordered(); const arrival = producer.subscribe({ delay: { max: Duration.millis(5000) } }); - producer.createGroup(5n); + defined(producer.createGroup(5n)); expect((await ordered.nextGroup())?.start).toBe(5n); // A late seq 3 is skipped by the ordered cursor, which has already passed it, but the // arrival cursor has both buffered and still delivers each exactly once. - producer.createGroup(3n); + defined(producer.createGroup(3n)); expect((await arrival.recvGroup())?.start).toBe(3n); expect((await arrival.recvGroup())?.start).toBe(5n); }); @@ -2880,13 +2881,13 @@ test("the first group read commits the cursor and refuses the other order", asyn // An arrival read commits to arrival order; ordered() is refused afterwards. const arrival = producer.subscribe({ delay: { max: Duration.millis(5000) } }); - producer.createGroup(5n); + defined(producer.createGroup(5n)); expect((await arrival.recvGroup())?.start).toBe(5n); expect(() => arrival.ordered()).toThrow("arrival order"); // The commitment refuses the other cursor without poisoning this one: a late // lower sequence still flows in arrival order. - producer.createGroup(3n); + defined(producer.createGroup(3n)); expect((await arrival.recvGroup())?.start).toBe(3n); // The other direction: ordered() takes the subscription and arrival reads throw. @@ -2914,7 +2915,7 @@ test("a closed track still delivers a group parked above the cap once the cap is const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }).ordered(); for (let key = 0n; key < 3n; key++) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.writeFrame(textFrame(`frame-${key}`, Timestamp.fromMillis(Number(group.start)))); group.finish(); } @@ -3047,10 +3048,10 @@ test("a late group below the largest changes nothing", async () => { const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI }); const subscriber = producer.subscribe(); - const framed = producer.createGroup(2n); + const framed = defined(producer.createGroup(2n)); framed.writeFrame({ payload: enc.encode("a"), timestamp: Timestamp.fromMillis(2) }); framed.finish(); - const empty = producer.createGroup(5n); + const empty = defined(producer.createGroup(5n)); empty.finish(); producer.finishAt({ group: 6n, frame: 0 }); @@ -3058,7 +3059,7 @@ test("a late group below the largest changes nothing", async () => { expect(await subscriber.largest()).toBeUndefined(); // Late content below the end is still admitted; it just isn't the largest. - const late = producer.createGroup(4n); + const late = defined(producer.createGroup(4n)); late.writeFrame({ payload: enc.encode("b"), timestamp: Timestamp.fromMillis(4) }); expect(await subscriber.largest()).toBeUndefined(); expect(await producer.subscribe().largest()).toEqual({ group: 5n, frame: 0 }); @@ -3073,7 +3074,7 @@ test("a recreated largest group is reported before the end", async () => { const subscriber = producer.subscribe(); // The recreated group carries the same content, timestamps included. const timestamp = Timestamp.now(); - const first = producer.createGroup(0n); + const first = defined(producer.createGroup(0n)); first.writeFrame({ payload: enc.encode("a"), timestamp }); first.abort(new Error("cut")); producer.finishAt({ group: 1n, frame: 0 }); @@ -3087,7 +3088,7 @@ test("a recreated largest group is reported before the end", async () => { await settle(); expect(advanced).toBe(false); - const again = producer.createGroup(0n); + const again = defined(producer.createGroup(0n)); for (const payload of ["a", "b"]) again.writeFrame({ payload: enc.encode(payload), timestamp }); expect(await next).toEqual({ group: 0n, frame: 1 }); again.finish(); @@ -3098,7 +3099,7 @@ test("a recreated largest group is reported before the end", async () => { /** Write untimed group `sequence` with `frames` frames, left open. */ function framedGroup(producer: TrackProducer, key: bigint, frames: number): GroupProducer { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); for (let i = 0; i < frames; i++) group.writeFrame({ payload: enc.encode("x"), timestamp: Timestamp.unscaled(group.start) }); return group; @@ -3234,7 +3235,7 @@ test("group ranges preserve progress and spell out inclusion", async () => { const track = producer .subscribe({ delay: { max: Duration.millis(5000) } }) .withRange({ start: { included: 1n }, end: { included: 1n } }); - for (let key = 0n; key < 4n; key++) producer.createGroup(key); + for (let key = 0n; key < 4n; key++) defined(producer.createGroup(key)); expect(track.tryRecvGroup()?.start).toBe(1n); expect(track.tryRecvGroup()).toBeUndefined(); track.withRange({ start: { included: 1n }, end: { excluded: 3n } }); @@ -3249,7 +3250,7 @@ test("group ranges preserve progress and spell out inclusion", async () => { test("a lowered range re-offers the unread cached groups", () => { const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }).withRange({ start: { included: 10n } }); - for (const key of [5n, 6n, 10n]) producer.createGroup(key); + for (const key of [5n, 6n, 10n]) defined(producer.createGroup(key)); expect(track.tryRecvGroup()?.start).toBe(10n); expect(track.tryRecvGroup()).toBeUndefined(); @@ -3259,7 +3260,7 @@ test("a lowered range re-offers the unread cached groups", () => { expect(track.tryRecvGroup()?.start).toBe(5n); track.withRange({}); expect(track.tryRecvGroup()).toBeUndefined(); - producer.createGroup(11n); + defined(producer.createGroup(11n)); expect(track.tryRecvGroup()?.start).toBe(11n); track.close(); }); @@ -3267,10 +3268,10 @@ test("a lowered range re-offers the unread cached groups", () => { test("a lowered range re-offers a cached cut with its error", async () => { const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }).withRange({ start: { included: 1n } }); - const cut = producer.createGroup(0n); + const cut = defined(producer.createGroup(0n)); const error = new StreamError(StreamCode(70), { message: "cut" }); cut.abort(error); - producer.createGroup(1n); + defined(producer.createGroup(1n)); expect(track.tryRecvGroup()?.start).toBe(1n); track.withRange({}); @@ -3285,7 +3286,7 @@ test("a lowered range re-offers a cached cut with its error", async () => { test("a lowered range still re-offers after the producer closes", () => { const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }).withRange({ start: { included: 1n } }); - for (const key of [0n, 1n]) producer.createGroup(key).finish(); + for (const key of [0n, 1n]) defined(producer.createGroup(key)).finish(); expect(track.tryRecvGroup()?.start).toBe(1n); producer.finish(); producer.close(); @@ -3302,7 +3303,7 @@ for (const abort of [undefined, new Error("gone")]) { const track = producer .subscribe({ delay: { max: Duration.millis(5000) } }) .withRange({ start: { included: 1n } }); - for (const key of [0n, 1n]) producer.createGroup(key); + for (const key of [0n, 1n]) defined(producer.createGroup(key)); expect(track.tryRecvGroup()?.start).toBe(1n); track.close(abort); @@ -3316,7 +3317,7 @@ for (const abort of [undefined, new Error("gone")]) { test("malformed group bounds do not partially advance the cursor", () => { const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(5000) } }); - producer.createGroup(0n); + defined(producer.createGroup(0n)); expect(() => track.withRange({ start: { included: 3n }, end: { excluded: -1n } })).toThrow(); expect(track.tryRecvGroup()?.start).toBe(0n); track.close(); @@ -3325,7 +3326,7 @@ test("malformed group bounds do not partially advance the cursor", () => { test("finishAt declares an end ahead of the live edge without ending the track", async () => { const producer = new TrackProducer("test"); const track = producer.subscribe({ delay: { max: Duration.millis(60_000) } }); - producer.createGroup(5n); + defined(producer.createGroup(5n)); const first = await track.recvGroup(); expect(first?.start).toBe(5n); @@ -3334,9 +3335,9 @@ test("finishAt declares an end ahead of the live edge without ending the track", expect(await track.finished()).toEqual({ group: 8n, frame: 0 }); // Not terminal: groups below the end still arrive, including a straggler. - const late = producer.createGroup(7n); + const late = defined(producer.createGroup(7n)); late.finish(); - const straggler = producer.createGroup(6n); + const straggler = defined(producer.createGroup(6n)); straggler.finish(); expect((await track.recvGroup())?.start).toBe(6n); expect((await track.recvGroup())?.start).toBe(7n); @@ -3360,7 +3361,7 @@ for (const ordered of [false, true]) { try { producer.finishAt({ group: 3n, frame: 0 }); const waiting = receive(); - const group = producer.createGroup(2n); + const group = defined(producer.createGroup(2n)); group.writeFrame(textFrame("tail", Timestamp.fromMillis(Number(group.start)))); const received = await waiting; expect(received?.start).toBe(2n); @@ -3580,13 +3581,13 @@ test("an abort after the declared end settles ends clean", async () => { test("a settled end survives a late group and an abort", async () => { const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI }); const subscriber = producer.subscribe(); - const last = producer.createGroup(5n); + const last = defined(producer.createGroup(5n)); last.finish(); producer.finishAt({ group: 6n, frame: 0 }); await settle(); expect(producer.closed.peek()).toBeNull(); - producer.createGroup(4n); + defined(producer.createGroup(4n)); producer.abort(new Error("boom")); expect(producer.closed.peek()).toBeNull(); expect((await subscriber.recvGroup())?.start).toBe(5n); @@ -3831,7 +3832,7 @@ test("a scale-less single-frame write lands at its key", () => { producer.writeFrame({ payload: enc.encode("c"), timestamp: Timestamp.unscaled(5n) }); expect(drain(subscriber)).toEqual([3n, 5n]); // The keys below each write are skipped, so creating one is refused. - expect(() => producer.createGroup(4n)).toThrow(Skipped); + expect(() => defined(producer.createGroup(4n))).toThrow(Skipped); }); // An explicit start is a floor, not a request: the budget still skips what it finds stale @@ -3857,7 +3858,7 @@ test("explicit and producer-cut drops survive outside the group cache", async () hooks.dropTrackGroups(producer, 3n, 4n, { error: DROPPED }); expect(hooks.tryRecvGroup(reader, true)).toEqual({ kind: "drop", start: 3n, end: 4n, error: DROPPED }); - const group = producer.createGroup(4n); + const group = defined(producer.createGroup(4n)); const cut = new Error("cut"); group.abort(cut); await settle(); @@ -3879,7 +3880,7 @@ test("a group ended by a cancel or cache policy is a hole, not a drop", async () new TooFarBehind(), ]; for (const [key, hole] of holes.entries()) { - const group = producer.createGroup(BigInt(key)); + const group = defined(producer.createGroup(BigInt(key))); group.abort(hole); } await settle(); @@ -3893,9 +3894,9 @@ test("a group ended by a cancel or cache policy is a hole, not a drop", async () test("an upstream drop ends a group still arriving with its error", async () => { const producer = new TrackProducer("video").accept({ maxAge: null }); const reader = producer.subscribe({ delay: { max: Duration.millis(60_000) } }); - const arriving = producer.createGroup(3n); + const arriving = defined(producer.createGroup(3n)); arriving.writeFrame({ payload: enc.encode("3"), timestamp: Timestamp.unscaled(arriving.start) }); - const finished = producer.createGroup(4n); + const finished = defined(producer.createGroup(4n)); finished.writeFrame({ payload: enc.encode("4"), timestamp: Timestamp.unscaled(finished.start) }); finished.finish(); @@ -4306,11 +4307,11 @@ test("a drop below the window is reported once the window lowers to it", () => { test("a re-created cut group is served, not dropped", async () => { const producer = new TrackProducer("video").accept({}); const reader = producer.subscribe({ delay: { max: Duration.millis(60_000) } }); - const cut = producer.createGroup(4n); + const cut = defined(producer.createGroup(4n)); cut.abort(new Error("cut")); await settle(); - producer.createGroup(4n); + defined(producer.createGroup(4n)); await settle(); const recv = hooks.tryRecvGroup(reader, true); expect(recv.kind === "group" ? recv.group.start : recv).toBe(4n); @@ -4326,7 +4327,7 @@ test("a reported drop still allows a late group, handed out once", () => { hooks.dropTrackGroups(producer, 2n, 4n, { error: DROPPED }); expect(hooks.tryRecvGroup(reader, true)).toEqual({ kind: "drop", start: 2n, end: 4n, error: DROPPED }); expect(hooks.tryRecvGroup(reader, true)).toEqual({ kind: "idle" }); - producer.createGroup(3n).finish(); + defined(producer.createGroup(3n)).finish(); const recv = hooks.tryRecvGroup(reader, true); expect(recv.kind === "group" ? recv.group.start : recv).toBe(3n); if (recv.kind === "group") recv.group.close(); @@ -4378,7 +4379,7 @@ test("a superseded stale run is unknown again, and its group is handed out", () hooks.dropTrackGroups(producer, 1n, 2n, staleHole(500)); hooks.supersedeStale(producer); expect(hooks.tryDrop(reader)).toBeUndefined(); - producer.createGroup(1n).finish(); + defined(producer.createGroup(1n)).finish(); const recv = hooks.tryRecvGroup(reader, true); expect(recv.kind === "group" ? recv.group.start : recv).toBe(1n); if (recv.kind === "group") recv.group.close(); @@ -4448,7 +4449,7 @@ test("a mid-group end survives eviction and a filtered late reader", async () => const producer = new TrackProducer("video").accept({}); try { producer.finishAt({ group: 5n, frame: 5 }); - const group = producer.createGroup(5n); + const group = defined(producer.createGroup(5n)); for (let i = 0; i < 5; i++) group.writeFrame({ payload: new Uint8Array([i]), timestamp: Timestamp.unscaled(group.start) }); group.finish(); @@ -4490,7 +4491,7 @@ test("a wire end repeats or refines but never moves", () => { // end says does not exist. test("a mid-group end refuses to cut existing frames", () => { const producer = new TrackProducer("video").accept({}); - const group = producer.createGroup(5n); + const group = defined(producer.createGroup(5n)); for (let i = 0; i < 6; i++) group.writeFrame({ payload: new Uint8Array([i]), timestamp: Timestamp.unscaled(group.start) }); expect(() => producer.finishAt({ group: 5n, frame: 5 })).toThrow(ProtocolViolation); @@ -4506,7 +4507,7 @@ test.each([true, false])("a mid-group end caps later writes (declared first: %s) const end = { group: 5n, frame: 2 }; if (early) producer.finishAt(end); - const group = producer.createGroup(5n); + const group = defined(producer.createGroup(5n)); group.writeFrame({ payload: new Uint8Array([0]), timestamp: Timestamp.unscaled(group.start) }); if (!early) producer.finishAt(end); group.writeFrame({ payload: new Uint8Array([1]), timestamp: Timestamp.unscaled(group.start) }); @@ -4514,7 +4515,7 @@ test.each([true, false])("a mid-group end caps later writes (declared first: %s) group.writeFrame({ payload: new Uint8Array([2]), timestamp: Timestamp.unscaled(group.start) }), ).toThrow("past the track's end"); expect(group.consume().frameCount).toBe(2); - expect(() => producer.createGroup(6n)).toThrow(); + expect(() => defined(producer.createGroup(6n))).toThrow(); producer.finish(); producer.close(); }); @@ -4522,7 +4523,7 @@ test.each([true, false])("a mid-group end caps later writes (declared first: %s) // A closed group `sequence` written into `producer` whose one frame starts at `ms`, aborted // as ingest does when that frame is refused. function stampGroup(producer: TrackProducer, key: bigint, ms: number): GroupProducer { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); try { group.writeFrame({ payload: enc.encode(`${ms}`), timestamp: Timestamp.fromMillis(ms) }); } catch (err) { @@ -4543,7 +4544,7 @@ test("a re-created group is handed out once", () => { const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI, maxAge: Duration.millis(30_000) }); const subscriber = producer.subscribe({ delay: { max: Duration.millis(30_000) } }); stampGroup(producer, 0n, 0); - const aborted = producer.createGroup(1n); + const aborted = defined(producer.createGroup(1n)); expect(drainGroups(subscriber)).toEqual([0n, 1n]); aborted.abort(new Error("aborted")); @@ -4661,11 +4662,11 @@ test("a rewind is refused whichever group lands first", () => { // that start as the watermark, and no later group can start before it. test("a replaced aborted group still bounds later ones", () => { const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI }); - const first = producer.createGroup(0n); + const first = defined(producer.createGroup(0n)); first.writeFrame({ payload: enc.encode("1000"), timestamp: Timestamp.fromMillis(1000) }); first.abort(new Error("aborted")); - const replacement = producer.createGroup(0n); + const replacement = defined(producer.createGroup(0n)); replacement.writeFrame({ payload: enc.encode("500"), timestamp: Timestamp.fromMillis(500) }); replacement.finish(); expect(() => stampGroup(producer, 1n, 600)).toThrow(TimestampMismatch); @@ -4693,7 +4694,7 @@ test("a rewind across large timescales is refused", () => { test("a group's first frame is checked against the group below it", () => { const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI }); stampGroup(producer, 1n, 6000); - const group = producer.createGroup(2n); + const group = defined(producer.createGroup(2n)); expect(() => group.writeFrame({ payload: enc.encode("early"), timestamp: Timestamp.fromMillis(5000) })).toThrow( TimestampMismatch, ); @@ -4747,7 +4748,7 @@ test("an evicted group still bounds, and a late group below it is unverified", a test("an untimed track takes groups in any order", () => { const producer = new TrackProducer("test").accept({}); for (const key of [5n, 3n, 4n]) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.writeFrame({ payload: enc.encode(`${key}`), timestamp: Timestamp.unscaled(group.start) }); group.finish(); } @@ -4757,7 +4758,7 @@ test("replay and backlogs deliver sparse out-of-order arrivals ascending without const producer = new TrackProducer("test").accept({ maxAge: null }); const all = { ranges: [{ start: { time: 0n } }], delay: { max: null } }; const write = (key: bigint) => { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.writeFrame({ payload: enc.encode(`${key}`), timestamp: Timestamp.unscaled(group.start) }); group.finish(); }; @@ -4800,7 +4801,7 @@ function pendingTail(end: bigint, maxDelay = Duration.millis(60_000)) { hooks.startTrack(producer, { start: 0n }); hooks.endTrack(producer, { group: end, frame: 0 }); const write = (key: bigint) => { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.finish(); }; return { producer, reader, write }; @@ -4823,14 +4824,14 @@ test("a received end behind a hole settles only once the hole fills", async () = const reader = producer.subscribe({ delay: { max: Duration.millis(60_000) } }); hooks.receiveTrack(producer); hooks.startTrack(producer, { start: 0n }); - const late = producer.createGroup(2n); + const late = defined(producer.createGroup(2n)); late.finish(); hooks.endTrack(producer, { group: 3n, frame: 0 }); await settle(); expect(producer.closed.peek()).toBeUndefined(); for (const key of [0n, 1n]) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.finish(); } await settle(); @@ -4879,7 +4880,7 @@ test("an end no subscription feeds owes no tail", async () => { ranges: [{ start: { time: 0n } }], delay: { max: Duration.millis(60_000) }, }); - const group = producer.createGroup(2n); + const group = defined(producer.createGroup(2n)); group.finish(); hooks.endTrack(producer, { group: 3n, frame: 0 }); const live = producer.subscribe({ ranges: [{ start: { time: 2n } }], delay: { max: Duration.millis(60_000) } }); @@ -4901,7 +4902,7 @@ test("an end refined after the subscription ended owes no tail", async () => { ranges: [{ start: { time: 0n } }], delay: { max: Duration.millis(60_000) }, }); - const group = producer.createGroup(2n); + const group = defined(producer.createGroup(2n)); group.writeFrame({ payload: new Uint8Array([1]), timestamp: Timestamp.unscaled(group.start) }); group.finish(); hooks.endTrack(producer, { group: 3n, frame: 0 }); @@ -4921,7 +4922,7 @@ test("without a declared start, the first arrival stands in for it", async () => const producer = new TrackProducer("test"); const reader = producer.subscribe({ delay: { max: Duration.millis(60_000) } }); hooks.endTrack(producer, { group: 3n, frame: 0 }); - const group = producer.createGroup(2n); + const group = defined(producer.createGroup(2n)); group.finish(); expect((await reader.recvGroup())?.start).toBe(2n); expect(await reader.recvGroup()).toBeUndefined(); @@ -4970,7 +4971,7 @@ test("a pending tail owes from SUBSCRIBE_START while the demand keeps its floor" hooks.receiveTrack(producer); hooks.startTrack(producer, { start: 3n, requested: 1n }); hooks.endTrack(producer, { group: 4n, frame: 0 }); - const group = producer.createGroup(3n); + const group = defined(producer.createGroup(3n)); group.finish(); expect((await reader.recvGroup())?.start).toBe(3n); expect(await reader.recvGroup()).toBeUndefined(); @@ -4993,7 +4994,7 @@ test("an end after the highest group holds the reader at the hole", async () => const reader = producer.subscribe({ delay: { max: Duration.millis(60_000) } }); hooks.receiveTrack(producer); hooks.startTrack(producer, { start: 0n }); - const high = producer.createGroup(2n); + const high = defined(producer.createGroup(2n)); high.finish(); expect((await reader.recvGroup())?.start).toBe(2n); const next = reader.recvGroup(); @@ -5001,7 +5002,7 @@ test("an end after the highest group holds the reader at the hole", async () => hooks.endTrack(producer, { group: 3n, frame: 0 }); expect(await settled(next)).toBe(false); for (const key of [0n, 1n]) { - const low = producer.createGroup(key); + const low = defined(producer.createGroup(key)); low.finish(); } expect((await next)?.start).toBe(0n); @@ -5338,7 +5339,7 @@ test("reading a shed frame head requests refresh", async () => { test("a failed track keeps its history", async () => { const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI, maxAge: null }); for (const key of [0n, 1n]) { - const group = producer.createGroup(key); + const group = defined(producer.createGroup(key)); group.writeFrame(textFrame("a", Timestamp.fromMillis(Number(key)))); group.finish(); @@ -5375,12 +5376,12 @@ test("a failed track keeps its history", async () => { test("fail ends at the live edge and leaves an end already given", async () => { const failed = new StreamError(StreamCode(71)); const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI, maxAge: null }); - const latest = producer.createGroup(2n); + const latest = defined(producer.createGroup(2n)); latest.writeFrame(textFrame("c", Timestamp.fromMillis(2))); latest.finish(); producer.fail(failed); - expect(() => producer.createGroup(3n)).toThrow(); - const late = producer.createGroup(1n); + expect(() => defined(producer.createGroup(3n))).toThrow(); + const late = defined(producer.createGroup(1n)); late.writeFrame(textFrame("b", Timestamp.fromMillis(1))); late.finish(); const sub = producer.subscribe({ ranges: [{ start: { time: 1n } }], delay: { max: Duration.millis(30_000) } }); @@ -5425,16 +5426,16 @@ test("an append skips the holes created groups left below it", () => { } return got; }; - producer.createGroup(0n).finish(); + defined(producer.createGroup(0n)).finish(); hooks.dropTrackGroups(producer, 2n, 3n, { error: DROPPED }); - producer.createGroup(4n).finish(); + defined(producer.createGroup(4n)).finish(); expect(drain()).toEqual([[2n, 3n, false], 0n, 4n]); hooks.appendNext(producer).finish(); expect(drain()).toEqual([[1n, 4n, true], 5n]); // The next append only names what was left since this one. - producer.createGroup(7n).finish(); + defined(producer.createGroup(7n)).finish(); hooks.appendNext(producer).finish(); expect(drain()).toEqual([[6n, 7n, true], 7n, 8n]); @@ -5442,8 +5443,8 @@ test("an append skips the holes created groups left below it", () => { hooks.receiveTrack(copy); copy.accept({ maxAge: null }); const late = copy.subscribe({ delay: { max: null } }); - copy.createGroup(0n).finish(); - copy.createGroup(2n).finish(); + defined(copy.createGroup(0n)).finish(); + defined(copy.createGroup(2n)).finish(); hooks.appendNext(copy).finish(); expect(hooks.tryRecvGroup(late, true)).toMatchObject({ kind: "group" }); expect(hooks.tryRecvGroup(late, true)).toMatchObject({ kind: "group" }); @@ -5455,10 +5456,10 @@ test("an append skips the holes created groups left below it", () => { test("a late local group reaches a reader, since creating out of order skips nothing", () => { const producer = new TrackProducer("test"); producer.accept({ maxAge: null }); - producer.createGroup(0n).finish(); - producer.createGroup(2n).finish(); + defined(producer.createGroup(0n)).finish(); + defined(producer.createGroup(2n)).finish(); const reader = producer.subscribe({ delay: { max: null }, order: "ascending" }); - producer.createGroup(1n).finish(); + defined(producer.createGroup(1n)).finish(); const got: bigint[] = []; for (let group = reader.tryRecvGroup(); group; group = reader.tryRecvGroup()) got.push(group.start); expect(got).toEqual([0n, 1n, 2n]); @@ -5470,7 +5471,7 @@ test("declared skips up to the end settle the track", async () => { const producer = new TrackProducer("test"); producer.accept({}); const reader = producer.subscribe({ delay: { max: null }, order: "ascending" }); - producer.createGroup(0n).finish(); + defined(producer.createGroup(0n)).finish(); // Group 0's finish settles first, so only the skip can reach the end. await yieldNow(); producer.finishAt({ group: 3n, frame: 0 }); @@ -5488,28 +5489,28 @@ test("declared skips up to the end settle the track", async () => { test("creating a skipped sequence throws Skipped", () => { const producer = new TrackProducer("test"); producer.accept({}); - producer.createGroup(0n).finish(); - producer.createGroup(3n).finish(); + defined(producer.createGroup(0n)).finish(); + defined(producer.createGroup(3n)).finish(); hooks.appendNext(producer).finish(); - expect(() => producer.createGroup(1n)).toThrow(Skipped); + expect(() => defined(producer.createGroup(1n))).toThrow(Skipped); producer.skipGroups(5n, 7n); - expect(() => producer.createGroup(6n)).toThrow(Skipped); + expect(() => defined(producer.createGroup(6n))).toThrow(Skipped); // No skip below group 0. expect(() => producer.skipGroups(-1n, 1n)).toThrow(RangeError); // The next sequence, 5, was skipped too. expect(() => hooks.appendNext(producer)).toThrow(Skipped); // A later drop leaves a skipped sequence skipped. expect(hooks.dropTrackGroups(producer, 1n, 2n, { error: DROPPED })).toEqual([]); - expect(() => producer.createGroup(1n)).toThrow(Skipped); + expect(() => defined(producer.createGroup(1n))).toThrow(Skipped); // A dropped sequence may be created again. hooks.dropTrackGroups(producer, 9n, 10n, { error: DROPPED }); - producer.createGroup(9n).finish(); + defined(producer.createGroup(9n)).finish(); const other = new TrackProducer("test"); other.accept({}); const reader = other.subscribe({ delay: { max: null } }); - other.createGroup(1n).finish(); + defined(other.createGroup(1n)).finish(); hooks.dropTrackGroups(other, 3n, 4n, { error: DROPPED }); hooks.dropTrackGroups(other, 4n, 5n, staleHole(1000)); other.skipGroups(0n, 5n); @@ -5544,10 +5545,10 @@ test("a skip is reported over a reported drop", () => { } return got; }; - producer.createGroup(0n).finish(); + defined(producer.createGroup(0n)).finish(); hooks.dropTrackGroups(producer, 1n, 3n, { error: DROPPED }); hooks.dropTrackGroups(producer, 4n, 5n, { error: DROPPED }); - producer.createGroup(5n).finish(); + defined(producer.createGroup(5n)).finish(); expect(drain()).toEqual([[1n, 3n, false], [4n, 5n, false], 0n, 5n]); // Group 0 arrived, so the skip leaves it; both drops and the gap between become one skip. @@ -5556,7 +5557,7 @@ test("a skip is reported over a reported drop", () => { expect(hooks.dropTrackGroups(producer, 2n, 3n, { error: DROPPED })).toEqual([]); expect(drain()).toEqual([]); - expect(() => producer.createGroup(2n)).toThrow(Skipped); + expect(() => defined(producer.createGroup(2n))).toThrow(Skipped); reader.close(); producer.close(); }); @@ -5569,13 +5570,13 @@ test("a huge skip costs one run", () => { const producer = new TrackProducer("test"); producer.accept({ maxAge: null }); const reader = producer.subscribe({ delay: { max: null } }); - producer.createGroup(0n).finish(); + defined(producer.createGroup(0n)).finish(); if (append) { - producer.createGroup(FAR).finish(); + defined(producer.createGroup(FAR)).finish(); hooks.appendNext(producer).finish(); } else { producer.skipGroups(1n, FAR); - producer.createGroup(FAR).finish(); + defined(producer.createGroup(FAR)).finish(); } const got: unknown[] = []; for ( @@ -5596,10 +5597,10 @@ test("a huge skip costs one run", () => { test("the reserved sequence is refused", () => { const reserved = (1n << 64n) - 1n; const producer = new TrackProducer("test").accept({}); - expect(() => producer.createGroup(1n << 64n)).toThrow(RangeError); - expect(() => producer.createGroup(reserved)).toThrow(RangeError); + expect(() => defined(producer.createGroup(1n << 64n))).toThrow(RangeError); + expect(() => defined(producer.createGroup(reserved))).toThrow(RangeError); expect(() => hooks.receiveGroup(producer, { start: reserved, offset: 0 })).toThrow(RangeError); - producer.createGroup(reserved - 1n).finish(); + defined(producer.createGroup(reserved - 1n)).finish(); expect(() => hooks.appendNext(producer)).toThrow(RangeError); // A run's exclusive end may sit at the reserved sequence, never past it. producer.skipGroups(1n << 63n, reserved); @@ -5611,13 +5612,13 @@ test("the reserved sequence is refused", () => { test("finishing returns handles that write nothing new but fill a late group", async () => { const producer = new TrackProducer("test"); const subscriber = producer.subscribe({ delay: { max: null }, ranges: [{ start: { time: 0n } }] }); - producer.createGroup(1n).finish(); + defined(producer.createGroup(1n)).finish(); const finished = producer.finish(); // @ts-expect-error a finished track appends no group expect(() => finished.appendGroup(Timestamp.unscaled(2n))).toThrow("at or past the track's end"); - expect(() => finished.createGroup(2n)).toThrow("at or past the track's end"); + expect(() => defined(finished.createGroup(2n))).toThrow("at or past the track's end"); - const late = finished.createGroup(0n); + const late = defined(finished.createGroup(0n)); late.writeFrame(textFrame("late", Timestamp.fromMillis(Number(late.start)))); const group = late.finish(); // @ts-expect-error a finished group takes no frame diff --git a/js/net/src/track.ts b/js/net/src/track.ts index a3af08b4981..b360b096e48 100644 --- a/js/net/src/track.ts +++ b/js/net/src/track.ts @@ -1359,7 +1359,7 @@ export class Producer { name, accept: (key, info) => { if (info !== undefined && this.#state.info.peek() === undefined) this.accept(info); - return this.#createGroup(key, 0, true); + return this.#createGroup(key, 0, true) ?? duplicate(key); }, drop: (start, end, hole) => { this.#drop(start, end, hole); @@ -1502,7 +1502,7 @@ export class Producer { producer.#placing++; }; hooks.receiveGroup = (producer, { start: sequence, offset: start, fill }) => - producer.#createGroup(sequence, start, fill); + producer.#createGroup(sequence, start, fill) ?? duplicate(sequence); hooks.arrivingGroup = (producer, key) => { const group = producer.#cached.get(key)?.group; if (!group || group.closed.peek() !== undefined) return undefined; @@ -2529,17 +2529,17 @@ export class Producer { * key already skipped throws {@link Skipped}, and the reserved key 2^64-1 a * `RangeError`. * - * Throws on a key that is still cached: a live duplicate would fan out to every - * subscriber twice. An aborted incarnation is evicted so a fresh group can serve the + * Returns `undefined` for a key that is still cached: a live duplicate would fan out to + * every subscriber twice. An aborted incarnation is evicted so a fresh group can serve the * key again. Best effort (mirrors Rust): nothing remembers a key whose cache * entry is already gone, so a long-evicted key is accepted as new. Its frames are * checked like {@link appendGroup}'s. */ - createGroup(key: bigint): GroupProducer { + createGroup(key: bigint): GroupProducer | undefined { return this.#createGroup(key, 0); } - #createGroup(key: bigint, start: number, fetched = false): GroupProducer { + #createGroup(key: bigint, start: number, fetched = false): GroupProducer | undefined { this.#writable(key); // A skip says the key will never be produced, so it is final. A drop is not: a // publisher may re-create a group it cut or aborted. @@ -2554,9 +2554,7 @@ export class Producer { this.#unlink(existing); this.#uncache(existing); } else if (existing) { - if (!failed) { - throw new Error(`duplicate group: key=${key}`); - } + if (!failed) return undefined; // A mirror the failed copy kept open, held for a duplicate, is the new copy's to continue. for (const [sink, mirror] of existing.mirrors) { if (mirror.closed.peek() !== undefined || !hooks.readsMirrored(mirror)) continue; @@ -2914,6 +2912,12 @@ function late(): Hole { return { error: new StreamError(StreamCode.Old, { message: "group landed after the read passed it" }) }; } +// Refuse a copy of `key` the track already holds, where a caller has already ruled it out or a +// received copy collides with one the cache answers from. +function duplicate(key: bigint): never { + throw new Error(`duplicate group: key=${key}`); +} + // A group missing its head that no fill could serve. function headless(): Hole { return { error: new StreamError(StreamCode.NotFound, { message: "group head never served" }) }; @@ -2981,7 +2985,7 @@ export interface Finished { /** The track's info, once accepted. */ info(): Promise; /** Create an older group below the end, which arrived late; see {@link Producer.createGroup}. */ - createGroup(key: bigint): GroupProducer; + createGroup(key: bigint): GroupProducer | undefined; /** Serve the groups readers miss below the end; see {@link Producer.requests}. */ requests(): Requests; /** Subscribe to this in-process track; see {@link Producer.subscribe}. */ diff --git a/js/net/src/untimed.test.ts b/js/net/src/untimed.test.ts index 9cc3253b9d5..f2fed35c097 100644 --- a/js/net/src/untimed.test.ts +++ b/js/net/src/untimed.test.ts @@ -62,7 +62,7 @@ async function roundTrip(wire: Wire, timescale: Timescale | undefined, timestamp const request = await wireOf(broadcast).requested(); if (!request) break; const track = request.accept({ timescale }); - const group = key === undefined ? hooks.appendNext(track) : track.createGroup(key); + const group = key === undefined ? hooks.appendNext(track) : defined(track.createGroup(key)); for (const [i, timestamp] of timestamps.entries()) { group.writeFrame({ payload: new Uint8Array([i]), timestamp }); } @@ -95,7 +95,7 @@ async function republish(input: BroadcastConsumer): Promise { const groups = subscription.ordered(); for (let group = await groups.nextGroup(); group; group = await groups.nextGroup()) { // The same group, so a scale-less frame's key still names it. - const out = video.createGroup(group.start); + const out = defined(video.createGroup(group.start)); for (let frame = await group.readFrame(); frame; frame = await group.readFrame()) out.writeFrame(frame); out.finish(); } diff --git a/js/watch/src/audio/decoder.test.ts b/js/watch/src/audio/decoder.test.ts index 36265d812ec..5d6c72c68a3 100644 --- a/js/watch/src/audio/decoder.test.ts +++ b/js/watch/src/audio/decoder.test.ts @@ -1655,7 +1655,7 @@ async function livePlayback(burst: number) { held.push(frame * FRAME); if (held.length < burst) continue; for (const timestamp of held) { - const group = track.createGroup(sequence++); + const group = defined(track.createGroup(sequence++)); group.writeFrame(legacyFrame(Duration.millis(timestamp))); group.finish(); } diff --git a/js/watch/src/audio/playout.test.ts b/js/watch/src/audio/playout.test.ts index 31c7ed15e4e..b68cbeafa2c 100644 --- a/js/watch/src/audio/playout.test.ts +++ b/js/watch/src/audio/playout.test.ts @@ -7,6 +7,7 @@ import { Signal } from "@moq/signals"; import { STRETCH } from "../sync"; import { maxDelay, target } from "./latency"; import { AudioRingBuffer } from "./ring-buffer"; +import { defined } from "../defined.test-util.ts"; // Replay recorded-shape arrival traces through the ring and count what a listener would hear: // quanta rendered short (an underrun) and samples the ring threw away (a skip). The ring is sized @@ -104,7 +105,7 @@ async function measure(t: Arrival[], budget: (target: Duration) => Duration): Pr clock.jump(Duration.millis(arrival).saturatingSub(clock.now().since(Instant.ZERO))); for (; next < t.length && t[next].arrival === arrival; next++) { const media = t[next].media * 1000; - const group = track.createGroup(BigInt(next)); + const group = defined(track.createGroup(BigInt(next))); group.writeFrame({ payload: encode(media), timestamp: Time.Timestamp.fromMicros(media) }); group.finish(); } diff --git a/js/watch/src/audio/replay.ts b/js/watch/src/audio/replay.ts index 51706123613..56b6374b1c0 100644 --- a/js/watch/src/audio/replay.ts +++ b/js/watch/src/audio/replay.ts @@ -386,7 +386,9 @@ export async function* replay(trace: Arrival[], options: Options): AsyncGenerato if (!group) { const from = skipped.get(arrival.group); if (from !== undefined) track.skipGroups(BigInt(from), BigInt(arrival.group)); - group = track.createGroup(BigInt(arrival.group)); + const created = track.createGroup(BigInt(arrival.group)); + if (!created) throw new Error(`the trace reopens group ${arrival.group}`); + group = created; groups.set(arrival.group, group); } const timestamp = micros(arrival.timestamp); diff --git a/js/watch/src/video/decoder.test.ts b/js/watch/src/video/decoder.test.ts index 321752e0ba0..2704062e21c 100644 --- a/js/watch/src/video/decoder.test.ts +++ b/js/watch/src/video/decoder.test.ts @@ -1132,7 +1132,7 @@ function liveVideo(clock: ReturnType, track: Moq.Track.Producer held.push(frame * FRAME); if (held.length < this.burst) continue; for (const media of held) { - const group = track.createGroup(sequence++); + const group = defined(track.createGroup(sequence++)); group.writeFrame(legacyFrame(Duration.millis(media))); group.finish(); } @@ -1242,7 +1242,7 @@ it("a resumed video track keeps its estimate, so one late burst does not raise t for (const media of queued.splice(0)) { if (media % (FRAME * GOP) === 0) { group?.finish(); - group = track.createGroup(BigInt(media / (FRAME * GOP))); + group = defined(track.createGroup(BigInt(media / (FRAME * GOP)))); } group?.writeFrame(legacyFrame(Duration.millis(media))); } @@ -1491,7 +1491,7 @@ it("buffered video holds its poster until its own span reaches the floor", async const clock = manualAt(0); const playback = await guardedPlayback("legacy", [], [], true, 1000); if (!playback.track) throw new Error("missing video track"); - const group = playback.track.createGroup(0n); + const group = defined(playback.track.createGroup(0n)); try { group.writeFrame(legacyFrame(Duration.micros(0))); group.writeFrame(legacyFrame(Duration.micros(40_000))); @@ -1543,11 +1543,11 @@ it("buffered video starts on a finished track whose holes park it at the max del const playback = await guardedPlayback("legacy", [], [], true, 1000); if (!playback.track) throw new Error("missing video track"); try { - const first = playback.track.createGroup(0n); + const first = defined(playback.track.createGroup(0n)); first.writeFrame(legacyFrame(Duration.micros(0))); first.finish(); // Group 1 never arrives. - const second = playback.track.createGroup(2n); + const second = defined(playback.track.createGroup(2n)); second.writeFrame(legacyFrame(Duration.micros(2_000_000))); second.finish(); await microtasks(); diff --git a/rs/libmoq/src/api.rs b/rs/libmoq/src/api.rs index d7ab441ac77..76805f08864 100644 --- a/rs/libmoq/src/api.rs +++ b/rs/libmoq/src/api.rs @@ -3727,7 +3727,8 @@ pub unsafe extern "C" fn moq_publish_track_group(track: u32, start: *const moq_t /// Create a raw group with an explicit start. /// -/// Returns a non-zero group handle on success, or a negative code on failure. +/// Returns a non-zero group handle on success, or a negative code on failure, including when +/// another live group holds the start. #[unsafe(no_mangle)] pub extern "C" fn moq_publish_track_group_at(track: u32, start: u64) -> i32 { ffi::enter(move || { diff --git a/rs/libmoq/src/consume.rs b/rs/libmoq/src/consume.rs index 6c4bc9b0d79..6d97bd68b4e 100644 --- a/rs/libmoq/src/consume.rs +++ b/rs/libmoq/src/consume.rs @@ -1520,7 +1520,7 @@ mod read_tests { ); let timestamp = |us| moq_net::Timestamp::from_micros(us).unwrap(); let write = |start, us, payload: bytes::Bytes| { - let mut group = track.create_group(moq_net::group::Info { start }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start }).unwrap().unwrap(); format() .write( &mut group, @@ -1658,7 +1658,7 @@ mod tests { } fn write(&mut self, start: u64, micros: u64) { - let mut group = self.track.create_group(moq_net::group::Info { start }).unwrap(); + let mut group = self.track.create_group(moq_net::group::Info { start }).unwrap().unwrap(); hang::container::Frame { timestamp: moq_net::Timestamp::from_micros(micros).unwrap(), payload: bytes::Bytes::from_static(b"frame"), diff --git a/rs/libmoq/src/publish.rs b/rs/libmoq/src/publish.rs index 5fcf679ef4d..ae12b020e86 100644 --- a/rs/libmoq/src/publish.rs +++ b/rs/libmoq/src/publish.rs @@ -1239,7 +1239,10 @@ impl Publish { /// Create a raw group starting at `start`, in the track's timescale, which names it. pub fn track_group_at(&mut self, track: Id, start: u64) -> Result { let raw = self.tracks.get_mut(track).ok_or(Error::TrackNotFound)?; - let group = raw.inner.create_group(moq_net::group::Info { start })?; + let group = raw + .inner + .create_group(moq_net::group::Info { start })? + .ok_or(moq_net::Error::Duplicate)?; self.insert_group(group) } diff --git a/rs/libmoq/src/test.rs b/rs/libmoq/src/test.rs index c32f00b567a..eabe4ba3991 100644 --- a/rs/libmoq/src/test.rs +++ b/rs/libmoq/src/test.rs @@ -5429,7 +5429,7 @@ fn a_group_request_nobody_reads_is_withdrawn() { let producer = state.publish.track_producer(Id::try_from(track).unwrap()).unwrap(); let reader = producer.subscribe(ascending(7, None)); producer.start_at(10).unwrap(); - let mut group = producer.create_group(moq_net::group::Info { start: 10 }).unwrap(); + let mut group = producer.create_group(moq_net::group::Info { start: 10 }).unwrap().unwrap(); group .write_frame(moq_net::Timestamp::from_millis(10).unwrap(), &b"live"[..]) .unwrap(); @@ -5474,7 +5474,7 @@ fn a_rejected_group_request_binds_only_its_readers() { let mut state = State::lock(); let producer = state.publish.track_producer(Id::try_from(track).unwrap()).unwrap(); producer.start_at(10).unwrap(); - let mut group = producer.create_group(moq_net::group::Info { start: 10 }).unwrap(); + let mut group = producer.create_group(moq_net::group::Info { start: 10 }).unwrap().unwrap(); group .write_frame(moq_net::Timestamp::from_millis(10).unwrap(), &b"live"[..]) .unwrap(); diff --git a/rs/moq-archive/benches/producer.rs b/rs/moq-archive/benches/producer.rs index 01ce8c0fa15..064450a3171 100644 --- a/rs/moq-archive/benches/producer.rs +++ b/rs/moq-archive/benches/producer.rs @@ -29,7 +29,7 @@ fn setup(tracks: usize, groups: u64) -> (broadcast::Producer, Vec { - let group = self.producer.create_group(group::Info { start: sequence })?; + // A held start is a sequence the archive already gave. + let group = self + .producer + .create_group(group::Info { start: sequence })? + .ok_or(Error::Sequence)?; let open = self.open.insert(Open { group, sequence, diff --git a/rs/moq-archive/src/producer/backends.rs b/rs/moq-archive/src/producer/backends.rs index f2570d17b55..f4ac66109c1 100644 --- a/rs/moq-archive/src/producer/backends.rs +++ b/rs/moq-archive/src/producer/backends.rs @@ -32,7 +32,7 @@ fn source(groups: u64, chat: &[(u64, &[&str])]) -> (broadcast::Producer, [track: ) .unwrap(); for sequence in 0..groups { - let mut group = video.create_group(group::Info { start: sequence }).unwrap(); + let mut group = video.create_group(group::Info { start: sequence }).unwrap().unwrap(); for frame in 0..2 { let pts = Timestamp::from_millis(sequence * 1_000 + frame * 500).unwrap(); group.write_frame(pts, format!("v{sequence}.{frame}")).unwrap(); @@ -43,7 +43,7 @@ fn source(groups: u64, chat: &[(u64, &[&str])]) -> (broadcast::Producer, [track: .create_track(CHAT, track::Info::default().with_max_age(None)) .unwrap(); for (sequence, frames) in chat { - let mut group = text.create_group(group::Info { start: *sequence }).unwrap(); + let mut group = text.create_group(group::Info { start: *sequence }).unwrap().unwrap(); for frame in *frames { group .write_frame(moq_net::Timestamp::unscaled(*sequence), frame.to_string()) diff --git a/rs/moq-archive/src/producer/tests.rs b/rs/moq-archive/src/producer/tests.rs index ac6704b648a..232f274501e 100644 --- a/rs/moq-archive/src/producer/tests.rs +++ b/rs/moq-archive/src/producer/tests.rs @@ -45,7 +45,7 @@ fn ms(ms: u64) -> Timestamp { /// Write a whole group of `(pts, payload)` frames. fn group(track: &track::Producer, sequence: u64, frames: &[(u64, &str)]) { - let mut group = track.create_group(group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(group::Info { start: sequence }).unwrap().unwrap(); for (pts, payload) in frames { group.write_frame(ms(*pts), payload.to_string()).unwrap(); } @@ -269,7 +269,7 @@ async fn an_open_untimed_group_is_cut_at_each_flush() { let task = spawn(&store, &broadcast, config().with_flush(SECOND)); subscribed(&data).await; - let mut open = data.create_group(group::Info { start: 0 }).unwrap(); + let mut open = data.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(moq_net::Timestamp::unscaled(0), "a").unwrap(); settle().await; sleep(SECOND).await; @@ -306,7 +306,7 @@ async fn an_untimed_group_splits_by_wall_clock() { let task = spawn(&store, &broadcast, config()); subscribed(&data).await; - let mut open = data.create_group(group::Info { start: 0 }).unwrap(); + let mut open = data.create_group(group::Info { start: 0 }).unwrap().unwrap(); for payload in ["a", "b", "c", "d", "e"] { open.write_frame(moq_net::Timestamp::unscaled(0), payload).unwrap(); settle().await; @@ -315,7 +315,7 @@ async fn an_untimed_group_splits_by_wall_clock() { open.finish().unwrap(); settle().await; sleep(2 * SECOND).await; - let mut next = data.create_group(group::Info { start: 1 }).unwrap(); + let mut next = data.create_group(group::Info { start: 1 }).unwrap().unwrap(); next.write_frame(moq_net::Timestamp::unscaled(1), "f").unwrap(); next.finish().unwrap(); settle().await; @@ -347,7 +347,7 @@ async fn an_idle_track_is_flushed_within_the_bound() { let task = spawn(&store, &broadcast, config().with_flush(SECOND)); subscribed(&video).await; - let mut open = video.create_group(group::Info { start: 0 }).unwrap(); + let mut open = video.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ms(0), "a").unwrap(); settle().await; sleep(SECOND / 2).await; @@ -382,8 +382,8 @@ async fn a_restart_mid_group_loses_and_duplicates_nothing() { subscribed(&video).await; subscribed(&data).await; - let mut timed_group = video.create_group(group::Info { start: 0 }).unwrap(); - let mut untimed_group = data.create_group(group::Info { start: 0 }).unwrap(); + let mut timed_group = video.create_group(group::Info { start: 0 }).unwrap().unwrap(); + let mut untimed_group = data.create_group(group::Info { start: 0 }).unwrap().unwrap(); for (pts, payload) in [(0, "a"), (100, "b")] { timed_group.write_frame(ms(pts), payload).unwrap(); untimed_group @@ -443,7 +443,7 @@ async fn a_partial_group_resumes_after_its_last_stored_frame() { subscribed(&video).await; group(&video, 0, &[(0, "a")]); - let mut partial = video.create_group(group::Info { start: 1 }).unwrap(); + let mut partial = video.create_group(group::Info { start: 1 }).unwrap().unwrap(); partial.start_at(2).unwrap(); partial.write_frame(ms(500), "c").unwrap(); settle().await; @@ -538,7 +538,7 @@ async fn track_names_stay_one_segment_through_a_resume() { let task = spawn(&store, &broadcast, config().with_flush(SECOND)); for track in &tracks { subscribed(track).await; - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(moq_net::Timestamp::unscaled(0), "x").unwrap(); group.finish().unwrap(); } @@ -664,7 +664,7 @@ async fn markers_wait_for_the_listing_to_end() { subscribed(&audio).await; group(&video, 0, &[(0, "a")]); - let mut last = video.create_group(group::Info { start: 1 }).unwrap(); + let mut last = video.create_group(group::Info { start: 1 }).unwrap().unwrap(); last.write_frame(ms(1000), "b").unwrap(); last.write_frame(ms(1100), "c").unwrap(); // A mid-group end: frames 0 and 1 of group 1. diff --git a/rs/moq-audio/src/decode/consumer.rs b/rs/moq-audio/src/decode/consumer.rs index b867502132b..f07e85c2653 100644 --- a/rs/moq-audio/src/decode/consumer.rs +++ b/rs/moq-audio/src/decode/consumer.rs @@ -2966,7 +2966,7 @@ mod tests { let start = kio::clock::now(); for &(at, sequence, media) in events { tokio::time::advance(Duration::from_millis(at).saturating_sub(start.elapsed())).await; - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let frame = moq_mux::container::Frame { timestamp: Timestamp::from_micros(media * 1000).unwrap(), duration: None, @@ -3074,7 +3074,7 @@ mod tests { let container = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Audio); let payload: Bytes = vec![0u8; 160 * size_of::()].into(); let write = |sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let frame = moq_mux::container::Frame { timestamp: Timestamp::from_micros(sequence * 20_000).unwrap(), duration: None, @@ -3132,7 +3132,7 @@ mod tests { let container = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Audio); let payload: Bytes = vec![0u8; 160 * size_of::()].into(); let write = |sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let frame = moq_mux::container::Frame { timestamp: Timestamp::from_micros(sequence * 20_000).unwrap(), duration: None, @@ -3190,7 +3190,7 @@ mod tests { let container = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Audio); let payload: Bytes = vec![0u8; 160 * size_of::()].into(); let write = |sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let frame = moq_mux::container::Frame { timestamp: Timestamp::from_micros(sequence * 20_000).unwrap(), duration: None, diff --git a/rs/moq-cli/src/archive.rs b/rs/moq-cli/src/archive.rs index 5268574fdb7..888527aa083 100644 --- a/rs/moq-cli/src/archive.rs +++ b/rs/moq-cli/src/archive.rs @@ -430,7 +430,7 @@ mod tests { for path in ["live/a", "live/b", "other"] { let broadcast = origin.route(path, moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast.broadcast().create_track("video", info.clone()).unwrap(); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(Timestamp::from_millis(0).unwrap(), path).unwrap(); group.finish().unwrap(); broadcast.announce().unwrap(); @@ -486,7 +486,7 @@ mod tests { .with_max_age(Duration::from_secs(3600)); let broadcast = origin.route(path, moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast.broadcast().create_track("video", info).unwrap(); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(Timestamp::from_millis(0).unwrap(), path).unwrap(); group.finish().unwrap(); broadcast.announce().unwrap(); @@ -629,7 +629,7 @@ mod tests { .with_max_age(None); let video = source.create_track("video", info).unwrap(); for sequence in 0..2 { - let mut group = video.create_group(group::Info { start: sequence * 1000 }).unwrap(); + let mut group = video.create_group(group::Info { start: sequence * 1000 }).unwrap().unwrap(); let pts = Timestamp::from_millis(sequence * 1000).unwrap(); group.write_frame(pts, format!("frame {sequence}")).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-cli/src/play/video.rs b/rs/moq-cli/src/play/video.rs index fa53d483dc1..fc8bed60e83 100644 --- a/rs/moq-cli/src/play/video.rs +++ b/rs/moq-cli/src/play/video.rs @@ -864,7 +864,7 @@ mod tests { let write = |sequence, stamps: Vec| { let mut group = published .create_group(moq_net::group::Info { start: sequence }) - .unwrap(); + .unwrap().unwrap(); let frames: Vec<_> = stamps .into_iter() .enumerate() @@ -1303,7 +1303,7 @@ mod tests { let write = |sequence: u64| { let mut group = published .create_group(moq_net::group::Info { start: sequence }) - .unwrap(); + .unwrap().unwrap(); format().write(&mut group, &[frame(sequence * 100, true)]).unwrap(); group.finish().unwrap(); }; diff --git a/rs/moq-e2ee/src/tests.rs b/rs/moq-e2ee/src/tests.rs index 99f5d3409fc..b2571b19b03 100644 --- a/rs/moq-e2ee/src/tests.rs +++ b/rs/moq-e2ee/src/tests.rs @@ -641,7 +641,7 @@ fn one_name_keys_its_stream_and_datagram_tracks_apart() { let forged = net_track(&name); let mut reader = consuming.consume(forged.subscribe(subscribe_all()), "audio").unwrap(); - let mut group = forged.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = forged.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(ms(1), sealed).unwrap(); group.finish().unwrap(); assert_eq!( @@ -1240,7 +1240,7 @@ fn grouped_authentication_ends_track() { let mut key = pair.generation.key(semantic, Domain::Group).unwrap(); let mut payload = key.protect(1, 0, b"ok", MAX_GROUPED_PAYLOAD).unwrap().to_vec(); payload[0] ^= 1; - let mut bad = pair.net.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut bad = pair.net.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); bad.write_frame(ms(2), payload).unwrap(); bad.finish().unwrap(); @@ -1307,14 +1307,14 @@ fn grouped_failure_wakes_pending_reads_and_releases_demand() { // One authentic frame, then silence. The group and the track stay open. let semantic = pair.semantic.as_str(); let mut key = pair.generation.key(semantic, Domain::Group).unwrap(); - let mut open = pair.net.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut open = pair.net.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); let open_demand = open.demand(); open.write_frame(ms(1), key.protect(0, 0, b"ok", MAX_GROUPED_PAYLOAD).unwrap()) .unwrap(); let mut payload = key.protect(1, 0, b"nope", MAX_GROUPED_PAYLOAD).unwrap().to_vec(); payload[0] ^= 1; - let mut bad = pair.net.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut bad = pair.net.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); let bad_demand = bad.demand(); bad.write_frame(ms(2), payload).unwrap(); diff --git a/rs/moq-e2ee/src/track.rs b/rs/moq-e2ee/src/track.rs index 5f61c378049..7ee09761b08 100644 --- a/rs/moq-e2ee/src/track.rs +++ b/rs/moq-e2ee/src/track.rs @@ -57,11 +57,11 @@ impl Producer { /// /// # Errors /// - /// [`Error::Reuse`](crate::Error::Reuse) if `start` was already allocated, [`Error::Identity`](crate::Error::Identity) if - /// it exceeds `2^53-1`, or a net error. + /// [`Error::Reuse`](crate::Error::Reuse) if `start` was already allocated or another group + /// holds it, [`Error::Identity`](crate::Error::Identity) if it exceeds `2^53-1`, or a net error. pub fn create_group(&mut self, start: u64) -> Result { let (_, inner) = self.claim.allocate(Some(start), |start| { - Ok(self.inner.create_group(moq_net::group::Info { start })?) + self.inner.create_group(moq_net::group::Info { start })?.ok_or(crate::Error::Reuse) })?; Ok(self.group(inner)) } diff --git a/rs/moq-ffi/src/media.rs b/rs/moq-ffi/src/media.rs index 453b2453830..2329cc97588 100644 --- a/rs/moq-ffi/src/media.rs +++ b/rs/moq-ffi/src/media.rs @@ -1667,7 +1667,7 @@ mod read_tests { let (_broadcast, track, reader) = subscribe_warmup().await; let mut media = reader.reads.take(|_| Ok(())).unwrap(); let write = |start: u64, micros| { - let mut group = track.create_group(start.into()).unwrap(); + let mut group = track.create_group(start.into()).unwrap().unwrap(); moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Audio) .write( &mut group, @@ -1734,7 +1734,7 @@ mod read_tests { value, scale: Some(1_000_000), }; - let mut first = track.create_group(0u64.into()).unwrap(); + let mut first = track.create_group(0u64.into()).unwrap().unwrap(); format() .write( &mut first, @@ -1753,7 +1753,7 @@ mod read_tests { assert_eq!(frame.payload, b"encoded"); assert_eq!(frame.timestamp, micros(10_000)); assert!(frame.keyframe); - let mut marker = track.create_group(2u64.into()).unwrap(); + let mut marker = track.create_group(2u64.into()).unwrap().unwrap(); format() .write( &mut marker, @@ -1773,7 +1773,7 @@ mod read_tests { reader.next().await.unwrap(), Some(MoqMediaRead::End { end }) if end == micros(20_000) )); - let mut resumed = track.create_group(3u64.into()).unwrap(); + let mut resumed = track.create_group(3u64.into()).unwrap().unwrap(); format() .write( &mut resumed, diff --git a/rs/moq-ffi/src/producer.rs b/rs/moq-ffi/src/producer.rs index 7e5addeeef7..1d9825463ff 100644 --- a/rs/moq-ffi/src/producer.rs +++ b/rs/moq-ffi/src/producer.rs @@ -911,12 +911,14 @@ impl MoqTrackProducer { /// Create a group starting at `start`, in the track's timescale, which names it. /// /// Use this for sparse or replayed tracks: unlike [`append_group`](Self::append_group), it - /// declares nothing below it skipped. + /// declares nothing below it skipped. A start another live group holds is refused. pub fn create_group(&self, start: u64) -> Result, MoqError> { let _guard = crate::ffi::enter(); let mut phase = self.phase.lock().unwrap(); let raw = phase.raw()?; - let group = raw.create_group(moq_net::group::Info { start })?; + let group = raw + .create_group(moq_net::group::Info { start })? + .ok_or(moq_net::Error::Duplicate)?; Ok(Arc::new(MoqGroupProducer::from_inner(group))) } diff --git a/rs/moq-hls/src/export/mod.rs b/rs/moq-hls/src/export/mod.rs index 604e3ac7300..3b665fab0fd 100644 --- a/rs/moq-hls/src/export/mod.rs +++ b/rs/moq-hls/src/export/mod.rs @@ -1506,7 +1506,7 @@ mod tests { // Closed groups follow, and transmuxing one caches the init. for group in 2..5 { - let mut writing = media.create_group(group.into()).unwrap(); + let mut writing = media.create_group(group.into()).unwrap().unwrap(); write_keyframe(&mut writing, group); writing.finish().unwrap(); } @@ -1580,9 +1580,9 @@ mod tests { sequence: u64, ) -> (moq_net::track::Producer, moq_net::group::Producer) { let media = broadcast.create_track(name, timed()).unwrap(); - let mut open = media.create_group(sequence.into()).unwrap(); + let mut open = media.create_group(sequence.into()).unwrap().unwrap(); write_keyframe(&mut open, sequence); - let mut next = media.create_group((sequence + 1).into()).unwrap(); + let mut next = media.create_group((sequence + 1).into()).unwrap().unwrap(); write_keyframe(&mut next, sequence + 1); next.finish().unwrap(); (media, open) @@ -1631,11 +1631,11 @@ mod tests { let (origin, broadcast, _catalog, _video0) = inline_sibling().await; let media = broadcast.broadcast().create_track("video1", timed()).unwrap(); for sequence in 0..3 { - let mut group = media.create_group(sequence.into()).unwrap(); + let mut group = media.create_group(sequence.into()).unwrap().unwrap(); write_keyframe(&mut group, sequence); group.finish().unwrap(); } - let mut open = media.create_group(3u64.into()).unwrap(); + let mut open = media.create_group(3u64.into()).unwrap().unwrap(); write_keyframe(&mut open, 3); let broadcaster = Broadcaster::spawned(crate::resolved(&origin, "live").await, Config::default()); @@ -1870,7 +1870,7 @@ mod tests { ); for sequence in 0..3 { - let mut group = media.create_group(sequence.into()).unwrap(); + let mut group = media.create_group(sequence.into()).unwrap().unwrap(); write_keyframe(&mut group, sequence); group.finish().unwrap(); } @@ -1888,7 +1888,7 @@ mod tests { .unwrap(); let media = broadcast.broadcast().create_track("video1", timed()).unwrap(); for sequence in 0..4 { - let mut group = media.create_group(sequence.into()).unwrap(); + let mut group = media.create_group(sequence.into()).unwrap().unwrap(); write_keyframe(&mut group, sequence); group.finish().unwrap(); } @@ -3630,7 +3630,7 @@ mod tests { let mut group = self .track .create_group(moq_net::group::Info { start: sequence }) - .unwrap(); + .unwrap().unwrap(); for index in 0..frames.max(1) { let micros = (pts_ms + index * INTERVAL.as_millis() as u64 / 10) * 1_000; let frame = vp8_frame(micros, index == 0); @@ -3655,7 +3655,7 @@ mod tests { let mut group = self .track .create_group(moq_net::group::Info { start: sequence }) - .unwrap(); + .unwrap().unwrap(); let mut payload = KEYFRAME.to_vec(); payload[6..8].copy_from_slice(&width.to_le_bytes()); payload[8..10].copy_from_slice(&height.to_le_bytes()); @@ -3678,7 +3678,7 @@ mod tests { let mut group = self .track .create_group(moq_net::group::Info { start: sequence }) - .unwrap(); + .unwrap().unwrap(); let frame = vp8_frame(pts_ms * 1_000, true); hang::container::Frame { timestamp: frame.timestamp, @@ -4065,7 +4065,7 @@ mod tests { .step_by(100) .map(|ms| vp8_frame(ms * 1_000, ms == pts_ms)) .collect(); - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let bytes = muxer.fragment(sequence as u32, &frames, None).unwrap(); group.write_frame(frames[0].timestamp, bytes).unwrap(); group.finish().unwrap(); @@ -4644,7 +4644,7 @@ mod tests { "one group per millisecond of the interval" ); for sequence in 0..=cap { - let mut group = media.track.create_group(sequence.into()).unwrap(); + let mut group = media.track.create_group(sequence.into()).unwrap().unwrap(); let frame = vp8_frame(sequence, true); hang::container::Frame { timestamp: frame.timestamp, diff --git a/rs/moq-hls/src/server/include_tests.rs b/rs/moq-hls/src/server/include_tests.rs index 366686d0658..f7925856a8e 100644 --- a/rs/moq-hls/src/server/include_tests.rs +++ b/rs/moq-hls/src/server/include_tests.rs @@ -62,7 +62,7 @@ fn publish(origin: &moq_net::origin::Producer, path: &str, instance: &Instance, fn frames(track: &track::Producer, first: u64) { for sequence in first..first + 3 { // Keyed by its first frame's pts, in the track's microseconds. - let mut group = track.create_group((sequence * 2_000_000).into()).unwrap(); + let mut group = track.create_group((sequence * 2_000_000).into()).unwrap().unwrap(); hang::container::Frame { timestamp: Timestamp::from_secs(sequence * 2).unwrap(), payload: bytes::Bytes::from_static(if track.name() == "audio" { diff --git a/rs/moq-json/src/snapshot/mod.rs b/rs/moq-json/src/snapshot/mod.rs index ea9be1f32dc..0bd515f3eec 100644 --- a/rs/moq-json/src/snapshot/mod.rs +++ b/rs/moq-json/src/snapshot/mod.rs @@ -261,7 +261,7 @@ mod test { let waiter = kio::Waiter::noop(); // Group 0 delivers a value, then stays open with the reader parked on its next frame. - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); group .write_frame(moq_net::Timestamp::ZERO, Bytes::from_static(br#"{"a":1}"#)) .unwrap(); @@ -276,7 +276,7 @@ mod test { ); // The replacement arrives and the reader picks up where the value now lives. - let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); group .write_frame( moq_net::Timestamp::from_millis(1).unwrap(), @@ -298,7 +298,7 @@ mod test { let mut consumer = Consumer::::new(track.consume(), consumer::Config::default()); let waiter = kio::Waiter::noop(); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); group .write_frame(moq_net::Timestamp::ZERO, Bytes::from_static(br#"{"a":1}"#)) .unwrap(); diff --git a/rs/moq-mux/src/codec/h264/export.rs b/rs/moq-mux/src/codec/h264/export.rs index 751bfa02768..c28a472ef5e 100644 --- a/rs/moq-mux/src/codec/h264/export.rs +++ b/rs/moq-mux/src/codec/h264/export.rs @@ -218,14 +218,14 @@ mod tests { .unwrap(); // Group 0 (keyframe-starting group): one IDR frame. - let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_length_prefixed(&mut g0, 0, &[idr]); g0.finish().unwrap(); // Group 1 (next group): one P-slice. Consumer marks the first frame // of every group as keyframe by protocol invariant, so the exporter // MUST treat both group-starts as keyframes and inject SPS+PPS twice. - let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_length_prefixed(&mut g1, 33_000, &[p_slice]); g1.finish().unwrap(); let _track = track.finish().unwrap(); @@ -332,7 +332,7 @@ mod tests { let track = broadcast .create_track("video", hang::container::track_info(hang::catalog::PRIORITY.video)) .unwrap(); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); let nals: &[&[u8]] = &[&[0x67, 0x42, 0, 0x1f], &[0x68, 0xce], &[0x65, 0x88]]; write_length_prefixed(&mut group, 0, nals); group.finish().unwrap(); diff --git a/rs/moq-mux/src/codec/h265/export.rs b/rs/moq-mux/src/codec/h265/export.rs index 9d47e2dbabd..2fce54d0f62 100644 --- a/rs/moq-mux/src/codec/h265/export.rs +++ b/rs/moq-mux/src/codec/h265/export.rs @@ -208,11 +208,11 @@ mod tests { .create_track("video.hvc1", hang::container::track_info(hang::catalog::PRIORITY.video)) .unwrap(); - let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_length_prefixed(&mut g0, 0, &[idr]); g0.finish().unwrap(); - let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_length_prefixed(&mut g1, 33_000, &[trail]); g1.finish().unwrap(); let _track = track.finish().unwrap(); @@ -328,7 +328,7 @@ mod tests { let track = broadcast .create_track("video", hang::container::track_info(hang::catalog::PRIORITY.video)) .unwrap(); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); let nals: &[&[u8]] = &[&[0x40, 1, 0x0c], &[0x42, 1, 1], &[0x44, 1, 0xc0], &[0x26, 1, 0x88]]; write_length_prefixed(&mut group, 0, nals); group.finish().unwrap(); diff --git a/rs/moq-mux/src/container/consumer.rs b/rs/moq-mux/src/container/consumer.rs index 55209132670..78ba59763f2 100644 --- a/rs/moq-mux/src/container/consumer.rs +++ b/rs/moq-mux/src/container/consumer.rs @@ -1917,7 +1917,7 @@ mod tests { /// Write a finished group with explicit sequence and timestamps (Container::Legacy(crate::container::Kind::Data) format). fn write_group(track: &mut moq_net::track::Producer, sequence: u64, timestamps: &[Timestamp]) { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); for ×tamp in timestamps { let frame = Frame { timestamp, @@ -2012,7 +2012,7 @@ mod tests { } fn write_marker_group(track: &mut moq_net::track::Producer, sequence: u64, timestamp: Timestamp) { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Audio) .write( &mut group, @@ -2116,7 +2116,7 @@ mod tests { Container::Legacy(crate::container::Kind::Data), ); write_group(&mut track, 0, &[ts(0), ts(10_000)]); - let mut group = track.create_group(moq_net::group::Info { start: 20_000 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 20_000 }).unwrap().unwrap(); group.write_frame(ts(20_000), Bytes::new()).unwrap(); group.finish().unwrap(); let _track = track.finish().unwrap(); @@ -2134,7 +2134,7 @@ mod tests { let mut reader = Consumer::new(subscriber, Container::Legacy(crate::container::Kind::Data)); write_group(&mut track, 0, &[ts(10_000)]); assert!(matches!(reader.read().await.unwrap(), Some(Read::Frame { .. }))); - let mut marker = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); + let mut marker = track.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); marker.write_frame(ts(20_000), Bytes::new()).unwrap(); marker.finish().unwrap(); @@ -2191,7 +2191,7 @@ mod tests { reader.read().await.unwrap(), Some(Read::Frame { group: 2, .. }) )); - let mut marker = track.create_group(moq_net::group::Info { start: 4 }).unwrap(); + let mut marker = track.create_group(moq_net::group::Info { start: 4 }).unwrap().unwrap(); marker.write_frame(ts(30_000), Bytes::new()).unwrap(); marker.finish().unwrap(); assert!(reader.poll_read(&kio::Waiter::noop()).is_pending()); @@ -2234,7 +2234,7 @@ mod tests { )); assert_eq!(reader.arrival(), Some(second)); - let mut marker = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); + let mut marker = track.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); marker.write_frame(ts(66_000), Bytes::new()).unwrap(); marker.finish().unwrap(); assert!(matches!(reader.read().await.unwrap(), Some(Read::End { group: 2, .. }))); @@ -2330,7 +2330,7 @@ mod tests { async fn the_join_is_the_largest_at_the_answer_not_at_the_start() { let mut track = track_producer("data", hang::container::track_info(hang::catalog::PRIORITY.audio)); let landed = kio::clock::now(); - let mut open = track.create_group(moq_net::group::Info { start: 3 }).unwrap(); + let mut open = track.create_group(moq_net::group::Info { start: 3 }).unwrap().unwrap(); let subscriber = track.subscribe( moq_net::track::Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(1))), ); @@ -2516,7 +2516,7 @@ mod tests { }; // A stalled group 500 ms behind the newest content is still within the max delay. - let mut stalled = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut stalled = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); let frame = Frame { timestamp: ts(0), payload: Bytes::from_static(&[0xDE, 0xAD]), @@ -2711,14 +2711,14 @@ mod tests { ); reader.max_delay = Duration::ZERO; // The current group stays open, so only a skip moves past it. - let mut slow = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut slow = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); hang::container::Frame { timestamp: ts(0), payload: Bytes::from_static(b"a"), } .write_to(&mut slow) .unwrap(); - let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); group.write_frame(ts(10_000), Bytes::new()).unwrap(); hang::container::Frame { timestamp: ts(10_000), @@ -2773,7 +2773,7 @@ mod tests { Container::Legacy(crate::container::Kind::Data), ); write_group(&mut track, 0, &[ts(0)]); - let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); let mut objects = [Bytes::new(), second.clone()]; if !marker_first { objects.reverse(); @@ -2898,7 +2898,7 @@ mod tests { let mut reader = Consumer::new(subscription, Container::try_from(&config).unwrap()); // One 20 ms CELT packet per group. The group starting at 40 ms never arrives. for start in [0, 20_000, 60_000] { - let mut group = track.create_group(moq_net::group::Info { start }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start }).unwrap().unwrap(); let packet = Frame { timestamp: ts(start), payload: Bytes::from_static(&[31 << 3, 0]), @@ -2924,7 +2924,7 @@ mod tests { let mut reader = Consumer::new(subscription, Container::Legacy(crate::container::Kind::Audio)); reader.max_delay = Duration::ZERO; // Group 0 stays open, and is read before the newer group lands: the skip comes after the start. - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Audio) .write( &mut group, @@ -2952,7 +2952,7 @@ mod tests { let mut reader = Consumer::new(subscription, Container::Legacy(crate::container::Kind::Video)); let wire = Container::Legacy(crate::container::Kind::Video); for (sequence, start) in [(0, 0), (1, 33_000)] { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let frame = |timestamp: u64, payload| Frame { timestamp: ts(timestamp), payload, @@ -2982,7 +2982,7 @@ mod tests { ); let mut reader = Consumer::new(subscription, Container::Legacy(crate::container::Kind::Audio)); write_group(&mut track, 0, &[ts(0), ts(20_000)]); - let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); let frame = |timestamp: u64, payload| Frame { timestamp: ts(timestamp), payload, @@ -3049,7 +3049,7 @@ mod tests { write_group(&mut track, 0, &[ts(0)]); track .create_group(moq_net::group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); write_group(&mut track, 2, &[ts(1_000)]); @@ -3064,7 +3064,7 @@ mod tests { async fn a_live_edge_start_on_an_empty_group_moves_on() { let mut track = track_producer("test", hang::container::track_info(hang::catalog::PRIORITY.audio)); write_group(&mut track, 0, &[ts(0)]); - let _empty = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let _empty = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); let mut subscriber = track.subscribe( moq_net::track::Subscription::default().with_delay(Delay::default().with_max(Duration::from_millis(500))), @@ -3094,7 +3094,7 @@ mod tests { consumer.max_delay = Duration::ZERO; // Group 0 stays open, and is read before the newer group lands: the skip comes after the start. - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Audio) .write( &mut group, @@ -3163,7 +3163,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); // Group 0: 5 frames, NOT finished (blocks consumer) - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); for f in 0..5u64 { Container::Legacy(crate::container::Kind::Data) .write( @@ -3206,7 +3206,7 @@ mod tests { // Group 0 at ts 0 keeps timestamps monotonic with sequence (groups 1-9 follow at // g*50 ms), so the test exercises age skipping and not rewind detection. - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group0, @@ -3248,7 +3248,7 @@ mod tests { let consumer_track = track.subscribe(None); let mut consumer = container_max_delay_only(consumer_track, Duration::from_millis(100)); - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group0, @@ -3316,11 +3316,11 @@ mod tests { // A 2.5 s group, half arrived, and the next one already 0.5 s in. The reader started // before the next one landed, so this is a stall, not a join's backlog, which starts // within the budget instead (see `a_buffered_backlog_starts_within_the_budget`). - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write(&mut group0, ts(0)); write(&mut group0, ts(500_000)); assert_eq!(read(&mut consumer), Some(ts(0))); - let mut group1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write(&mut group1, ts(2_500_000)); write(&mut group1, ts(3_000_000)); @@ -3333,7 +3333,7 @@ mod tests { assert_eq!(read(&mut consumer), Some(ts(2_500_000))); // Once the reach falls a full budget behind, the stalled group is skipped. - let mut group2 = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); + let mut group2 = track.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); write(&mut group2, ts(5_000_000)); write(&mut group2, ts(7_000_000)); assert_eq!(read(&mut consumer), Some(ts(3_000_000))); @@ -3357,7 +3357,7 @@ mod tests { let timestamps: Vec<_> = (0..10).map(|f| ts(g * 1_000_000 + f * 100_000)).collect(); write_group(&mut track, g, ×tamps); } - let mut last = track.create_group(moq_net::group::Info { start: 5 }).unwrap(); + let mut last = track.create_group(moq_net::group::Info { start: 5 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut last, @@ -3401,7 +3401,7 @@ mod tests { for g in 0..4u64 { write_group(&mut track, g, &frames(g)); } - let mut fifth = track.create_group(moq_net::group::Info { start: 4 }).unwrap(); + let mut fifth = track.create_group(moq_net::group::Info { start: 4 }).unwrap().unwrap(); write_group(&mut track, 5, &[ts(5_000_000)]); let mut read = Vec::new(); @@ -3554,7 +3554,7 @@ mod tests { consumer.max_delay = Duration::from_millis(300); write_group(&mut track, 0, &[ts(0)]); // The end, then the stopped encoder's final packet, as `moq_audio`'s producer writes them. - let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); let frame = |timestamp, payload| Frame { timestamp, payload, @@ -3605,7 +3605,7 @@ mod tests { let mut consumer = Consumer::new(track.subscribe(None), Container::Legacy(crate::container::Kind::Audio)); consumer.max_delay = Duration::ZERO; - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Audio) .write( &mut group0, @@ -3675,7 +3675,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Video)); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); let media = |timestamp| Frame { timestamp, payload: Bytes::from_static(&[0xDE, 0xAD]), @@ -3707,7 +3707,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Video)); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_marker(&mut group, ts(20_000)); Container::Legacy(crate::container::Kind::Video) .write( @@ -3739,7 +3739,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Video)); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Video) .write( &mut group, @@ -3772,7 +3772,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Loc(crate::container::Kind::Video)); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); let media = Frame { timestamp: ts(0), payload: Bytes::from_static(&[0xDE, 0xAD]), @@ -3812,7 +3812,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group0, @@ -3977,7 +3977,7 @@ mod tests { let format = Container::Legacy(crate::container::Kind::Data); let mut consumer = Consumer::new(track, Container::Legacy(crate::container::Kind::Data)); - let mut open = first_track.create_group(0u64.into()).unwrap(); + let mut open = first_track.create_group(0u64.into()).unwrap().unwrap(); format .write( &mut open, @@ -4052,7 +4052,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); // Group 0: a frame the consumer reads, positioning it there. - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group0, @@ -4181,7 +4181,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); // Group 0's stream opens first but carries no frames yet; group 1's frame wins. - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_group(&mut track, 1, &[ts(100_000)]); // Startup latches onto the lowest arrived sequence and waits under the budget. @@ -4366,7 +4366,7 @@ mod tests { write_group(&mut track, 5, &[ts(5_000_000)]); // Group 4 covers the 4.92s target, and its first frame is read before the rest of it lands. - let mut covering = track.create_group(moq_net::group::Info { start: 4 }).unwrap(); + let mut covering = track.create_group(moq_net::group::Info { start: 4 }).unwrap().unwrap(); let write = |group: &mut moq_net::group::Producer, micros| { let frame = Frame { timestamp: ts(micros), @@ -4739,7 +4739,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, FailingDecode); // A decodable frame first (so the consumer reads the group), then a malformed one. - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); group .write_frame(moq_net::Timestamp::ZERO, Bytes::from(0u64.to_le_bytes().to_vec())) .unwrap(); @@ -4797,7 +4797,7 @@ mod tests { moq_net::track::Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(10))); let mut consumer = Consumer::new(track.subscribe(subscription), FailingDecode); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_failing(&mut group, None); write_failing(&mut group, Some(0)); group.finish().unwrap(); @@ -4817,7 +4817,7 @@ mod tests { let track = track_producer("test", timed()); let mut consumer = Consumer::new(track.subscribe(None), FailingDecode); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_failing(&mut group, None); write_failing(&mut group, Some(0)); group.finish().unwrap(); @@ -4839,11 +4839,11 @@ mod tests { moq_net::track::Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(10))); let mut consumer = Consumer::new(track.subscribe(subscription), FailingDecode); - let mut malformed = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut malformed = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_failing(&mut malformed, None); let malformed_demand = malformed.demand(); let _malformed = malformed.finish().unwrap(); - let mut later = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut later = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_failing(&mut later, Some(10_000)); let read = read_past_frames(&mut consumer).await; @@ -4864,9 +4864,9 @@ mod tests { let mut consumer = Consumer::new(track.subscribe(subscription), FailingDecode); // The current group stays open, so the reader looks ahead into the next one. - let mut slow = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut slow = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_failing(&mut slow, Some(0)); - let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_failing(&mut group, Some(10_000)); write_failing(&mut group, None); write_failing(&mut group, Some(20_000)); @@ -4901,14 +4901,14 @@ mod tests { moq_net::track::Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(10))); let mut consumer = Consumer::new(track.subscribe(subscription), FailingDecode); - let mut current = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut current = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_failing(&mut current, Some(0)); write_failing(&mut current, Some(10_000)); write_failing(&mut current, Some(20_000)); let first = consumer.read_frame().await.unwrap().unwrap(); assert_eq!(first.timestamp, ts(0)); - let mut later = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut later = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_failing(&mut later, None); later.finish().unwrap(); for expected in [10_000, 20_000] { @@ -4931,17 +4931,17 @@ mod tests { moq_net::track::Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(10))); let mut consumer = Consumer::new(track.subscribe(subscription), FailingDecode); - let mut current = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut current = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_failing(&mut current, Some(100_000)); let first = consumer.read_frame().await.unwrap().unwrap(); assert_eq!(first.timestamp, ts(100_000)); - let mut malformed = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut malformed = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_failing(&mut malformed, Some(110_000)); malformed.write_frame(ts(110_000), Bytes::from_static(b"FAIL")).unwrap(); malformed.finish().unwrap(); // The transport only checks a group's first frame, so the rewind is its second. - let mut rewound = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); + let mut rewound = track.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); write_failing(&mut rewound, Some(150_000)); write_failing(&mut rewound, Some(50_000)); rewound.finish().unwrap(); @@ -4968,10 +4968,10 @@ mod tests { moq_net::track::Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(10))); let mut consumer = Consumer::new(track.subscribe(subscription), FailingDecode).live(); - let mut old = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut old = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_failing(&mut old, None); old.finish().unwrap(); - let mut newest = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut newest = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_failing(&mut newest, Some(10_000)); newest.finish().unwrap(); let _track = track.finish().unwrap(); @@ -4990,12 +4990,12 @@ mod tests { moq_net::track::Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(10))); let mut consumer = Consumer::new(track.subscribe(subscription), FailingDecode); - let mut current = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut current = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_failing(&mut current, Some(0)); let first = consumer.read_frame().await.unwrap().unwrap(); assert_eq!(first.timestamp, ts(0)); - let mut later = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut later = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_failing(&mut later, None); // The reader looks ahead into the later group while it waits on the open one. assert!( @@ -5025,7 +5025,7 @@ mod tests { moq_net::track::Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(10))); let mut consumer = Consumer::new(track.subscribe(subscription), FailingDecode); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_failing(&mut group, Some(0)); write_failing(&mut group, None); let first = consumer.read_frame().await.unwrap().unwrap(); @@ -5043,7 +5043,7 @@ mod tests { fn the_lookahead_keeps_a_decode_error_before_an_evicted_tail() { let waiter = kio::Waiter::noop(); let track = track_producer("test", timed()); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_failing(&mut group, Some(0)); write_failing(&mut group, None); write_failing(&mut group, Some(10_000)); @@ -5076,7 +5076,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); let payload_bytes = vec![0x01, 0x02, 0x03, 0x04, 0x05]; - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group, @@ -5115,7 +5115,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group0, @@ -5206,7 +5206,7 @@ mod tests { // to avoid the age skip and test B-frame timestamp tracking. let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); for ×tamp in &[ts(0), ts(66_000), ts(33_000)] { Container::Legacy(crate::container::Kind::Data) .write( @@ -5261,7 +5261,7 @@ mod tests { write_group(&mut track, 3, &[ts(0)]); write_group(&mut track, 5, &[ts(150_000)]); - let mut group7 = track.create_group(moq_net::group::Info { start: 7 }).unwrap(); + let mut group7 = track.create_group(moq_net::group::Info { start: 7 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group7, @@ -5316,7 +5316,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - let _group5 = track.create_group(moq_net::group::Info { start: 5 }).unwrap(); + let _group5 = track.create_group(moq_net::group::Info { start: 5 }).unwrap().unwrap(); write_group(&mut track, 7, &[ts(210_000)]); // Group 5 is open and within budget: its frames may still arrive, so wait. @@ -5351,7 +5351,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); // Sequence 0 never arrives; sequence 1's stream opens but never carries a frame. - let group1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let group1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); let _track = track.finish().unwrap(); // While group 1 is open its frames may still come, so the consumer waits. @@ -5384,7 +5384,7 @@ mod tests { // Group 0's stream is open but its frames lose the race; the track boundary // arrives before them. - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_group(&mut track, 1, &[ts(100_000)]); let _track = track.finish().unwrap(); @@ -5618,7 +5618,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group0, @@ -5656,7 +5656,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group0, @@ -5695,7 +5695,7 @@ mod tests { let mut consumer = container_max_delay_only(consumer_track, Duration::from_millis(100)); // Group 0: stalled at ts=0, NOT finished - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group0, @@ -5754,7 +5754,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - let group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); group0.abort(moq_net::Error::Cancel).unwrap(); write_group(&mut track, 1, &[ts(30_000)]); @@ -5776,7 +5776,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); for timestamp in [ts(0), ts(10_000)] { let frame = Frame { timestamp, @@ -5815,7 +5815,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); let first = Frame { timestamp: ts(0), payload: Bytes::from(vec![0xDEu8; 1024]), @@ -5875,7 +5875,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - let group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); group0.finish().unwrap(); write_group(&mut track, 1, &[ts(30_000)]); @@ -5898,7 +5898,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); // Write frames using Container::Legacy(crate::container::Kind::Data) encoding - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); for i in 0..3u64 { let frame = Frame { timestamp: ts(i * 33_333), @@ -5945,11 +5945,11 @@ mod tests { let mut consumer = Consumer::new(consumer_track, DurationWire); // Group 0: one frame at ts=0 lasting 33ms, never finished. - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_duration_frame(&mut group0, ts(0), ts(33_000)); // Group 1: finished, starts exactly where group 0's frame ends. - let mut group1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_duration_frame(&mut group1, ts(33_000), ts(33_000)); group1.finish().unwrap(); @@ -5976,10 +5976,10 @@ mod tests { ), DurationWire, ); - let mut group0 = track.create_group(moq_net::group::Info { start: 1_000_000 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 1_000_000 }).unwrap().unwrap(); write_duration_frame(&mut group0, ts(0), ts(33_000)); group0.finish().unwrap(); - let mut group1 = track.create_group(moq_net::group::Info { start: 1_090_000 }).unwrap(); + let mut group1 = track.create_group(moq_net::group::Info { start: 1_090_000 }).unwrap().unwrap(); write_duration_frame(&mut group1, ts(33_000), ts(33_000)); group1.finish().unwrap(); let _track = track.finish().unwrap(); @@ -6001,11 +6001,11 @@ mod tests { let mut consumer = Consumer::new(consumer_track, DurationWire); // Group 0: frame at ts=0 lasting only 10ms, far short of group 1 at 33ms. - let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); write_duration_frame(&mut group0, ts(0), ts(10_000)); // Group 1: finished at 33ms. - let mut group1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_duration_frame(&mut group1, ts(33_000), ts(33_000)); group1.finish().unwrap(); let _track = track.finish().unwrap(); @@ -6070,7 +6070,7 @@ mod tests { sequence: u64, timestamp: Timestamp, ) -> moq_net::group::Producer { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group, @@ -6181,7 +6181,7 @@ mod tests { consumer.set_max_buffer(MAX_BUFFER); let _stalled = open_group(&mut track, 0, ts(0)); - let mut markers = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut markers = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); for _ in 0..2_000 { write_marker(&mut markers, ts(10_000)); } @@ -6243,7 +6243,7 @@ mod tests { ); let mut consumer = Consumer::new(subscriber, Container::Loc(crate::container::Kind::Data)); - let mut padded = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut padded = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); for i in 0..8 { let timestamp = i * 1_000; // An unknown video-config property (0x0d) padding the frame, then the timestamp (0x10). @@ -6287,7 +6287,7 @@ mod tests { consumer.set_max_buffer(2 * std::mem::size_of::>()); let _stalled = open_group(&mut track, 0, ts(0)); - let _empty = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let _empty = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); write_group(&mut track, 2, &[ts(20_000)]); let mut reads = Vec::new(); @@ -6313,8 +6313,8 @@ mod tests { consumer.poll_read(waiter), Poll::Ready(Ok(Some(Read::Frame { group: 0, .. }))) )); - let between = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); - let mut later = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); + let between = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); + let mut later = track.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut later, @@ -6388,7 +6388,7 @@ mod tests { let mut consumer = container_max_delay_only(track.subscribe(None), max_delay); consumer.set_max_buffer(4096); for sequence in 0..2u64 { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group, @@ -6402,7 +6402,7 @@ mod tests { .unwrap(); group.finish().unwrap(); } - let mut marker = track.create_group(moq_net::group::Info { start: 3 }).unwrap(); + let mut marker = track.create_group(moq_net::group::Info { start: 3 }).unwrap().unwrap(); marker.write_frame(ts(20_000), Bytes::new()).unwrap(); marker.finish().unwrap(); @@ -6427,7 +6427,7 @@ mod tests { async fn a_hole_in_a_drained_backlog_is_late_from_the_earliest_arrival_past_it() { let mut track = track_producer("test", hang::container::track_info(hang::catalog::PRIORITY.video)); let marker = |track: &mut moq_net::track::Producer, sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); group.write_frame(ts(sequence * 10_000), Bytes::new()).unwrap(); group.finish().unwrap(); }; @@ -6484,7 +6484,7 @@ mod tests { Container::Legacy(crate::container::Kind::Data), ); for sequence in 0..256 { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group, @@ -6519,7 +6519,7 @@ mod tests { Container::Legacy(crate::container::Kind::Data), ); write_group(&mut track, 0, &[ts(0)]); - let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group, diff --git a/rs/moq-mux/src/container/fmp4/import.rs b/rs/moq-mux/src/container/fmp4/import.rs index b93d302745c..7cf249c7bba 100644 --- a/rs/moq-mux/src/container/fmp4/import.rs +++ b/rs/moq-mux/src/container/fmp4/import.rs @@ -1623,7 +1623,10 @@ impl Passthrough { prev.finish()?; } match (self.pending_start.take(), start) { - (Some(start), _) => self.track.create_group(moq_net::group::Info { start })?, + (Some(start), _) => self + .track + .create_group(moq_net::group::Info { start })? + .ok_or(moq_net::Error::Duplicate)?, (None, Some(_)) => self.track.append_group(timestamp)?, (None, None) => unreachable!("a new group without a pending start has one"), } diff --git a/rs/moq-mux/src/container/producer.rs b/rs/moq-mux/src/container/producer.rs index dd077aeee83..59fe8cc071e 100644 --- a/rs/moq-mux/src/container/producer.rs +++ b/rs/moq-mux/src/container/producer.rs @@ -686,7 +686,10 @@ where return Err(super::MissingKeyframe.into()); } let group = match (self.pending_start.take(), start) { - (Some(start), _) => self.inner.create_group(moq_net::group::Info { start })?, + (Some(start), _) => self + .inner + .create_group(moq_net::group::Info { start })? + .ok_or(moq_net::Error::Duplicate)?, (None, Some(start)) => { // A track's first group says nothing came before it, so a reader can tell it // is the first: a decoder starting there needs no warmup. @@ -952,7 +955,10 @@ where self.pending_start = None; let mut group = match appended { true => self.inner.append_group(timestamp)?, - false => self.inner.create_group(moq_net::group::Info { start })?, + false => self + .inner + .create_group(moq_net::group::Info { start })? + .ok_or(moq_net::Error::Duplicate)?, }; match self.container.kind() { Kind::Data => group.write_frame(timestamp, Bytes::new())?, diff --git a/rs/moq-mux/src/container/source.rs b/rs/moq-mux/src/container/source.rs index 037b8262074..6bce43f9001 100644 --- a/rs/moq-mux/src/container/source.rs +++ b/rs/moq-mux/src/container/source.rs @@ -1295,7 +1295,7 @@ mod tests { // One 24 ms frame per group, as the TS import publishes MPEG-1 audio. let wire = HangContainer::Legacy(crate::container::Kind::Audio); let write = |sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); wire.write(&mut group, &[raw_frame(sequence * 24_000, b"audio", true)]) .unwrap(); group.finish().unwrap(); @@ -1379,7 +1379,7 @@ mod tests { let wire = HangContainer::Legacy(crate::container::Kind::Audio); let pes = |pes: u64| { for sequence in pes * 5..pes * 5 + 5 { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); wire.write(&mut group, &[raw_frame(sequence * 24_000, b"audio", true)]) .unwrap(); group.finish().unwrap(); @@ -1520,7 +1520,7 @@ mod tests { let (track, mut export) = audio_export().await; let wire = HangContainer::Legacy(crate::container::Kind::Audio); let group = |sequence: u64, timestamp: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); wire.write(&mut group, &[raw_frame(timestamp, b"audio", true)]).unwrap(); group }; @@ -1553,7 +1553,7 @@ mod tests { let (track, mut export) = audio_export().await; let wire = HangContainer::Legacy(crate::container::Kind::Audio); for (sequence, timestamp, payload) in [(0, 0, b"audio".as_slice()), (2, 1_000_000, b"".as_slice())] { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); wire.write(&mut group, &[raw_frame(timestamp, payload, true)]).unwrap(); group.finish().unwrap(); } @@ -1604,7 +1604,7 @@ mod tests { ), (2, vec![raw_frame(100_000, b"resumed", true)]), ] { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); wire.write(&mut group, &frames).unwrap(); group.finish().unwrap(); } diff --git a/rs/moq-mux/src/container/ts/export_test.rs b/rs/moq-mux/src/container/ts/export_test.rs index c28a8f457de..942e6505da3 100644 --- a/rs/moq-mux/src/container/ts/export_test.rs +++ b/rs/moq-mux/src/container/ts/export_test.rs @@ -1010,7 +1010,7 @@ async fn export_trims_leading_pictures_after_each_delivery_break() { (11, vec![200, 180, 190, 210]), (13, vec![400, 380, 390, 410]), ] { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let frames: Vec<_> = stamps .into_iter() .enumerate() @@ -1315,7 +1315,7 @@ async fn export_declared(reorder: u8, groups: &[&[u64]]) -> (Export = stamps .iter() .enumerate() @@ -6339,14 +6339,14 @@ async fn a_start_group_cut_short_goes_out() { // The first group delivers five pictures before the next group lands and the publisher // resets it. - let mut cut = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut cut = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); for tick in 0..5 { rig.at(tick * VIDEO_US).await; wire.write(&mut cut, &[picture(tick)]).unwrap(); out.extend(poll_frames(&mut export)); rig.audio_until(tick * VIDEO_US, &mut export, &mut out); } - let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); wire.write(&mut group, &[picture(GOP)]).unwrap(); cut.abort(moq_net::Error::Old).unwrap(); for tick in 5..GOP { @@ -6358,7 +6358,7 @@ async fn a_start_group_cut_short_goes_out() { rig.at(tick * VIDEO_US).await; if tick.is_multiple_of(GOP) { group.finish().unwrap(); - group = track.create_group(moq_net::group::Info { start: tick / GOP }).unwrap(); + group = track.create_group(moq_net::group::Info { start: tick / GOP }).unwrap().unwrap(); } wire.write(&mut group, &[picture(tick)]).unwrap(); out.extend(poll_frames(&mut export)); @@ -8647,7 +8647,7 @@ async fn a_skipped_group_flags_the_clock() { for sequence in 0..80 + 2 * missing { kio::clock::sleep_until(start.saturating_add(Duration::from_millis(sequence * 100))).await; if !(20..20 + missing).contains(&sequence) && !(40 + missing..40 + 2 * missing).contains(&sequence) { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); for k in 0..5u64 { let frame = Frame { timestamp: Timestamp::from_millis(60_000 + sequence * 100 + k * 20).unwrap(), @@ -8791,7 +8791,7 @@ async fn a_timeline_restarting_at_zero_fails_the_export() { for sequence in 0..11u64 { kio::clock::sleep_until(start.saturating_add(Duration::from_secs(sequence))).await; let base = if sequence < 10 { sequence * 1_000 } else { 0 }; - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); for k in 0..50u64 { let millis = if sequence == 10 && k == 0 { 9_001 } else { base + k * 20 }; let frame = Frame { diff --git a/rs/moq-mux/src/container/ts/recovery_test.rs b/rs/moq-mux/src/container/ts/recovery_test.rs index 9a3da4fdede..c60806e0bae 100644 --- a/rs/moq-mux/src/container/ts/recovery_test.rs +++ b/rs/moq-mux/src/container/ts/recovery_test.rs @@ -955,7 +955,7 @@ async fn run(recording: &Recording, arm: &Arm) -> Run { let group = open[t].get_or_insert_with(|| { kept[t] = 0; let info = moq_net::group::Info { start: *sequence }; - producers[t].create_group(info).unwrap() + producers[t].create_group(info).unwrap().unwrap() }); assert_eq!(group.start, *sequence, "a schedule interleaves groups of track {t}"); group diff --git a/rs/moq-mux/src/container/ts/release_test.rs b/rs/moq-mux/src/container/ts/release_test.rs index 530271ccc48..e75f3a4c343 100644 --- a/rs/moq-mux/src/container/ts/release_test.rs +++ b/rs/moq-mux/src/container/ts/release_test.rs @@ -149,7 +149,7 @@ fn republish_cut( track.skip_groups(run); } let info = moq_net::group::Info { start: object.group }; - group = Some((object.group, track.create_group(info).unwrap())); + group = Some((object.group, track.create_group(info).unwrap().unwrap())); } let timestamp = moq_net::Timestamp::from_micros(object.micros).unwrap(); let group = &mut group.as_mut().unwrap().1; diff --git a/rs/moq-net-tests/tests/integration/snapshot.rs b/rs/moq-net-tests/tests/integration/snapshot.rs index 0d97cffa54a..301f02427ae 100644 --- a/rs/moq-net-tests/tests/integration/snapshot.rs +++ b/rs/moq-net-tests/tests/integration/snapshot.rs @@ -21,7 +21,7 @@ fn reads_skip_an_owed_hole() { let mut next = snapshot::Consumer::::new(track.consume(), Default::default()); let waiter = kio::Waiter::noop(); let put = |start: u64| { - let mut group = track.create_group(group::Info { start }).unwrap(); + let mut group = track.create_group(group::Info { start }).unwrap().unwrap(); group .write_frame( moq_net::Timestamp::unscaled(start), diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index 1fac9133935..93dc92455f8 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -1126,7 +1126,7 @@ fn bench_handoff(c: &mut Criterion) { .route("room/live", moq_net::origin::RouteOptions::hidden()) .unwrap(); let track = standby.broadcast().create_track("video", timed()).unwrap(); - let mut second = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut second = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); second.write_frame(at(1), b"two".as_ref()).unwrap(); second.finish().unwrap(); // Announcing is what makes the standby a route the front can take. @@ -1736,7 +1736,7 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { .unwrap(); let track = broadcast.broadcast().create_track("0", timed()).unwrap(); for key in order { - let mut group = track.create_group(moq_net::group::Info { start: key as u64 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key as u64 }).unwrap().unwrap(); group.write_frame(at(key as u64), b"f".as_ref()).unwrap(); group.finish().unwrap(); } diff --git a/rs/moq-net/benches/ranges.rs b/rs/moq-net/benches/ranges.rs index 34b71a6e009..f7c15f5ecc9 100644 --- a/rs/moq-net/benches/ranges.rs +++ b/rs/moq-net/benches/ranges.rs @@ -51,7 +51,7 @@ fn millis(millis: u64) -> Timestamp { /// Write a one-frame group starting at `key` milliseconds. fn land(track: &track::Producer, key: u64) { - let mut group = track.create_group(group::Info { start: key }).unwrap(); + let mut group = track.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(millis(key), Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); } @@ -137,7 +137,7 @@ impl TimeCap { } pub(crate) fn step(&mut self) { - let mut group = self.track.create_group(group::Info { start: self.next }).unwrap(); + let mut group = self.track.create_group(group::Info { start: self.next }).unwrap().unwrap(); let mut handed = drain(&mut self.reader); group.write_frame(millis(self.next), Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); @@ -277,7 +277,7 @@ impl TimeGaps { pub(crate) fn step(&mut self) { // Each a millisecond after the last, from where the history ended. - let mut group = self.track.create_group(group::Info { start: self.next }).unwrap(); + let mut group = self.track.create_group(group::Info { start: self.next }).unwrap().unwrap(); let mut handed = drain(&mut self.reader); group.write_frame(millis(self.next), Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-net/benches/tail.rs b/rs/moq-net/benches/tail.rs index b6ee3ad4cac..095e3987137 100644 --- a/rs/moq-net/benches/tail.rs +++ b/rs/moq-net/benches/tail.rs @@ -48,7 +48,7 @@ impl Held { for key in 1..=groups as u64 { track .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } diff --git a/rs/moq-net/benches/track.rs b/rs/moq-net/benches/track.rs index ac09c385146..8d954137aab 100644 --- a/rs/moq-net/benches/track.rs +++ b/rs/moq-net/benches/track.rs @@ -395,7 +395,7 @@ impl HighKey { } fn write(&self, key: u64) { - let mut group = self.track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = self.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::unscaled(key), self.payload.clone()) .unwrap(); @@ -1424,7 +1424,7 @@ impl Sparse { true => at(key), false => moq_net::Timestamp::unscaled(key), }; - let mut group = self.track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = self.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group.write_frame(timestamp, Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); let Poll::Ready(Ok(Some(read))) = self.sub.poll_recv_group(&kio::Waiter::noop()) else { @@ -1645,7 +1645,7 @@ impl GapFlush { track::Subscription::default().with_delay(track::Delay::default().with_max(Duration::from_secs(3600))), ); let mut hand_out = |key: u64| { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group.write_frame(at(key), Bytes::from_static(b"x")).unwrap(); let Poll::Ready(Ok(Some(read))) = sub.poll_recv_group(&kio::Waiter::noop()) else { panic!("the group is cached"); @@ -1674,7 +1674,7 @@ impl GapFlush { let mut group = self .track .create_group(moq_net::group::Info { start: TWO_HOURS }) - .unwrap(); + .unwrap().unwrap(); group.write_frame(at(TWO_HOURS), Bytes::from_static(b"x")).unwrap(); let Poll::Ready(Ok(Some(read))) = self.sub.poll_recv_group(&kio::Waiter::noop()) else { panic!("the group is cached"); @@ -1875,7 +1875,7 @@ impl BudgetWidening { let waiter = kio::Waiter::noop(); let mut write = |keys: std::ops::Range| { for key in keys { - let mut group = track.create_group(group::Info { start: 100 * key }).unwrap(); + let mut group = track.create_group(group::Info { start: 100 * key }).unwrap().unwrap(); group.write_frame(at(100 * key), Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); } @@ -1950,7 +1950,7 @@ impl TimeEnd { fn new(readers: usize, groups: u64) -> Self { let broadcast = broadcast::Info::default().produce(); let track = broadcast.create_track("bench", timed()).unwrap(); - let mut zero = track.create_group(group::Info { start: 0 }).unwrap(); + let mut zero = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); zero.write_frame(Timestamp::from_millis(0).unwrap(), Bytes::from_static(b"x")) .unwrap(); zero.finish().unwrap(); @@ -1977,7 +1977,7 @@ impl TimeEnd { fn run(&mut self) { let waiter = kio::Waiter::noop(); for key in 2..self.groups + 2 { - let mut group = self.track.create_group(group::Info { start: key }).unwrap(); + let mut group = self.track.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), Bytes::from_static(b"x")) .unwrap(); @@ -2029,7 +2029,7 @@ impl Fills { // The feed starts past every run, so each is a miss. let start = runs * 2; track.start_at(start).unwrap(); - let mut group = track.create_group(group::Info { start }).unwrap(); + let mut group = track.create_group(group::Info { start }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(start).unwrap(), Bytes::from_static(b"x")) .unwrap(); @@ -2137,7 +2137,7 @@ impl RangeFills { // it its own fill, and has every range start at a time no group held places. let start = ranges * (width + 1) + 1; track.start_at(start).unwrap(); - let mut group = track.create_group(group::Info { start }).unwrap(); + let mut group = track.create_group(group::Info { start }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(start).unwrap(), Bytes::from_static(b"x")) .unwrap(); @@ -2246,7 +2246,7 @@ impl RefusedFill { let mut track = broadcast.create_track("bench", timed()).unwrap(); let dynamic = track.requests(); track.start_at(Self::START).unwrap(); - let mut group = track.create_group(group::Info { start: Self::START }).unwrap(); + let mut group = track.create_group(group::Info { start: Self::START }).unwrap().unwrap(); group.write_frame(Timestamp::ZERO, Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); let waiter = kio::Waiter::noop(); diff --git a/rs/moq-net/src/fuzz/ingest.rs b/rs/moq-net/src/fuzz/ingest.rs index cd8d9fc71e3..a1b99e1b242 100644 --- a/rs/moq-net/src/fuzz/ingest.rs +++ b/rs/moq-net/src/fuzz/ingest.rs @@ -241,7 +241,7 @@ fn run(session: Session, info: &track::Info, body: &[u8], chunk: usize) -> Optio Session::Ietf { version } => { let (header, used) = ietf::GroupHeader::decode_slice(body, version).ok()?; let mut reader = reader(Bytes::copy_from_slice(&body[used..]), chunk, version); - let producer = track.create_group(group::Info { start: header.group_id }).ok()?; + let producer = track.create_group(group::Info { start: header.group_id }).ok()??; producer .set_wire(group::Wire { sparse: false, diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index ea8b3809cf9..c3deb3b53a5 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -8578,7 +8578,7 @@ mod group_priority_test { "test", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 5 }).unwrap(); + let mut group = track.create_group(group::Info { start: 5 }).unwrap().unwrap(); for _ in 0..5 { group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); } @@ -8725,7 +8725,7 @@ mod group_priority_test { "test", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group .write_frame(crate::Timestamp::from_millis(0).unwrap(), b"hello".as_slice()) .unwrap(); @@ -8868,7 +8868,7 @@ mod group_priority_test { let mut appended = 0; let produce = move || { for _ in 0..BATCH.min(GROUPS - appended) { - let mut group = producer.create_group(group::Info { start: appended }).unwrap(); + let mut group = producer.create_group(group::Info { start: appended }).unwrap().unwrap(); group .write_frame(crate::Timestamp::from_millis(appended).unwrap(), b"x".as_slice()) .unwrap(); @@ -8912,7 +8912,7 @@ mod group_priority_test { ServeRange::default(), ); for key in 0..2 { - let mut group = track.create_group(group::Info { start: key }).unwrap(); + let mut group = track.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::from_millis(key).unwrap(), b"x".as_slice()) .unwrap(); @@ -8959,7 +8959,7 @@ mod group_priority_test { track::Subscription::default() .with_delay(track::Delay::default().with_max(std::time::Duration::from_secs(3600))), ); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); for millis in 0..FRAMES as u64 { group .write_frame(crate::Timestamp::from_millis(millis).unwrap(), vec![0u8; PAYLOAD]) @@ -9008,10 +9008,10 @@ mod group_priority_test { ServeRange::default(), ); - let group = track.create_group(group::Info { start: 0 }).unwrap(); + let group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); assert!(futures::poll!(kio::wait(|waiter| serve.poll(waiter))).is_pending()); // A later group is served meanwhile, its stream independent of the one waiting. - let mut later = track.create_group(group::Info { start: 1 }).unwrap(); + let mut later = track.create_group(group::Info { start: 1 }).unwrap().unwrap(); later .write_frame(crate::Timestamp::unscaled(later.start), b"later".as_slice()) .unwrap(); @@ -9349,7 +9349,7 @@ mod group_priority_test { track::Info::default(), ); let mut subscriber = track.subscribe(None); - let _stalled = track.create_group(group::Info { start: 0 }).unwrap(); + let _stalled = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); let group = subscriber.recv_group().await.unwrap().expect("stalled group"); let mut serve = GroupServe::new( @@ -9372,7 +9372,7 @@ mod group_priority_test { "the relay state is unsettled" ); - let mut edge = track.create_group(group::Info { start: 1 }).unwrap(); + let mut edge = track.create_group(group::Info { start: 1 }).unwrap().unwrap(); edge.write_frame(crate::Timestamp::unscaled(edge.start), b"edge".as_slice()) .unwrap(); edge.finish().unwrap(); @@ -9391,7 +9391,7 @@ mod group_priority_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let mut producer = track.create_group(group::Info { start: 0 }).unwrap(); + let mut producer = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); producer.start_at(1).unwrap(); producer .write_frame(crate::Timestamp::ZERO, b"tail".as_slice()) @@ -9476,7 +9476,7 @@ mod group_priority_test { "test", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"done".as_slice()).unwrap(); let consumer = group.consume(); group.finish().unwrap(); @@ -9595,7 +9595,7 @@ mod subscribe_cursor_test { crate::track::Info::timed(), ); for key in 0..4 { - let mut group = track.create_group(group::Info { start: key }).unwrap(); + let mut group = track.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); } @@ -9848,7 +9848,7 @@ mod serve_tests { "{version}" ); if !super::super::request_stream::fin_cancels(version) { - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"after FIN".as_slice()).unwrap(); group.finish().unwrap(); assert!(futures::poll!(run.as_mut()).is_pending()); @@ -10026,7 +10026,7 @@ mod serve_tests { )); // An unfinished group keeps its stream open. - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"open".as_slice()).unwrap(); assert!(futures::poll!(run.as_mut()).is_pending()); let before = h.log.priorities(); @@ -10193,7 +10193,7 @@ mod serve_tests { async fn publish_done_after_a_track_error_follows_every_stream_close() { let version = Version::Draft22; let h = serve(version); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"head".as_slice()).unwrap(); let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), version) @@ -10254,7 +10254,7 @@ mod serve_tests { async fn publish_done_at_the_track_end_counts_and_follows_every_stream() { let version = Version::Draft22; let h = serve(version); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"head".as_slice()).unwrap(); let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), version) @@ -10411,7 +10411,7 @@ mod serve_tests { /// inside it and the group stream waits for object 1. async fn fail_update_mid_flight(version: Version) -> Wire { let h = serve(version); - let group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut frame = group .create_frame(frame::Info { timestamp: timestamp(), @@ -10532,7 +10532,7 @@ mod serve_tests { .count(); (ok, answers) }; - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut paused = 0; if !start_paused { serve_until(serve.as_mut(), "SUBSCRIBE_OK", || answers().0).await; @@ -10564,7 +10564,7 @@ mod serve_tests { let broadcast = crate::broadcast::Producer::new(Default::default()); let track = broadcast.create_track("audio", track::Info::default()).unwrap(); let subscriber = track.subscribe(Subscription::default().with_start(0).with_end(1)); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"bounded"[..]) .unwrap(); @@ -10655,7 +10655,7 @@ mod serve_tests { async fn a_joining_fetch_after_a_resume_is_served() { let version = Version::Draft18; let h = serve(version); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"head".as_slice()).unwrap(); let mut request = ScriptedSession::new(Vec::new()); request.log = h.log.clone(); @@ -10758,7 +10758,7 @@ mod serve_tests { /// Group 4 of `h`'s track: a 3 byte first frame and a 5 byte delta, over a refresh /// ratio of 1. fn refresh_group(h: &Serve) -> group::Producer { - let mut group = h.track.create_group(group::Info { start: 4 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 4 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"key".as_slice()).unwrap(); group.write_frame(group.key_time(), b"delta".as_slice()).unwrap(); group @@ -11887,7 +11887,7 @@ mod serve_tests { for version in ALL_VERSIONS { for wanted in [true, false] { let h = serve(version); - let mut group = h.track.create_group(group::Info { start: 4 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 4 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"a".as_slice()).unwrap(); group.write_frame(group.key_time(), b"b".as_slice()).unwrap(); kio::clock::sleep(std::time::Duration::from_millis(1)).await; @@ -12145,7 +12145,7 @@ mod serve_tests { for wanted in [true, false] { let mut h = serve(version); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(stamp, b"stamped".as_slice()).unwrap(); group.finish().unwrap(); @@ -12441,11 +12441,11 @@ mod serve_tests { async fn canonical_join_serves_the_head_on_a_fetch_stream() { for filter in [Filter::NextObject, Filter::Unfiltered] { let mut h = serve(Version::Draft22); - let mut earlier = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut earlier = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); earlier.write_frame(earlier.key_time(), b"earlier".as_slice()).unwrap(); earlier.finish().unwrap(); - let mut group = h.track.create_group(group::Info { start: 1 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 1 }).unwrap().unwrap(); for payload in [b"head-0", b"head-1", b"head-2"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } @@ -12499,7 +12499,7 @@ mod serve_tests { for (start, end, wanted) in narrowed { let version = Version::Draft22; let h = serve(version); - let mut group = h.track.create_group(group::Info { start: 1 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 1 }).unwrap().unwrap(); group .write_frame(group.key_time(), b"before-update".as_slice()) .unwrap(); @@ -12538,7 +12538,7 @@ mod serve_tests { .await; group.write_frame(group.key_time(), b"after-update".as_slice()).unwrap(); group.finish().unwrap(); - let mut later = h.track.create_group(group::Info { start: 4 }).unwrap(); + let mut later = h.track.create_group(group::Info { start: 4 }).unwrap().unwrap(); later.write_frame(later.key_time(), b"wanted".as_slice()).unwrap(); later.finish().unwrap(); h.track.finish_shared().unwrap(); @@ -12581,10 +12581,10 @@ mod serve_tests { for (filter, narrowing) in cases { let version = Version::Draft22; let h = serve(version); - let mut history = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut history = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); history.write_frame(history.key_time(), b"history".as_slice()).unwrap(); history.finish().unwrap(); - let mut group = h.track.create_group(group::Info { start: 1 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 1 }).unwrap().unwrap(); group .write_frame(group.key_time(), b"before-update".as_slice()) .unwrap(); @@ -12668,7 +12668,7 @@ mod serve_tests { let credit = kio::Producer::new(false); let session = ScriptedSession::per_stream(vec![Vec::new()]).with_open_uni_gate(credit.consume()); let h = serve_session(version, crate::track::Info::timed(), session); - let mut group = h.track.create_group(group::Info { start: 1 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 1 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"head".as_slice()).unwrap(); kio::clock::sim::yield_now().await; let mut request = ScriptedSession::new(Vec::new()); @@ -12740,10 +12740,10 @@ mod serve_tests { async fn a_fill_only_update_keeps_the_live_join_floor() { let version = Version::Draft22; let h = serve(version); - let mut history = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut history = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); history.write_frame(history.key_time(), b"history".as_slice()).unwrap(); history.finish().unwrap(); - let mut group = h.track.create_group(group::Info { start: 1 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 1 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"live".as_slice()).unwrap(); kio::clock::sim::yield_now().await; let mut request = ScriptedSession::new(Vec::new()); @@ -12798,7 +12798,7 @@ mod serve_tests { for end in [None, Some(EndLocation { group: 0, object: None })] { let version = Version::Draft22; let h = serve(version); - let mut group = h.track.create_group(group::Info { start: 1 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 1 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"history".as_slice()).unwrap(); kio::clock::sim::yield_now().await; let mut request = ScriptedSession::new(Vec::new()); @@ -12853,7 +12853,7 @@ mod serve_tests { .unwrap(); group.finish().unwrap(); for (key, payload) in [(2, b"excluded".as_slice()), (4, b"wanted".as_slice())] { - let mut group = h.track.create_group(group::Info { start: key }).unwrap(); + let mut group = h.track.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(group.key_time(), payload).unwrap(); group.finish().unwrap(); } @@ -12876,7 +12876,7 @@ mod serve_tests { async fn relative_one_replays_the_current_group() { let mut h = serve(Version::Draft22); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); for payload in [b"head-0", b"head-1", b"head-2"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } @@ -12896,7 +12896,7 @@ mod serve_tests { async fn next_object_does_not_replay_the_head() { let mut h = serve(Version::Draft22); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); for payload in [b"head-0", b"head-1", b"head-2"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } @@ -12926,7 +12926,7 @@ mod serve_tests { for (filter, history) in [(Filter::Unfiltered, 0), (zero, 1)] { let mut h = serve(version); for (key, payload) in [(0, b"history"), (1, b"latest!")] { - let mut group = h.track.create_group(group::Info { start: key }).unwrap(); + let mut group = h.track.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(group.key_time(), payload.as_slice()).unwrap(); group.finish().unwrap(); } @@ -12961,7 +12961,7 @@ mod serve_tests { .create_track("video", crate::track::Info::timed().with_max_age(None)) .unwrap(); for (key, payload) in [(0, b"history"), (1, b"latest!")] { - let mut group = track.create_group(group::Info { start: key }).unwrap(); + let mut group = track.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(group.key_time(), payload.as_slice()).unwrap(); group.finish().unwrap(); } @@ -13031,7 +13031,7 @@ mod serve_tests { let mut h = serve(Version::Draft22); for key in 0..2 { - let mut group = h.track.create_group(group::Info { start: key }).unwrap(); + let mut group = h.track.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); } @@ -13074,7 +13074,7 @@ mod serve_tests { #[kio::test] async fn a_fill_ranks_as_the_group_it_fills() { let h = serve(Version::Draft22); - let mut group = h.track.create_group(group::Info { start: 4 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 4 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"fill".as_slice()).unwrap(); let queue = h.publisher.priority.clone(); @@ -13137,7 +13137,7 @@ mod serve_tests { #[kio::test] async fn a_fill_outranks_the_rest_of_its_group() { let h = serve(Version::Draft22); - let mut group = h.track.create_group(group::Info { start: 4 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 4 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"head".as_slice()).unwrap(); let ranking = Ranking { @@ -13255,7 +13255,7 @@ mod serve_tests { /// and a `{0, 0}` End Location would be below the subscriber's own Start. fn publish_groups(h: &mut Serve, latest: u64) { for key in 0..=latest { - let mut group = h.track.create_group(group::Info { start: key }).unwrap(); + let mut group = h.track.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); } @@ -13340,7 +13340,7 @@ mod serve_tests { } }) .await; - let group = h.track.create_group(group::Info { start: 3 }).unwrap(); + let group = h.track.create_group(group::Info { start: 3 }).unwrap().unwrap(); group .set_wire(group::Wire { sparse: true, @@ -13436,7 +13436,7 @@ mod serve_tests { for version in JOINING_DRAFTS { let mut h = serve(version); publish_groups(&mut h, LATEST - 1); - let mut group = h.track.create_group(group::Info { start: LATEST }).unwrap(); + let mut group = h.track.create_group(group::Info { start: LATEST }).unwrap().unwrap(); let payloads: &[&[u8]] = &[b"first-object", b"", b"third-object"]; for payload in payloads { group.write_frame(group.key_time(), *payload).unwrap(); @@ -13657,7 +13657,7 @@ mod serve_tests { async fn a_joining_fetch_refuses_a_missing_prefix_before_fetch_ok() { let version = Version::Draft18; let h = serve(version); - let mut group = h.track.create_group(group::Info { start: 5 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 5 }).unwrap().unwrap(); group.start_at(1).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); @@ -13693,7 +13693,7 @@ mod serve_tests { async fn a_joining_fetch_refuses_a_prefix_group_it_lost() { let version = Version::Draft18; let h = serve(version); - let mut prefix = h.track.create_group(group::Info { start: 5 }).unwrap(); + let mut prefix = h.track.create_group(group::Info { start: 5 }).unwrap().unwrap(); prefix.write_frame(prefix.key_time(), b"frame".as_slice()).unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), version) @@ -13814,7 +13814,7 @@ mod serve_tests { for version in JOINING_DRAFTS { let mut h = serve(version); publish_groups(&mut h, 4); - let mut group = h.track.create_group(group::Info { start: 5 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 5 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"the-head".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -13911,7 +13911,7 @@ mod serve_tests { .broadcast() .create_track("video", crate::track::Info::timed()) .unwrap(); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".to_vec()).unwrap(); group.finish().unwrap(); settle().await; @@ -14133,7 +14133,7 @@ mod serve_tests { serve_until(serving.as_mut(), "SUBSCRIBE_OK was sent", || !h.log.trail().is_empty()).await; // A group left open, so its stream is still serving when the grant ends. - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); serve_until(serving.as_mut(), "the group stream opened", || { !data_streams(&h.log).is_empty() @@ -14280,7 +14280,7 @@ mod serve_tests { /// Groups `0..count`, each holding `g-0` and `g-1`, skipping `hole`. fn publish_pairs(h: &mut Serve, count: u64, hole: Option) { for key in (0..count).filter(|key| Some(*key) != hole) { - let mut group = h.track.create_group(group::Info { start: key }).unwrap(); + let mut group = h.track.create_group(group::Info { start: key }).unwrap().unwrap(); for object in 0..2 { group .write_frame(group.key_time(), format!("{key}-{object}").into_bytes()) @@ -14303,7 +14303,7 @@ mod serve_tests { async fn a_cached_standalone_fetch_yields_while_writing() { for version in FETCH_DRAFTS { let h = serve(version); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); for _ in 0..256 { group.write_frame(group.key_time(), vec![7; 1024]).unwrap(); } @@ -14701,7 +14701,7 @@ mod serve_tests { for wanted in [Some(true), opt_out].into_iter().flatten() { let h = serve(version); let track = h._broadcast.broadcast().create_track("timed", info.clone()).unwrap(); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(stamp, b"stamped".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -14787,7 +14787,7 @@ mod serve_tests { ..track::Info::timed() }, ); - let mut group = h.track.create_group(group::Info { start: 4 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 4 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"fill".as_slice()).unwrap(); group.finish().unwrap(); @@ -14823,7 +14823,7 @@ mod serve_tests { let session = ScriptedSession::per_stream(vec![Vec::new()]).with_unacked_uni_fins(1); let h = serve_session(version, track::Info::timed().with_max_age(Some(budget)), session); // Frozen timestamps, so only the wall clock since group 5 arrived convicts group 4. - let mut group = h.track.create_group(group::Info { start: 4 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 4 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"fill".as_slice()).unwrap(); group.finish().unwrap(); @@ -14857,7 +14857,7 @@ mod serve_tests { .await .expect("the fill went out whole"); - let mut next = h.track.create_group(group::Info { start: 5 }).unwrap(); + let mut next = h.track.create_group(group::Info { start: 5 }).unwrap().unwrap(); next.write_frame(next.key_time(), b"next".as_slice()).unwrap(); next.finish().unwrap(); kio::clock::sim::advance(budget - Duration::from_millis(1)).await; @@ -14879,7 +14879,7 @@ mod serve_tests { let session = ScriptedSession::per_stream(vec![Vec::new()]).with_uni_send_window(1); let h = serve_session(version, track::Info::timed().with_max_age(Some(budget)), session); // Frozen timestamps, so only the wall clock since group 1 arrived convicts group 0. - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"fetch".as_slice()).unwrap(); group.finish().unwrap(); @@ -14910,7 +14910,7 @@ mod serve_tests { }) .await; - let mut next = h.track.create_group(group::Info { start: 1 }).unwrap(); + let mut next = h.track.create_group(group::Info { start: 1 }).unwrap().unwrap(); next.write_frame(next.key_time(), b"next".as_slice()).unwrap(); next.finish().unwrap(); kio::clock::sim::advance(budget - Duration::from_millis(1)).await; @@ -14974,7 +14974,7 @@ mod serve_tests { ); let h = serve_track(version, info.clone()); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"a".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -15194,7 +15194,7 @@ mod serve_tests { h.track.finish_shared().unwrap(); None } - Largest::Live => Some(h.track.create_group(group::Info { start: 5 }).unwrap()), + Largest::Live => Some(h.track.create_group(group::Info { start: 5 }).unwrap().unwrap()), Largest::Idle => { h.track.set_idle(); None @@ -15210,7 +15210,7 @@ mod serve_tests { None } Largest::Aborted => { - let mut newer = h.track.create_group(group::Info { start: 5 }).unwrap(); + let mut newer = h.track.create_group(group::Info { start: 5 }).unwrap().unwrap(); newer.write_frame(newer.key_time(), b"5-0".to_vec()).unwrap(); newer.abort(Error::Cancel).unwrap(); None @@ -15274,7 +15274,7 @@ mod serve_tests { let version = Version::Draft22; let mut h = serve(version); publish_pairs(&mut h, 5, None); - let empty = h.track.create_group(group::Info { start: 5 }).unwrap(); + let empty = h.track.create_group(group::Info { start: 5 }).unwrap().unwrap(); empty.finish().unwrap(); settle().await; @@ -15511,7 +15511,7 @@ mod serve_tests { for version in FETCH_DRAFTS { let mut h = serve(version); publish_pairs(&mut h, 4, None); - let mut live = h.track.create_group(group::Info { start: 4 }).unwrap(); + let mut live = h.track.create_group(group::Info { start: 4 }).unwrap().unwrap(); for object in 0..2 { live.write_frame(live.key_time(), format!("4-{object}").into_bytes()) .unwrap(); @@ -15549,9 +15549,9 @@ mod serve_tests { for version in FETCH_DRAFTS { let mut h = serve(version); publish_pairs(&mut h, 4, None); - let mut older = h.track.create_group(group::Info { start: 4 }).unwrap(); + let mut older = h.track.create_group(group::Info { start: 4 }).unwrap().unwrap(); older.write_frame(older.key_time(), b"4-0".to_vec()).unwrap(); - let mut newer = h.track.create_group(group::Info { start: 5 }).unwrap(); + let mut newer = h.track.create_group(group::Info { start: 5 }).unwrap().unwrap(); newer.write_frame(newer.key_time(), b"5-0".to_vec()).unwrap(); settle().await; @@ -15655,7 +15655,7 @@ mod serve_tests { for version in FETCH_DRAFTS { // The group is still being written, so the fetch waits on it when the grant narrows. let h = serve(version); - let _group = h.track.clone().create_group(group::Info { start: 0 }).unwrap(); + let _group = h.track.clone().create_group(group::Info { start: 0 }).unwrap().unwrap(); settle().await; let auth = crate::auth::Link::new(false); let mut h = h; @@ -15694,7 +15694,7 @@ mod serve_tests { .broadcast() .create_track("video", crate::track::Info::timed()) .unwrap(); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"0-0".to_vec()).unwrap(); group.finish().unwrap(); settle().await; @@ -15793,7 +15793,7 @@ mod serve_tests { .broadcast() .create_track("video", crate::track::Info::timed()) .unwrap(); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), PAYLOAD.to_vec()).unwrap(); settle().await; @@ -15927,7 +15927,7 @@ mod serve_tests { .broadcast() .create_track("video", crate::track::Info::timed()) .unwrap(); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), PAYLOAD.to_vec()).unwrap(); settle().await; @@ -16103,7 +16103,7 @@ mod serve_tests { let h = serve_on(VERSION, auth, session); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), ANSWERED_HEAD.to_vec()).unwrap(); group.finish().unwrap(); settle().await; @@ -16270,7 +16270,7 @@ mod serve_tests { match parked { // One published group, so the subscription parks at the live edge. Parked::Acking => { - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".to_vec()).unwrap(); group.finish().unwrap(); } @@ -16839,7 +16839,7 @@ mod serve_tests { for version in JOINING_DRAFTS { let mut h = serve(version); publish_pairs(&mut h, 4, None); - let mut group = h.track.create_group(group::Info { start: 4 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 4 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"4-0".as_slice()).unwrap(); settle().await; @@ -16970,7 +16970,7 @@ mod serve_tests { let mut h = serve(version); // A live edge in the middle of group 5: objects 0 through 3. - let mut group = h.track.create_group(group::Info { start: 5 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 5 }).unwrap().unwrap(); for payload in [b"5-0", b"5-1", b"5-2", b"5-3"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } @@ -17063,7 +17063,7 @@ mod serve_tests { "test", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); for payload in [b"aa", b"bb", b"cc", b"dd"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } @@ -17204,7 +17204,7 @@ mod serve_tests { // Appending says the producer will not go back, so keys 3 and 4 never exist. write(track.append_group(crate::Timestamp::unscaled(5)).unwrap()); // A gap between created groups says nothing. - write(track.create_group(group::Info { start: 7 }).unwrap()); + write(track.create_group(group::Info { start: 7 }).unwrap().unwrap()); let _track = track.finish().unwrap(); let mut serve = TrackServe::new( @@ -17416,7 +17416,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth, subscribe_update_with_token(VERSION, true).await); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -17615,7 +17615,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth, script); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -17690,7 +17690,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth, script); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -17745,7 +17745,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth, script); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -17792,7 +17792,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth, script); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -17839,7 +17839,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth, script); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -17910,7 +17910,7 @@ mod serve_tests { let h = serve_with_auth(version, auth, script); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -17979,7 +17979,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth, script); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -18036,7 +18036,7 @@ mod serve_tests { cancel: impl FnOnce(), label: &str, ) { - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -18109,7 +18109,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth, subscribe_update_with_token(VERSION, true).await); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -18183,7 +18183,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth, subscribe_update_with_token(VERSION, true).await); let rt = h.publisher.runtime.clone(); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -18288,7 +18288,7 @@ mod serve_tests { auth.handle().authorize(&crate::auth::Grant::default()); let h = serve_with_auth(VERSION, auth, Vec::new()); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -18342,7 +18342,7 @@ mod serve_tests { auth.handle().authorize(limit); } let h = serve_with_auth(VERSION, auth.clone(), Vec::new()); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); group.finish().unwrap(); settle().await; @@ -18546,7 +18546,7 @@ mod serve_tests { let unlimited = crate::auth::Link::new(false); let h = serve_with_auth(VERSION, unlimited, Vec::new()); - let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = h.track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -21755,8 +21755,8 @@ mod range_tests { "video", crate::track::Info::timed(), ); - track.create_group(group::Info { start: 7 }).unwrap().finish().unwrap(); - track.create_group(group::Info { start: 8 }).unwrap().finish().unwrap(); + track.create_group(group::Info { start: 7 }).unwrap().unwrap().finish().unwrap(); + track.create_group(group::Info { start: 8 }).unwrap().unwrap().finish().unwrap(); // Next Group against a live edge of 8 asks for 9, which does not exist yet. let mut subscriber = track.subscribe(None); @@ -21767,7 +21767,7 @@ mod range_tests { ); // The group it asked for is what it gets once published. - track.create_group(group::Info { start: 9 }).unwrap().finish().unwrap(); + track.create_group(group::Info { start: 9 }).unwrap().unwrap().finish().unwrap(); let group = subscriber.recv_group().await.unwrap().expect("group 9"); assert_eq!(group.start, 9); } @@ -21919,13 +21919,13 @@ mod range_tests { "video", crate::track::Info::timed(), ); - let mut first = track.create_group(group::Info { start: 0 }).unwrap(); + let mut first = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); for _ in 0..3 { first .write_frame(crate::Timestamp::from_millis(0).unwrap(), b"frame".as_slice()) .unwrap(); } - let _open = track.create_group(group::Info { start: 1 }).unwrap(); + let _open = track.create_group(group::Info { start: 1 }).unwrap().unwrap(); let edge = live_edge(&track.consume()); assert_eq!(edge.latest, Some(1)); @@ -21956,7 +21956,7 @@ mod range_tests { if reported_first { track.report_object(3, 4); } - let mut newer = track.create_group(group::Info { start: key }).unwrap(); + let mut newer = track.create_group(group::Info { start: key }).unwrap().unwrap(); for _ in 0..frames { newer .write_frame(crate::Timestamp::from_millis(0).unwrap(), b"frame".as_slice()) @@ -21991,7 +21991,7 @@ mod range_tests { }); let staged = request.stage(crate::track::Info::timed()); for key in 0..3 { - let mut group = staged.create_group(group::Info { start: key }).unwrap(); + let mut group = staged.create_group(group::Info { start: key }).unwrap().unwrap(); for _ in 0..2 { group .write_frame(crate::Timestamp::from_millis(key).unwrap(), b"frame".as_slice()) @@ -22013,13 +22013,13 @@ mod range_tests { "video", crate::track::Info::timed(), ); - let mut first = track.create_group(group::Info { start: 0 }).unwrap(); + let mut first = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); first .write_frame(crate::Timestamp::from_millis(0).unwrap(), b"frame".as_slice()) .unwrap(); first.finish().unwrap(); // Key 1 never exists; the newest group is empty. - let _open = track.create_group(group::Info { start: 2 }).unwrap(); + let _open = track.create_group(group::Info { start: 2 }).unwrap().unwrap(); let edge = live_edge(&track.consume()); assert_eq!(edge.latest, Some(2)); @@ -22037,14 +22037,14 @@ mod range_tests { "video", crate::track::Info::timed(), ); - let mut first = track.create_group(group::Info { start: 0 }).unwrap(); + let mut first = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); for _ in 0..2 { first .write_frame(crate::Timestamp::from_millis(0).unwrap(), b"frame".as_slice()) .unwrap(); } first.finish().unwrap(); - let mut newest = track.create_group(group::Info { start: 1 }).unwrap(); + let mut newest = track.create_group(group::Info { start: 1 }).unwrap().unwrap(); newest.write_frame(newest.key_time(), b"frame".as_slice()).unwrap(); newest.abort(Error::Cancel).unwrap(); diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index cc5ddb229e6..3a113d3b99e 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -6475,7 +6475,10 @@ impl OpenGroup { let key = header.group_id; // Stats (groups/frames/bytes) are counted in the model as the group is written, // through the tagged `track::Producer`. - let create = |track: &mut track::Producer| track.create_group(group::Info { start: key }); + // A stream for a group the copy already holds is refused: the model has one producer per group. + let create = |track: &mut track::Producer| { + track.create_group(group::Info { start: key })?.ok_or(Error::Duplicate) + }; loop { match self.step { @@ -7091,12 +7094,12 @@ impl RunFill { } self.skipped = None; let key = group.ok_or(Error::ProtocolViolation)?; - match open_fill_group(track, &mut self.head, key) { - Ok(()) => {} + match open_fill_group(track, key)? { + Some(group) => self.head = Some((key, 0, group)), // Widening a range can fill groups the copy already owns. Drain their // objects without replacing their producer or cutting the rest of the fill. - Err(Error::Duplicate) if self.multiple => self.skipped = Some((key, 0)), - Err(err) => return Err(err), + None if self.multiple => self.skipped = Some((key, 0)), + None => return Err(Error::Duplicate), } } if self.skipped.is_some() { @@ -8190,12 +8193,11 @@ fn resolve_fetch_group(prior: Option, wire: Option) -> Result, - key: u64, -) -> Result<(), Error> { - let producer = track.create_group(group::Info { start: key })?; +/// The fill's group `key`, or `None` when the copy already holds it. +fn open_fill_group(track: &mut track::Producer, key: u64) -> Result, Error> { + let Some(producer) = track.create_group(group::Info { start: key })? else { + return Ok(None); + }; producer.set_wire(group::Wire { sparse: false, first_object: true, @@ -8205,8 +8207,7 @@ fn open_fill_group( fetchable: true, last: None, })?; - *head = Some((key, 0, crate::recv::Group::new(producer))); - Ok(()) + Ok(Some(crate::recv::Group::new(producer))) } /// Ready once a finished subscription's data streams are accounted for: Stream Count of @@ -16502,7 +16503,7 @@ mod stitch_tests { "video", track::Info::default().with_timescale(Timescale::MICRO), ); - let mut producer = track.create_group(group::Info { start: KEY }).unwrap(); + let mut producer = track.create_group(group::Info { start: KEY }).unwrap().unwrap(); producer.write_frame(timestamp(0), b"head-0".as_slice()).unwrap(); let mut group = producer.consume(); @@ -16528,7 +16529,7 @@ mod stitch_tests { "video", track::Info::default().with_timescale(Timescale::MICRO), ); - let mut producer = track.create_group(group::Info { start: KEY }).unwrap(); + let mut producer = track.create_group(group::Info { start: KEY }).unwrap().unwrap(); producer.write_frame(timestamp(0), b"head-0".as_slice()).unwrap(); let mut group = producer.consume(); @@ -16553,7 +16554,7 @@ mod stitch_tests { "video", track::Info::default().with_timescale(Timescale::MICRO), ); - let mut producer = track.create_group(group::Info { start: KEY }).unwrap(); + let mut producer = track.create_group(group::Info { start: KEY }).unwrap().unwrap(); producer.write_frame(timestamp(0), b"head-0".as_slice()).unwrap(); let mut group = producer.consume(); @@ -16921,7 +16922,7 @@ mod stitch_tests { let mut h = Harness::new(Fill::Done, vec![draft18_subgroup(KEY, true, 0, &[b"rewound"])]); h.subscriber.version = Version::Draft18; // Starts past the incoming group's first object, at `timestamp(0)`. - let mut before = h.track.create_group((KEY - 1).into()).unwrap(); + let mut before = h.track.create_group((KEY - 1).into()).unwrap().unwrap(); before.write_frame(timestamp(4000), b"before".as_slice()).unwrap(); before.finish().unwrap(); @@ -17288,7 +17289,7 @@ mod stitch_tests { let dynamic = run.track.requests(); let consumer = run.track.consume(); run.track.start_at(last + 1).unwrap(); - run.track.create_group((last + 1).into()).unwrap().finish().unwrap(); + run.track.create_group((last + 1).into()).unwrap().unwrap().finish().unwrap(); // From group 0, which a time start names whatever is held, so the history below // the feed is asked as a miss rather than looked up. let mut reading = consumer @@ -17387,7 +17388,7 @@ mod stitch_tests { run.track.broadcast().pool.poll(now, &kio::Waiter::noop()); run.track.received(); run.track.start_at(3).unwrap(); - run.track.create_group(3u64.into()).unwrap().finish().unwrap(); + run.track.create_group(3u64.into()).unwrap().unwrap().finish().unwrap(); let requests = run.track.requests(); // From group 0, which a time start names whatever is held. let mut reader = run.track.subscribe( @@ -17436,7 +17437,7 @@ mod stitch_tests { let dynamic = run.track.requests(); let consumer = run.track.consume(); run.track.start_at(7).unwrap(); - run.track.create_group(7u64.into()).unwrap().finish().unwrap(); + run.track.create_group(7u64.into()).unwrap().unwrap().finish().unwrap(); // From group 0, which a time start names whatever is held, so the history below // the feed is asked as a miss rather than looked up. let mut reading = consumer @@ -18377,9 +18378,7 @@ mod joining_fetch_tests { let held = state.subscribes.values().next().unwrap(); (held.producer.clone().unwrap(), held.fill.clone()) }; - let mut head = None; - open_fill_group(&mut track, &mut head, 4).unwrap(); - let (key, next, producer) = head.unwrap(); + let (key, next, producer) = (4, 0, open_fill_group(&mut track, 4).unwrap().unwrap()); *fill.write().ok().unwrap() = Fill::Ready { key, next, @@ -19377,7 +19376,7 @@ mod new_group_tests { let state = self.probe.state.lock(); let copy = state.subscribes.values().next().unwrap().producer.clone().unwrap(); drop(state); - let mut group = copy.create_group(group::Info { start: key }).unwrap(); + let mut group = copy.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), b"key".as_slice()) .unwrap(); diff --git a/rs/moq-net/src/ietf/subscriber/tracks.rs b/rs/moq-net/src/ietf/subscriber/tracks.rs index 03a95b6015f..f7bb1321771 100644 --- a/rs/moq-net/src/ietf/subscriber/tracks.rs +++ b/rs/moq-net/src/ietf/subscriber/tracks.rs @@ -2385,7 +2385,7 @@ mod tests { .producer .clone() .unwrap(); - let mut group = copy.create_group(crate::model::group::Info { start: 5 }).unwrap(); + let mut group = copy.create_group(crate::model::group::Info { start: 5 }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), b"key".as_slice()) .unwrap(); diff --git a/rs/moq-net/src/lite/ietf.rs b/rs/moq-net/src/lite/ietf.rs index 8e9d7380430..43f77c92d78 100644 --- a/rs/moq-net/src/lite/ietf.rs +++ b/rs/moq-net/src/lite/ietf.rs @@ -856,7 +856,7 @@ mod hop_tests { info.properties = track_properties.clone(); let track = broadcast.broadcast().create_track("video", info).unwrap(); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group .set_wire(group::Wire { sparse: false, @@ -1108,7 +1108,7 @@ mod hop_tests { .broadcast() .create_track("video", track::Info::timed().with_timescale(Timescale::MILLI)) .unwrap(); - let mut first = track.create_group(0u64.into()).unwrap(); + let mut first = track.create_group(0u64.into()).unwrap().unwrap(); first.write_frame(ts(5), b"key".to_vec()).unwrap(); first.write_frame(ts(6), b"delta".to_vec()).unwrap(); first.finish().unwrap(); @@ -1146,7 +1146,7 @@ mod hop_tests { ..track::Info::timed() }; let track = broadcast.broadcast().create_track("video", info).unwrap(); - let mut head = track.create_group(0u64.into()).unwrap(); + let mut head = track.create_group(0u64.into()).unwrap().unwrap(); head.write_frame(ts(100), b"frame".to_vec()).unwrap(); head.finish().unwrap(); let (downstream, sessions) = test_hop(&upstream, "room", offer).await; @@ -1193,7 +1193,7 @@ mod hop_tests { // acquire native moq-lite checks merely because it crossed a negotiated hop; // without the extension, the copy is checked, so it advances instead. let start = if negotiated { ts(50) } else { ts(150) }; - let mut group = track.create_group(1u64.into()).unwrap(); + let mut group = track.create_group(1u64.into()).unwrap().unwrap(); group.write_frame(start, b"frame".to_vec()).unwrap(); group.finish().unwrap(); let mut received = recv(&mut subscriber).await; diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index 113bc66af57..771ac07124b 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -3417,7 +3417,7 @@ mod test { let mut subscriber = producer.subscribe(None); let write = |producer: &mut track::Producer, key: u64| { - let mut group = producer.create_group(crate::group::Info { start: key }).unwrap(); + let mut group = producer.create_group(crate::group::Info { start: key }).unwrap().unwrap(); group.write_frame(group.key_time(), b"x".to_vec()).unwrap(); group.finish().unwrap(); }; @@ -3454,7 +3454,7 @@ mod test { ); let write = |producer: &mut track::Producer, key: u64| { - let mut group = producer.create_group(crate::group::Info { start: key }).unwrap(); + let mut group = producer.create_group(crate::group::Info { start: key }).unwrap().unwrap(); group.write_frame(group.key_time(), b"x".to_vec()).unwrap(); group.finish().unwrap(); }; @@ -3480,7 +3480,7 @@ mod test { // The last group is 6 (exclusive 7), but only group 5 has been produced so far. producer .create_group(group::Info { start: 5 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer.finish_at(track::Position::group(7)).unwrap(); @@ -3502,7 +3502,7 @@ mod test { // then the track finishes. producer .create_group(group::Info { start: 6 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); match recv_next(&mut subscriber, false).await.unwrap() { @@ -3558,7 +3558,7 @@ mod test { producer .create_group(group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); match recv_next(&mut subscriber, false).await.unwrap() { @@ -3569,7 +3569,7 @@ mod test { // Group 1 lands after group 2 was already served. producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); match recv_next(&mut subscriber, false).now_or_never() { @@ -7254,7 +7254,7 @@ mod serve_group_test { "video", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 3 }).unwrap(); + let mut group = track.create_group(group::Info { start: 3 }).unwrap().unwrap(); group.start_at(5).unwrap(); group.write_frame(group.key_time(), b"tail".to_vec()).unwrap(); let starting = |frame| Frames { @@ -7273,7 +7273,7 @@ mod serve_group_test { assert!(position_group(group.consume(), &starting(2)).is_none()); // The offset belongs to the start group only; a later group is served whole. - let mut other = track.create_group(group::Info { start: 4 }).unwrap(); + let mut other = track.create_group(group::Info { start: 4 }).unwrap().unwrap(); other.write_frame(other.key_time(), b"whole".to_vec()).unwrap(); let consumer = position_group(other.consume(), &starting(5)).unwrap(); assert_eq!(consumer.index(), 0); @@ -7287,7 +7287,7 @@ mod serve_group_test { "video", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 7 }).unwrap(); + let mut group = track.create_group(group::Info { start: 7 }).unwrap().unwrap(); for i in 0..4u8 { group.write_frame(group.key_time(), vec![i]).unwrap(); } @@ -7367,7 +7367,7 @@ mod serve_group_test { "test", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(0).unwrap(), b"hello".as_slice()) .unwrap(); @@ -7481,7 +7481,7 @@ mod serve_group_test { "test", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(2).unwrap(), b"x".as_slice()) .unwrap(); @@ -7950,7 +7950,7 @@ mod serve_group_test { ); let (mut run, mut writer, log) = lite_run(version, SinkSession::gated_open_uni(gate.consume()), subscriber); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} assert_eq!(run.machines(), 1, "group 0 waits for credit"); @@ -8089,7 +8089,7 @@ mod serve_group_test { "test", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(0).unwrap(), b"hello".as_slice()) .unwrap(); @@ -8186,7 +8186,7 @@ mod serve_group_test { "test", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"hello".as_slice()).unwrap(); let consumer = group.consume(); group.finish().unwrap(); @@ -8360,7 +8360,7 @@ mod serve_group_test { } fn write_group(track: &mut track::Producer, key: u64, millis: u64) { - let mut group = track.create_group(group::Info { start: key }).unwrap(); + let mut group = track.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(millis).unwrap(), b"x".as_slice()) .unwrap(); @@ -8540,7 +8540,7 @@ mod serve_group_test { let log = Log::default(); let (mut run, mut writer, _) = lite07_run(SinkSession::new(log.clone()).with_unacked_fin(), subscriber); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); for millis in 0..FRAMES as u64 { group .write_frame(Timestamp::from_millis(millis).unwrap(), vec![0u8; PAYLOAD]) @@ -9376,7 +9376,7 @@ mod serve_group_test { "test", crate::track::Info::timed(), ); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(0).unwrap(), b"x".as_slice()) .unwrap(); @@ -9655,7 +9655,7 @@ mod serve_group_test { while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} assert!(run.start.resolved().is_some()); - let group = track.create_group(group::Info { start: 1 }).unwrap(); + let group = track.create_group(group::Info { start: 1 }).unwrap().unwrap(); group.abort(Error::App(1)).unwrap(); while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} assert_eq!(drops(&mut writer, &log, version).await, [(1, 1)]); @@ -9812,7 +9812,7 @@ mod serve_group_test { while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} assert!(run.start.resolved().is_some()); - let group = track.create_group(group::Info { start: 1 }).unwrap(); + let group = track.create_group(group::Info { start: 1 }).unwrap().unwrap(); group.abort(Error::App(1)).unwrap(); while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} assert_eq!(drops(&mut writer, &log, version).await, [(1, 1)]); @@ -9882,7 +9882,7 @@ mod serve_group_test { while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} assert!(run.start.resolved().is_some()); - let mut headless = track.create_group(group::Info { start: 1 }).unwrap(); + let mut headless = track.create_group(group::Info { start: 1 }).unwrap().unwrap(); headless.start_at(1).unwrap(); headless .write_frame(Timestamp::from_millis(1).unwrap(), b"x".as_slice()) @@ -10705,7 +10705,7 @@ mod serve_group_test { let mut relay = RelayRun::new(&mut track, 5); // Group 5's first frame is gone. - let mut headless = track.create_group(group::Info { start: 5 }).unwrap(); + let mut headless = track.create_group(group::Info { start: 5 }).unwrap().unwrap(); headless.start_at(1).unwrap(); headless .write_frame(Timestamp::from_millis(5).unwrap(), b"x".as_slice()) @@ -10733,7 +10733,7 @@ mod serve_group_test { track.drop_groups(4..5, StreamError::Old); // Group 5's first frame is gone. - let mut headless = track.create_group(group::Info { start: 5 }).unwrap(); + let mut headless = track.create_group(group::Info { start: 5 }).unwrap().unwrap(); headless.start_at(1).unwrap(); headless .write_frame(Timestamp::from_millis(5).unwrap(), b"x".as_slice()) @@ -12009,7 +12009,7 @@ mod tests { fn write(track: &mut track::Producer, keys: &[u64]) { for &key in keys { - let mut group = track.create_group(group::Info { start: key }).unwrap(); + let mut group = track.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); group.finish().unwrap(); } @@ -12255,7 +12255,7 @@ mod tests { .unwrap(); let track = request.accept(crate::track::Info::timed().with_refresh(crate::track::Refresh::default().with_ratio(1))); - let mut group = track.create_group(group::Info { start: 1 }).unwrap(); + let mut group = track.create_group(group::Info { start: 1 }).unwrap().unwrap(); for frame in [&b"key"[..], b"abc", b"d"] { group.write_frame(group.key_time(), frame).unwrap(); } @@ -12269,7 +12269,7 @@ mod tests { // The asked-for group arrives, over the ratio too. A restated wanted group is now // stale, so it is not another join. - let mut group = track.create_group(group::Info { start: 2 }).unwrap(); + let mut group = track.create_group(group::Info { start: 2 }).unwrap().unwrap(); for frame in [&b"key"[..], b"abc", b"d"] { group.write_frame(group.key_time(), frame).unwrap(); } @@ -12420,7 +12420,7 @@ mod tests { let mut appended = 0; tasks.push(Box::new(move |waiter: &kio::Waiter| { for _ in 0..BATCH.min(GROUPS - appended) { - let mut group = producer.create_group(group::Info { start: appended }).unwrap(); + let mut group = producer.create_group(group::Info { start: appended }).unwrap().unwrap(); group .write_frame(crate::Timestamp::from_millis(appended).unwrap(), b"x".as_slice()) .unwrap(); @@ -13051,7 +13051,7 @@ mod tests { let broadcast = origin.route("room", crate::origin::RouteOptions::hidden()).unwrap(); broadcast.announce().unwrap(); let track = broadcast.broadcast().create_track("video", info).unwrap(); - let mut group = track.create_group(group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); for (millis, payload) in [(0, &b"key"[..]), (33, b"delta")] { group .write_frame(crate::Timestamp::from_millis(millis).unwrap(), payload) diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index a681670af07..cbe9a8dd087 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -3231,7 +3231,7 @@ mod tests { /// A group arriving at the relay as its header lands: cached, then accounted for. fn arrive(track: &track::Producer, tail: &kio::Producer, key: u64, now: crate::time::Instant) { - let mut group = track.create_group(group::Info { start: key }).unwrap(); + let mut group = track.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); @@ -3350,7 +3350,7 @@ mod tests { let h = Harness::new(Version::Lite04); let (mut track, fetching, req) = feed_fetch(3); for key in [5, 6] { - let mut group = track.create_group(group::Info { start: key }).unwrap(); + let mut group = track.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); @@ -3412,7 +3412,7 @@ mod tests { "group 3 was asked for just now (update: {update})" ); - let mut group = track.create_group(group::Info { start: 3 }).unwrap(); + let mut group = track.create_group(group::Info { start: 3 }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); @@ -4866,7 +4866,7 @@ mod tests { ..crate::track::Info::timed() }; let track = track::Producer::new(std::sync::Arc::new(crate::broadcast::Info::default()), "video", info); - let mut before = track.create_group(4u64.into()).unwrap(); + let mut before = track.create_group(4u64.into()).unwrap().unwrap(); before .write_frame(Timestamp::from_millis(1000).unwrap(), &b"before"[..]) .unwrap(); @@ -4951,7 +4951,7 @@ mod tests { "video", crate::track::Info::timed(), ); - let mut cached = track.create_group(group::Info { start: 0 }).unwrap(); + let mut cached = track.create_group(group::Info { start: 0 }).unwrap().unwrap(); cached.write_frame(cached.key_time(), &b"0"[..]).unwrap(); cached.finish().unwrap(); track.set_idle(); @@ -4967,7 +4967,7 @@ mod tests { assert!(!track.is_live(), "the start waits for a group"); entry.answered(None, Some(Position::group(3))); } - let mut newest = track.create_group(group::Info { start: 3 }).unwrap(); + let mut newest = track.create_group(group::Info { start: 3 }).unwrap().unwrap(); newest .write_frame(Timestamp::from_millis(300).unwrap(), &b"3"[..]) .unwrap(); @@ -5024,7 +5024,7 @@ mod tests { "video", crate::track::Info::timed(), ); - let mut cached = track.create_group(group::Info { start: 3 }).unwrap(); + let mut cached = track.create_group(group::Info { start: 3 }).unwrap().unwrap(); cached.write_frame(cached.key_time(), &b"x"[..]).unwrap(); cached.finish().unwrap(); let tail = kio::Producer::new(Tail::default()); @@ -5305,7 +5305,7 @@ mod tests { let broadcast = crate::broadcast::Info::new().produce(); let request = broadcast.reserve_track("video").unwrap(); let serving = ServeLoop::new(&serve, request, crate::track::Info::timed()); - let mut group = serving.serving.create_group(group::Info { start: 2 }).unwrap(); + let mut group = serving.serving.create_group(group::Info { start: 2 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"2".as_slice()).unwrap(); group.finish().unwrap(); let mut reader = broadcast @@ -5596,7 +5596,7 @@ mod tests { ); let requests = copy.requests(); for key in 0..6 { - let mut group = copy.create_group(group::Info { start: key }).unwrap(); + let mut group = copy.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::from_millis(key * 1000).unwrap(), b"x".as_slice()) .unwrap(); @@ -5701,7 +5701,7 @@ mod tests { group.finish().map(drop) }; let arrive = |serving: &mut ServeLoop, key| { - let group = serving.serving.create_group(crate::group::Info { start: key }).unwrap(); + let group = serving.serving.create_group(crate::group::Info { start: key }).unwrap().unwrap(); (group, Reading::open(&tail, Some(key), now())) }; @@ -5806,7 +5806,7 @@ mod tests { groups: first..last + 1, }) }; - let mut group = serving.serving.create_group(crate::group::Info { start: 5 }).unwrap(); + let mut group = serving.serving.create_group(crate::group::Info { start: 5 }).unwrap().unwrap(); group .write_frame(crate::Timestamp::from_millis(5).unwrap(), &b"x"[..]) .unwrap(); @@ -5901,7 +5901,7 @@ mod tests { let request = broadcast.reserve_track("video").unwrap(); let serving = ServeLoop::new(&serve, request, crate::track::Info::timed()); let producer = serving.serving.clone(); - let mut arriving = serving.serving.create_group(group::Info { start: 2 }).unwrap(); + let mut arriving = serving.serving.create_group(group::Info { start: 2 }).unwrap().unwrap(); arriving.write_frame(arriving.key_time(), b"2".as_slice()).unwrap(); let mut reader = broadcast .consume() @@ -5934,7 +5934,7 @@ mod tests { ); // The track goes on: the next group still reaches the reader. - let mut following = producer.create_group(group::Info { start: 3 }).unwrap(); + let mut following = producer.create_group(group::Info { start: 3 }).unwrap().unwrap(); following.write_frame(following.key_time(), b"3".as_slice()).unwrap(); let mut next = reader .recv_group() @@ -8193,7 +8193,7 @@ mod tests { let established = h.wire().len(); let arrive = |serving: &ServeLoop, key| { - let mut group = serving.serving.create_group(group::Info { start: key }).unwrap(); + let mut group = serving.serving.create_group(group::Info { start: key }).unwrap().unwrap(); for frame in [&b"key"[..], b"abc", b"d"] { group .write_frame(crate::Timestamp::unscaled(group.start), frame) diff --git a/rs/moq-net/src/lite/subscriber/fills.rs b/rs/moq-net/src/lite/subscriber/fills.rs index ee7adceca1e..0b97e0d8435 100644 --- a/rs/moq-net/src/lite/subscriber/fills.rs +++ b/rs/moq-net/src/lite/subscriber/fills.rs @@ -827,7 +827,7 @@ mod tests { ); let requests = producer.requests(); for key in 0..6 { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::from_millis(key * 1000).unwrap(), b"x".as_slice()) .unwrap(); diff --git a/rs/moq-net/src/model/broadcast.rs b/rs/moq-net/src/model/broadcast.rs index df07f2dfb06..9736a6e7ef6 100644 --- a/rs/moq-net/src/model/broadcast.rs +++ b/rs/moq-net/src/model/broadcast.rs @@ -2033,7 +2033,7 @@ mod test { // The new consumer should receive the new group, which continues past the first's. producer2 .create_group(crate::group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); track2.assert_group(); @@ -2051,7 +2051,7 @@ mod test { let track = consumer.track("media").unwrap().subscribe(None); let first = dynamic.assert_request().accept(crate::track::Info::timed()); - let mut group = first.create_group(crate::group::Info { start: 8 }).unwrap(); + let mut group = first.create_group(crate::group::Info { start: 8 }).unwrap().unwrap(); group.write_frame(at(1000), b"a".as_slice()).unwrap(); group.finish().unwrap(); let first = first.finish().unwrap(); diff --git a/rs/moq-net/src/model/group.rs b/rs/moq-net/src/model/group.rs index 40c06bf6cc8..2f02163b413 100644 --- a/rs/moq-net/src/model/group.rs +++ b/rs/moq-net/src/model/group.rs @@ -5639,7 +5639,7 @@ mod test { ); let groups: Vec<_> = (0..3) .map(|key| { - let mut group = track.create_group(Info { start: key }).unwrap(); + let mut group = track.create_group(Info { start: key }).unwrap().unwrap(); group.write_frame(group.key_time(), b"f".as_ref()).unwrap(); group.finish().unwrap() }) @@ -6556,7 +6556,7 @@ mod test { .create_track("test", None) .unwrap(); let mut subscriber = track.subscribe(None); - let live = track.create_group(Info { start: 0 }).unwrap(); + let live = track.create_group(Info { start: 0 }).unwrap().unwrap(); kio::clock::sleep(std::time::Duration::from_secs(1)).await; assert_eq!(alone.consume().arrived(), start); diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 38230904420..374ca1c834e 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -9295,7 +9295,7 @@ mod tests { let warns = count_drop_warnings("track::Producer dropped without finish", || { let broadcast = Arc::new(broadcast::Info::default()); let source = track::Producer::new(broadcast.clone(), "catalog.json", crate::track::Info::timed()); - let mut group = source.create_group(7u64.into()).unwrap(); + let mut group = source.create_group(7u64.into()).unwrap().unwrap(); group.write_frame(group.key_time(), b"snapshot".as_ref()).unwrap(); group.finish().unwrap(); let source = source.finish().unwrap(); @@ -10197,7 +10197,7 @@ mod tests { .sum() }; - let mut live = track.create_group(crate::group::Info { start: 1 }).unwrap(); + let mut live = track.create_group(crate::group::Info { start: 1 }).unwrap().unwrap(); live.write_frame(crate::Timestamp::from_millis(1).unwrap(), b"live".as_ref()) .unwrap(); live.finish().unwrap(); @@ -11991,7 +11991,7 @@ mod tests { .expect("the front asked the source") .expect("request"); let source = request.request_start(None).accept(crate::track::Info::timed()); - let mut group = source.create_group(0u64.into()).unwrap(); + let mut group = source.create_group(0u64.into()).unwrap().unwrap(); group.write_frame(group.key_time(), b"snapshot".as_ref()).unwrap(); group.finish().unwrap(); let source = source.finish().unwrap(); @@ -12365,7 +12365,7 @@ mod tests { .await .unwrap() .accept(crate::track::Info::timed()); - let mut group = source.create_group(0u64.into()).unwrap(); + let mut group = source.create_group(0u64.into()).unwrap().unwrap(); group.write_frame(group.key_time(), b"a".as_ref()).unwrap(); group.write_frame(group.key_time(), b"b".as_ref()).unwrap(); let mut subscription = subscribing.await.unwrap().unwrap(); @@ -12424,7 +12424,7 @@ mod tests { }); let mut next = request.request_start(None).accept(crate::track::Info::timed()); next.start_at(0).unwrap(); - let mut next_group = next.create_group(0u64.into()).unwrap(); + let mut next_group = next.create_group(0u64.into()).unwrap().unwrap(); next_group.start_at(2).unwrap(); next_group.write_frame(next_group.key_time(), b"c".as_ref()).unwrap(); assert_eq!(read(&mut reading).await, b"c", "dies_first={dies_first}"); @@ -12543,7 +12543,7 @@ mod tests { // A fresh source copy numbers groups past what the cache already delivered. let source = request.accept(crate::track::Info::timed()); - let mut group = source.create_group(1u64.into()).unwrap(); + let mut group = source.create_group(1u64.into()).unwrap().unwrap(); group.write_frame(group.key_time(), b"late".as_ref()).unwrap(); group.finish().unwrap(); let _source = source.finish().unwrap(); @@ -15274,7 +15274,7 @@ mod tests { let mut group = rig .incumbent_track .create_group(crate::group::Info { start: 5 }) - .unwrap(); + .unwrap().unwrap(); group.write_frame(group.key_time(), b"five".as_ref()).unwrap(); group.finish().unwrap(); assert_eq!(rig.subscription.recv_group().await.unwrap().unwrap().start, 5); diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 7858b13fff2..64d49e640c3 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -3699,11 +3699,11 @@ mod test { let source = copy(); routes.serve(source.consume()); let mut sub = subscribe(if routed { &logical } else { &source }, HOUR); - let mut history = source.create_group(group::Info { start: 0 }).unwrap(); + let mut history = source.create_group(group::Info { start: 0 }).unwrap().unwrap(); history.write_frame(ts(0), b"history".as_ref()).unwrap(); history.finish().unwrap(); let mut finished = recv(&mut sub); - let mut live = source.create_group(group::Info { start: 1 }).unwrap(); + let mut live = source.create_group(group::Info { start: 1 }).unwrap().unwrap(); live.write_frame(ts(1), b"live".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"live".to_vec())); @@ -3751,14 +3751,14 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(1)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"first".as_ref()).unwrap(); let mut held = recv(&mut sub); assert_eq!(read(&mut held), Some(b"first".to_vec())); let b = copy(); let dynamic = b.requests(); - let mut newer = b.create_group(group::Info { start: 1 }).unwrap(); + let mut newer = b.create_group(group::Info { start: 1 }).unwrap().unwrap(); newer.write_frame(ts(1), b"newer".as_ref()).unwrap(); newer.finish().unwrap(); routes.serve(b.consume()); @@ -3777,7 +3777,7 @@ mod test { ); if arrives { - let mut late = b.create_group(group::Info { start: 0 }).unwrap(); + let mut late = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); late.write_frame(ts(0), b"first".as_ref()).unwrap(); late.write_frame(ts(1), b"continued".as_ref()).unwrap(); late.finish().unwrap(); @@ -3809,7 +3809,7 @@ mod test { routes.serve(a.consume()); let mut quick = subscribe(&logical, short); let mut patient = subscribe(&logical, hour); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"first".as_ref()).unwrap(); let mut quick_held = recv(&mut quick); let mut patient_held = recv(&mut patient); @@ -3818,7 +3818,7 @@ mod test { let b = copy(); let dynamic = b.requests(); - let mut newer = b.create_group(group::Info { start: 1 }).unwrap(); + let mut newer = b.create_group(group::Info { start: 1 }).unwrap().unwrap(); newer.write_frame(ts(1), b"newer".as_ref()).unwrap(); newer.finish().unwrap(); routes.serve(b.consume()); @@ -3852,7 +3852,7 @@ mod test { ); drop(quick_held); drop(quick); - let mut late = b.create_group(group::Info { start: 0 }).unwrap(); + let mut late = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); late.write_frame(ts(0), b"first".as_ref()).unwrap(); late.write_frame(ts(1), b"continued".as_ref()).unwrap(); late.finish().unwrap(); @@ -3932,11 +3932,11 @@ mod test { let mut source = copy(); routes.serve(source.consume()); let mut sub = subscribe(&logical, HOUR); - let mut whole = source.create_group(group::Info { start: 0 }).unwrap(); + let mut whole = source.create_group(group::Info { start: 0 }).unwrap().unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); whole.finish().unwrap(); - let mut last = source.create_group(group::Info { start: 2 }).unwrap(); + let mut last = source.create_group(group::Info { start: 2 }).unwrap().unwrap(); last.write_frame(ts(2), b"c".as_ref()).unwrap(); source.finish_at(Position { group: 2, frame: 1 }).unwrap(); let mut first = recv(&mut sub); @@ -4155,7 +4155,7 @@ mod test { a.finish_at(Position { group: 4, frame: 2 }).unwrap(); let b = copy(); routes.serve(b.consume()); - let mut group = b.create_group(group::Info { start: 4 }).unwrap(); + let mut group = b.create_group(group::Info { start: 4 }).unwrap().unwrap(); group.write_frame(ts(0), b"x".as_ref()).unwrap(); let mut reading = recv(&mut sub); // Frames past the end arrive only once the group is handed out. @@ -4471,7 +4471,7 @@ mod test { let routes = Producer::new(); let logical = logical(&routes); let a = copy(); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"x".as_ref()).unwrap(); routes.serve(a.consume()); let subscription = Subscription::default() @@ -4630,7 +4630,7 @@ mod test { let logical = logical(&routes); let resumed = logical.consume(); let source = copy(); - let mut warm = source.create_group(group::Info { start: 2 }).unwrap(); + let mut warm = source.create_group(group::Info { start: 2 }).unwrap().unwrap(); warm.write_frame(crate::Timestamp::from_millis(0).unwrap(), b"2-0".as_ref()) .unwrap(); warm.finish().unwrap(); @@ -4656,7 +4656,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::ZERO); - let mut group = a.create_group(group::Info { start: 0 }).unwrap(); + let mut group = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(ts(0), b"a".as_ref()).unwrap(); group.finish().unwrap(); @@ -4740,7 +4740,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(if routed { &logical } else { &a }, Duration::from_secs(1)); for second in 0..4 { - let mut group = a.create_group(group::Info { start: second * 1000 }).unwrap(); + let mut group = a.create_group(group::Info { start: second * 1000 }).unwrap().unwrap(); group.write_frame(ts(second * 1000), b"x".as_ref()).unwrap(); group.finish().unwrap(); } @@ -4759,7 +4759,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); open.write_frame(ts(1), b"b".as_ref()).unwrap(); let mut reading = recv(&mut sub); @@ -4768,7 +4768,7 @@ mod test { // The replacement holds the whole group; the replaced route stays quiet. let b = copy(); - let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); + let mut whole = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); for (ms, frame) in [(0, b"a"), (1, b"b"), (2, b"c")] { whole.write_frame(ts(ms), frame.as_ref()).unwrap(); } @@ -4796,7 +4796,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&track, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); open.write_frame(ts(1), b"b".as_ref()).unwrap(); let mut reading = recv(&mut sub); @@ -4810,7 +4810,7 @@ mod test { assert_eq!(asked.resume, Some(Position::new(0, 2)), "past the two frames held"); // The new copy gets only the rest, and the reader reads on from it. - let mut rest = b.create_group(group::Info { start: 0 }).unwrap(); + let mut rest = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); rest.start_at(2).unwrap(); rest.write_frame(ts(2), b"c".as_ref()).unwrap(); rest.finish().unwrap(); @@ -4914,7 +4914,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -4946,7 +4946,7 @@ mod test { .map(|index| format!("{index}{}", "z".repeat(64)).into()) .collect(); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), frames[0].clone()).unwrap(); open.write_frame(ts(1), frames[1].clone()).unwrap(); let mut reading = recv(&mut sub); @@ -4983,7 +4983,7 @@ mod test { let mut sub = subscribe(&logical, Duration::from_secs(10)); let frame = || bytes::Bytes::from("z".repeat(64)); - let mut group = a.create_group(group::Info { start: 0 }).unwrap(); + let mut group = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(ts(0), frame()).unwrap(); let slice = super::super::flate::Encoder::new().frame(&frame()); let header = crate::model::frame::Header { @@ -5025,7 +5025,7 @@ mod test { let mut sub = subscribe(&logical, Duration::from_secs(10)); let frame = || bytes::Bytes::from("z".repeat(64)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), frame()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(frame().to_vec())); @@ -5064,7 +5064,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let open = a.create_group(group::Info { start: 0 }).unwrap(); + let open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut frame = open .create_frame(crate::frame::Info { size: 4, @@ -5083,7 +5083,7 @@ mod test { drop(frame); a.clone().abort(Error::Dropped).unwrap(); let b = copy(); - let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); + let mut whole = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); whole.write_frame(ts(0), b"abcd".as_ref()).unwrap(); routes.serve(b.consume()); @@ -5106,7 +5106,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -5153,7 +5153,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -5163,7 +5163,7 @@ mod test { for _ in 0..3 { assert!(reading.read_frame().now_or_never().is_none()); } - let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); + let mut whole = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); for (ms, frame) in [(0, b"a"), (1, b"b")] { whole.write_frame(ts(ms), frame.as_ref()).unwrap(); } @@ -5184,7 +5184,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -5212,7 +5212,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -5241,7 +5241,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -5269,7 +5269,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -5278,7 +5278,7 @@ mod test { assert!(reading.read_frame().now_or_never().is_none()); let b = copy(); - let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); + let mut whole = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); whole.finish().unwrap(); @@ -5297,7 +5297,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -5319,7 +5319,7 @@ mod test { let dynamic = a.requests(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -5336,7 +5336,7 @@ mod test { assert!(reading.read_frame().now_or_never().is_none(), "still waiting"); let b = copy(); - let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); + let mut whole = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); whole.finish().unwrap(); @@ -5359,7 +5359,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = if fetched { logical.consume().fetch_group(0, None).now_or_never().unwrap().unwrap() @@ -5392,7 +5392,7 @@ mod test { // Another route holds it: the group continues there. let b = copy(); - let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); + let mut whole = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); whole.finish().unwrap(); @@ -5411,7 +5411,7 @@ mod test { let logical = logical(&routes); let a = copy(); routes.serve(a.consume()); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut fetched = logical.consume().fetch_group(0, None).now_or_never().unwrap().unwrap(); assert_eq!( @@ -5445,7 +5445,7 @@ mod test { let logical = logical(&routes); let a = copy(); routes.serve(a.consume()); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut fetched = logical.consume().fetch_group(0, None).now_or_never().unwrap().unwrap(); assert_eq!(read(&mut fetched), Some(b"a".to_vec())); @@ -5484,7 +5484,7 @@ mod test { let a = copy(); let dynamic = a.requests(); routes.serve(a.consume()); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let _a = a.finish().unwrap(); let mut fetched = logical.consume().fetch_group(0, None).now_or_never().unwrap().unwrap(); @@ -5505,7 +5505,7 @@ mod test { continue; } let b = copy(); - let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); + let mut whole = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); whole.finish().unwrap(); @@ -5526,11 +5526,11 @@ mod test { let a = copy(); let dynamic = a.requests(); routes.serve(a.consume()); - let mut group = a.create_group(group::Info { start: 0 }).unwrap(); + let mut group = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(ts(0), b"a".as_ref()).unwrap(); group.finish().unwrap(); // Groups 1 and 2 are missing below the end: a fetch asks for them. - a.create_group(group::Info { start: 3 }).unwrap().finish().unwrap(); + a.create_group(group::Info { start: 3 }).unwrap().unwrap().finish().unwrap(); let last = a.consume(); let a = a.finish().unwrap(); routes.end(Ok(())); @@ -6102,7 +6102,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); open.write_frame(ts(1), b"b".as_ref()).unwrap(); let mut reading = recv(&mut sub); @@ -6146,7 +6146,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -6173,7 +6173,7 @@ mod test { let routes = Producer::new(); let a = copy(); routes.serve(a.consume()); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut fetched = logical(&routes) .consume() @@ -6210,7 +6210,7 @@ mod test { let routes = Producer::new(); let a = copy(); routes.serve(a.consume()); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut fetched = logical(&routes) .consume() @@ -6235,7 +6235,7 @@ mod test { let routes = Producer::new(); let a = track::Producer::new(Arc::new(broadcast::Info::default()), "video", info.clone()); routes.serve(a.consume()); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut drain = open.consume(); // Two frames that compress to almost nothing, but inflate past the tail together. for _ in 0..2 { @@ -6261,14 +6261,14 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); // B holds the whole group, then its route fails, keeping it. let b = copy(); - let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); + let mut whole = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); whole.finish().unwrap(); @@ -6308,7 +6308,7 @@ mod test { let b = copy(); for (track, keys) in [(&a, 0..2), (&b, 0..3)] { for key in keys { - let mut group = track.create_group(group::Info { start: key }).unwrap(); + let mut group = track.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(ts(key), b"x".as_ref()).unwrap(); group.finish().unwrap(); } @@ -6523,7 +6523,7 @@ mod test { /// Write a finished one-frame group, presented at its key in milliseconds. fn write(track: &track::Producer, key: u64) { - let mut group = track.create_group(group::Info { start: key }).unwrap(); + let mut group = track.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(ts(key), b"x".as_ref()).unwrap(); group.finish().unwrap(); } @@ -6619,7 +6619,7 @@ mod test { a.anchored(); routes.serve(a.consume()); write(&a, 10); - let mut open = a.create_group(group::Info { start: 100 }).unwrap(); + let mut open = a.create_group(group::Info { start: 100 }).unwrap().unwrap(); open.write_frame(ts(100), b"x".as_ref()).unwrap(); let subscription = Subscription::default() .with_delay(Delay::default().with_max(None)) @@ -6670,7 +6670,7 @@ mod test { a.anchored(); routes.serve(a.consume()); write(&a, 10); - let mut open = a.create_group(group::Info { start: 100 }).unwrap(); + let mut open = a.create_group(group::Info { start: 100 }).unwrap().unwrap(); open.write_frame(ts(100), b"x".as_ref()).unwrap(); let subscription = Subscription::default() .with_delay(Delay::default().with_max(None)) @@ -6715,7 +6715,7 @@ mod test { a.anchored(); routes.serve(a.consume()); write(&a, 10); - let mut open = a.create_group(group::Info { start: 100 }).unwrap(); + let mut open = a.create_group(group::Info { start: 100 }).unwrap().unwrap(); open.write_frame(ts(100), b"x".as_ref()).unwrap(); let subscription = Subscription::default() .with_delay(Delay::default().with_max(None)) @@ -7369,7 +7369,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(if nested { &outer } else { &inner }, HOUR); - let mut one = a.create_group(group::Info { start: 1 }).unwrap(); + let mut one = a.create_group(group::Info { start: 1 }).unwrap().unwrap(); one.write_frame(ts(1), b"x".as_ref()).unwrap(); let one = one.finish().unwrap(); write(&a, 3); @@ -7408,7 +7408,7 @@ mod test { write(&a, 3); } drain(&mut sub, ordered); - let mut two = a.create_group(group::Info { start: 2 }).unwrap(); + let mut two = a.create_group(group::Info { start: 2 }).unwrap().unwrap(); two.write_frame(ts(2), b"x".as_ref()).unwrap(); let two = two.finish().unwrap(); let reserved = peek(&mut sub, ordered); @@ -7637,7 +7637,7 @@ mod test { let b = copy(); routes.serve(b.consume()); - let mut failing = b.create_group(group::Info { start: 1 }).unwrap(); + let mut failing = b.create_group(group::Info { start: 1 }).unwrap().unwrap(); failing.write_frame(ts(1), b"a".as_ref()).unwrap(); let noop = kio::Waiter::noop(); let res = match ordered { @@ -7651,7 +7651,7 @@ mod test { assert_eq!(drain(&mut sub, ordered), Vec::::new()); // The old route finishes group 1 only now, and the new route's copy of it fails. - let mut whole = a.create_group(group::Info { start: 1 }).unwrap(); + let mut whole = a.create_group(group::Info { start: 1 }).unwrap().unwrap(); whole.write_frame(ts(1), b"a".as_ref()).unwrap(); whole.write_frame(ts(2), b"b".as_ref()).unwrap(); whole.finish().unwrap(); @@ -7681,7 +7681,7 @@ mod test { let c = copy(); routes.serve(c.consume()); - let mut failing = c.create_group(group::Info { start: 1 }).unwrap(); + let mut failing = c.create_group(group::Info { start: 1 }).unwrap().unwrap(); failing.write_frame(ts(1), b"a".as_ref()).unwrap(); let noop = kio::Waiter::noop(); let res = match ordered { @@ -7695,7 +7695,7 @@ mod test { assert_eq!(drain(&mut sub, ordered), Vec::::new()); // b's first group lands only now, and c's copy of it fails. - let mut whole = b.create_group(group::Info { start: 1 }).unwrap(); + let mut whole = b.create_group(group::Info { start: 1 }).unwrap().unwrap(); whole.write_frame(ts(1), b"a".as_ref()).unwrap(); whole.write_frame(ts(2), b"b".as_ref()).unwrap(); whole.finish().unwrap(); @@ -7870,7 +7870,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -7879,7 +7879,7 @@ mod test { assert!(reading.read_frame().now_or_never().is_none(), "no verdict yet"); let b = copy(); - let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); + let mut whole = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); whole.finish().unwrap(); @@ -7906,14 +7906,14 @@ mod test { routes.serve(c.consume()); // Every route holds group 1: a whole, b cut off by its route failing, c failing after a frame. - let mut whole = a.create_group(group::Info { start: 1 }).unwrap(); + let mut whole = a.create_group(group::Info { start: 1 }).unwrap().unwrap(); whole.write_frame(ts(1), b"a".as_ref()).unwrap(); whole.write_frame(ts(2), b"b".as_ref()).unwrap(); whole.finish().unwrap(); - let mut partial = b.create_group(group::Info { start: 1 }).unwrap(); + let mut partial = b.create_group(group::Info { start: 1 }).unwrap().unwrap(); partial.write_frame(ts(1), b"a".as_ref()).unwrap(); b.clone().abort(Error::Dropped).unwrap(); - let mut failing = c.create_group(group::Info { start: 1 }).unwrap(); + let mut failing = c.create_group(group::Info { start: 1 }).unwrap().unwrap(); failing.write_frame(ts(1), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(reading.start, 1); @@ -7946,11 +7946,11 @@ mod test { routes.serve(b.consume()); // Both routes hold group 1: the old one whole, the serving one failing after a frame. - let mut whole = a.create_group(group::Info { start: 1 }).unwrap(); + let mut whole = a.create_group(group::Info { start: 1 }).unwrap().unwrap(); whole.write_frame(ts(1), b"a".as_ref()).unwrap(); whole.write_frame(ts(2), b"b".as_ref()).unwrap(); whole.finish().unwrap(); - let mut failing = b.create_group(group::Info { start: 1 }).unwrap(); + let mut failing = b.create_group(group::Info { start: 1 }).unwrap().unwrap(); failing.write_frame(ts(1), b"a".as_ref()).unwrap(); let mut failing = Some(failing); if early { @@ -7998,11 +7998,11 @@ mod test { let b = copy(); routes.serve(b.consume()); - let mut whole = a.create_group(group::Info { start: 1 }).unwrap(); + let mut whole = a.create_group(group::Info { start: 1 }).unwrap().unwrap(); whole.write_frame(ts(1), b"a".as_ref()).unwrap(); whole.write_frame(ts(2), b"b".as_ref()).unwrap(); whole.finish().unwrap(); - let mut failing = b.create_group(group::Info { start: 1 }).unwrap(); + let mut failing = b.create_group(group::Info { start: 1 }).unwrap().unwrap(); failing.write_frame(ts(1), b"a".as_ref()).unwrap(); let res = match ordered { true => sub.poll_next_group(&kio::Waiter::noop()), @@ -8041,7 +8041,7 @@ mod test { routes.serve(b.consume()); // The serving route has nothing yet, so group 8 comes from the replaced one. - let mut open = a.create_group(group::Info { start: 8 }).unwrap(); + let mut open = a.create_group(group::Info { start: 8 }).unwrap().unwrap(); open.write_frame(ts(8), b"a".as_ref()).unwrap(); let res = match ordered { true => sub.poll_next_group(&kio::Waiter::noop()), @@ -8115,7 +8115,7 @@ mod test { routes.serve(a.consume()); let budget = Duration::from_secs(1); let mut sub = subscribe(&logical, budget); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -8243,7 +8243,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); write(&a, 0); - let open = a.create_group(group::Info { start: 1 }).unwrap(); + let open = a.create_group(group::Info { start: 1 }).unwrap().unwrap(); assert_eq!(drain(&mut sub, false), [0, 1]); open.abort(Error::Cancel).unwrap(); @@ -8299,7 +8299,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); sub.set_range(..=0); - let mut held = a.create_group(group::Info { start: 0 }).unwrap(); + let mut held = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); held.write_frame(ts(0), b"a".as_ref()).unwrap(); let Poll::Ready(Ok(Some(reading))) = sub.poll_recv_group(&kio::Waiter::noop()) else { panic!("group 0 is handed out") @@ -8380,7 +8380,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut group = a.create_group(group::Info { start: 5 }).unwrap(); + let mut group = a.create_group(group::Info { start: 5 }).unwrap().unwrap(); group.write_frame(ts(5), b"x".as_ref()).unwrap(); group.finish().unwrap(); assert_eq!(recv(&mut sub).start, 5); @@ -8390,7 +8390,7 @@ mod test { // Subscribe the replacement before it has anything, so the update moves a ready copy. assert!(sub.recv_group().now_or_never().is_none()); for key in [2, 6] { - let mut group = b.create_group(group::Info { start: key }).unwrap(); + let mut group = b.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(ts(key), b"x".as_ref()).unwrap(); group.finish().unwrap(); } @@ -8486,7 +8486,7 @@ mod test { .unwrap() .unwrap(); for key in 0..13 { - let mut group = a.create_group(group::Info { start: key * 1000 }).unwrap(); + let mut group = a.create_group(group::Info { start: key * 1000 }).unwrap().unwrap(); group.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); group.finish().unwrap(); } @@ -8500,7 +8500,7 @@ mod test { rest.push(group.start); } for key in 0..13 { - let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); + let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap().unwrap(); group.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); group.finish().unwrap(); } @@ -8756,7 +8756,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(30)); - let mut five = a.create_group(group::Info { start: 5000 }).unwrap(); + let mut five = a.create_group(group::Info { start: 5000 }).unwrap().unwrap(); five.write_frame(ts(5000), b"x".as_ref()).unwrap(); assert_eq!(recv(&mut sub).start, 5000); @@ -8773,7 +8773,7 @@ mod test { let b = b.accept(crate::track::Info::timed()); for key in 0..7 { - let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); + let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap().unwrap(); group.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); group.finish().unwrap(); } @@ -8893,7 +8893,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(30)); - let mut zero = a.create_group(group::Info { start: 0 }).unwrap(); + let mut zero = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); zero.write_frame(ts(0), b"x".as_ref()).unwrap(); assert_eq!(recv(&mut sub).start, 0); @@ -8910,7 +8910,7 @@ mod test { let b = b.accept(crate::track::Info::timed()); for key in 0..13 { - let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); + let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap().unwrap(); group.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); group.finish().unwrap(); } @@ -9012,7 +9012,7 @@ mod test { a.received(); routes.serve(a.consume()); let mut sub = subscribe(&front, Duration::from_secs(30)); - let mut zero = a.create_group(group::Info { start: 0 }).unwrap(); + let mut zero = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); zero.write_frame(ts(0), b"x".as_ref()).unwrap(); assert_eq!(recv(&mut sub).start, 0); @@ -9027,7 +9027,7 @@ mod test { sub.update(sub.subscription().with_ranges(ranges)).unwrap(); assert!(sub.recv_group().now_or_never().is_none()); for key in 1..4 { - let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); + let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap().unwrap(); group.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); group.finish().unwrap(); } @@ -9073,7 +9073,7 @@ mod test { let routes = Producer::new(); let a = copy(); routes.serve(a.consume()); - let mut first = a.create_group(group::Info { start: 3000 }).unwrap(); + let mut first = a.create_group(group::Info { start: 3000 }).unwrap().unwrap(); first.write_frame(ts(3000), b"x".as_ref()).unwrap(); first.finish().unwrap(); let range = track::Range { @@ -9212,7 +9212,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let mut first = a.create_group(group::Info { start: 0 }).unwrap(); + let mut first = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); first.write_frame(ts(0), b"a0".as_ref()).unwrap(); assert_eq!(recv(&mut sub).start, 0); @@ -9220,7 +9220,7 @@ mod test { routes.serve(b.consume()); // Both routes go on to group 1; only the serving one's copy counts. for (track, payload) in [(&a, b"a1"), (&b, b"b1")] { - let mut group = track.create_group(group::Info { start: 1 }).unwrap(); + let mut group = track.create_group(group::Info { start: 1 }).unwrap().unwrap(); group.write_frame(ts(1), payload.as_ref()).unwrap(); group.finish().unwrap(); } @@ -9237,7 +9237,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(2)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -9247,13 +9247,13 @@ mod test { let b = copy(); routes.serve(b.consume()); for key in 1..=2 { - let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); + let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap().unwrap(); group.write_frame(ts(key * 1000), b"b".as_ref()).unwrap(); group.finish().unwrap(); } assert!(reading.read_frame().now_or_never().is_none(), "not stale yet"); - let mut group = b.create_group(group::Info { start: 3000 }).unwrap(); + let mut group = b.create_group(group::Info { start: 3000 }).unwrap().unwrap(); group.write_frame(ts(3000), b"b".as_ref()).unwrap(); assert!(matches!(reading.read_frame().now_or_never(), Some(Err(Error::Old)))); } @@ -9277,7 +9277,7 @@ mod test { let a = untimed(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(1)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(crate::Timestamp::unscaled(open.start), b"a".as_ref()) .unwrap(); let mut reading = recv(&mut sub); @@ -9288,7 +9288,7 @@ mod test { // A driver collects the replacement's pool, so its wall deadlines fire. pool.step(Duration::ZERO); let write = |key| { - let mut group = b.create_group(group::Info { start: key }).unwrap(); + let mut group = b.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), b"b".as_ref()) .unwrap(); @@ -9443,7 +9443,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let _open = a.create_group(group::Info { start: 0 }).unwrap(); + let _open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut reading = recv(&mut sub); let wake = Arc::new(Wake::default()); let waiter = kio::Waiter::new(wake.clone().into()); @@ -9484,13 +9484,13 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_millis(100)); for (key, ms) in [(0, 0), (1, 1000)] { - let mut group = a.create_group(group::Info { start: key }).unwrap(); + let mut group = a.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(ts(ms), b"x".as_ref()).unwrap(); group.finish().unwrap(); } assert_eq!(recv(&mut sub).start, 0); assert_eq!(recv(&mut sub).start, 1); - let mut open = a.create_group(group::Info { start: 2 }).unwrap(); + let mut open = a.create_group(group::Info { start: 2 }).unwrap().unwrap(); open.write_frame(ts(2000), b"held".as_ref()).unwrap(); let mut group = recv(&mut sub); assert_eq!(read(&mut group), Some(b"held".to_vec())); @@ -9511,7 +9511,7 @@ mod test { let groups = groups .iter() .map(|&(key, ms)| { - let mut group = b.create_group(group::Info { start: key }).unwrap(); + let mut group = b.create_group(group::Info { start: key }).unwrap().unwrap(); if let Some(ms) = ms { group.write_frame(ts(ms), b"b".as_ref()).unwrap(); } @@ -9556,7 +9556,7 @@ mod test { } fn group(&self, key: u64) -> group::Producer { - self.copy.create_group(group::Info { start: key }).unwrap() + self.copy.create_group(group::Info { start: key }).unwrap().unwrap() } } @@ -9639,7 +9639,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let open = a.create_group(group::Info { start: 0 }).unwrap(); + let open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut frame = open .create_frame(crate::frame::Info { size: 4, @@ -9655,12 +9655,12 @@ mod test { ); let b = copy(); - let mut replacement = b.create_group(group::Info { start: 0 }).unwrap(); + let mut replacement = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); routes.serve(b.consume()); assert!(chunks.read_chunk().now_or_never().is_none()); if !arrives { for key in 1..=4 { - let mut group = b.create_group(group::Info { start: key }).unwrap(); + let mut group = b.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(ts(key * 10_000), b"new".as_ref()).unwrap(); group.finish().unwrap(); } @@ -9689,7 +9689,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(2)); - let open = a.create_group(group::Info { start: 0 }).unwrap(); + let open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut frame = open .create_frame(crate::frame::Info { size: 4, @@ -9702,7 +9702,7 @@ mod test { assert!(chunks.read_chunk().now_or_never().unwrap().is_ok()); let b = copy(); - let replacement = b.create_group(group::Info { start: 0 }).unwrap(); + let replacement = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut replacement_frame = replacement .create_frame(crate::frame::Info { size: 4, @@ -9715,7 +9715,7 @@ mod test { // Transfer the group cursor too, while its next frame is still pending. assert!(reading.read_frame().now_or_never().is_none()); for key in 1..=4 { - let mut next = b.create_group(group::Info { start: key }).unwrap(); + let mut next = b.create_group(group::Info { start: key }).unwrap().unwrap(); next.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); next.finish().unwrap(); } @@ -9742,7 +9742,7 @@ mod test { let _request = dynamic.requested_fill_group().now_or_never().unwrap().unwrap(); wake.0.store(false, std::sync::atomic::Ordering::Relaxed); let b = copy(); - let mut group = b.create_group(group::Info { start: 0 }).unwrap(); + let mut group = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(ts(0), b"b".as_ref()).unwrap(); group.finish().unwrap(); routes.serve(b.consume()); @@ -9790,7 +9790,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(2)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -9799,7 +9799,7 @@ mod test { routes.serve(b.consume()); assert!(reading.read_frame().now_or_never().is_none()); for key in 1..=4 { - let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); + let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap().unwrap(); group.write_frame(ts(key * 1000), b"b".as_ref()).unwrap(); group.finish().unwrap(); } @@ -9812,7 +9812,7 @@ mod test { let routes = Producer::new(); let logical = logical(&routes); let a = copy(); - let group = a.create_group(group::Info { start: 0 }).unwrap(); + let group = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); group .set_wire(group::Wire { sparse: false, @@ -9880,7 +9880,7 @@ mod test { let routes = Producer::new(); let logical = logical(&routes); let a = copy(); - let mut group = a.create_group(group::Info { start: 0 }).unwrap(); + let mut group = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); group .set_wire(group::Wire { sparse: false, @@ -9926,7 +9926,7 @@ mod test { #[cfg(feature = "async")] fn joined_past_a_gap(objects: &[(u64, &'static [u8])]) -> track::Producer { let b = copy(); - let mut group = b.create_group(group::Info { start: 0 }).unwrap(); + let mut group = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); group .set_wire(group::Wire { sparse: false, @@ -9968,7 +9968,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&front, Duration::from_secs(10)); - let open = a.create_group(group::Info { start: 0 }).unwrap(); + let open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut frame = open .create_frame(crate::frame::Info { size: 4, @@ -9997,7 +9997,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&front, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); open.write_frame(ts(1), b"b".as_ref()).unwrap(); let mut reading = recv(&mut sub); @@ -10018,7 +10018,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&front, Duration::from_secs(10)); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); let b = joined_past_a_gap(&[(6, b"x"), (7, b"y"), (8, b"z")]); @@ -10045,7 +10045,7 @@ mod test { fn a_fetched_group_wakes_when_the_route_changes() { let routes = Producer::new(); let a = copy(); - let _open = a.create_group(group::Info { start: 0 }).unwrap(); + let _open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); routes.serve(a.consume()); let mut reading = logical(&routes) .consume() @@ -10070,7 +10070,7 @@ mod test { let dynamic = a.requests(); routes.serve(a.consume()); - let mut arriving = a.create_group(group::Info { start: 0 }).unwrap(); + let mut arriving = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); arriving.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut fetched = logical(&routes) .consume() @@ -10125,7 +10125,7 @@ mod test { let dynamic = a.requests(); routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = match fetched { true => logical.consume().fetch_group(0, None).now_or_never().unwrap().unwrap(), @@ -10161,7 +10161,7 @@ mod test { let a_requests = a.requests(); routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = match fetched { true => logical.consume().fetch_group(0, None).now_or_never().unwrap().unwrap(), @@ -10172,7 +10172,7 @@ mod test { let b = copy(); let b_requests = b.requests(); routes.serve(b.consume()); - let mut repeat = b.create_group(group::Info { start: 0 }).unwrap(); + let mut repeat = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); repeat.write_frame(ts(0), b"a".as_ref()).unwrap(); open.abort(Error::WrongSize).unwrap(); assert!(reading.read_frame().now_or_never().is_none(), "fetched={fetched}"); @@ -10203,7 +10203,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -10230,7 +10230,7 @@ mod test { let routes = Producer::new(); let a = copy(); routes.serve(a.consume()); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let logical = logical(&routes); @@ -10252,7 +10252,7 @@ mod test { let routes = Producer::new(); let a = copy(); routes.serve(a.consume()); - let mut open = a.create_group(group::Info { start: 0 }).unwrap(); + let mut open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(ts(0), b"a".as_ref()).unwrap(); let budget = Duration::from_millis(500); @@ -10274,7 +10274,7 @@ mod test { // The new route runs a full second past the group's successor while its fetch is unanswered. for (key, ms) in [(1, 1000), (2, 2000)] { - let mut group = b.create_group(group::Info { start: key }).unwrap(); + let mut group = b.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(ts(ms), b"x".as_ref()).unwrap(); group.finish().unwrap(); } @@ -10289,7 +10289,7 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let _open = a.create_group(group::Info { start: 0 }).unwrap(); + let _open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut reading = recv(&mut sub); assert!(reading.read_frame().now_or_never().is_none()); routes.end(Err(Error::Unroutable)); @@ -10522,10 +10522,10 @@ mod test { let a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, Duration::from_secs(10)); - let _open = a.create_group(group::Info { start: 0 }).unwrap(); + let _open = a.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut reading = recv(&mut sub); let b = copy(); - let mut replacement = b.create_group(group::Info { start: 0 }).unwrap(); + let mut replacement = b.create_group(group::Info { start: 0 }).unwrap().unwrap(); replacement.write_frame(ts(0), b"b".as_ref()).unwrap(); routes.serve(b.consume()); assert_eq!(read(&mut reading), Some(b"b".to_vec())); @@ -10566,7 +10566,7 @@ mod test { let mut sub = subscribe(&logical, Duration::from_secs(if widen { 2 } else { 10 })); let b = copy(); // Both routes carry the same content, including the unfinished payload. - let writers = [&a, &b].map(|source| source.create_group(group::Info { start: 0 }).unwrap()); + let writers = [&a, &b].map(|source| source.create_group(group::Info { start: 0 }).unwrap().unwrap()); // Each group's writer, held open by its unfinished frame when chunked. let _writers: Vec<_> = writers .into_iter() @@ -10631,7 +10631,7 @@ mod test { "recovered={recovered}, widen={widen}, chunked={chunked}: preference update did not reach the copy" ); for key in 1..=4 { - let mut next = source.create_group(group::Info { start: key }).unwrap(); + let mut next = source.create_group(group::Info { start: key }).unwrap().unwrap(); next.write_frame(ts(key * 1000), b"next".as_ref()).unwrap(); next.finish().unwrap(); } @@ -10693,7 +10693,7 @@ mod test { routes.serve(copies[0].consume()); let mut writers: Vec<_> = copies .iter() - .map(|copy| Some(copy.create_group(group::Info { start: 0 }).unwrap())) + .map(|copy| Some(copy.create_group(group::Info { start: 0 }).unwrap().unwrap())) .collect(); writers[0] .as_mut() diff --git a/rs/moq-net/src/model/resume_model.rs b/rs/moq-net/src/model/resume_model.rs index e941713108b..feb7cfdd3df 100644 --- a/rs/moq-net/src/model/resume_model.rs +++ b/rs/moq-net/src/model/resume_model.rs @@ -509,7 +509,7 @@ impl Model { } let parts = copy.groups.entry(group).or_default(); if !parts.iter().any(|part| part.from == 0) - && let Ok(writer) = copy.track.create_group(group::Info { start: group }) + && let Ok(Some(writer)) = copy.track.create_group(group::Info { start: group }) { parts.push(Part { from: 0, diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 1916410c2be..7ae43eff75b 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -2992,27 +2992,17 @@ impl TrackState { self.max_key.map_or(0, |max| max + 1) } - /// Reject a key that is still cached; a dead (aborted or evicted) - /// incarnation is removed so a fresh group can serve the key again. Subscribers may - /// have seen its start, so it stays as the eviction watermark. + /// The copy of the feed's `key` that still answers from `frame_start`, if any. /// - /// Best effort: nothing remembers a key whose slot is already gone, so a - /// publisher re-sending a long-evicted key is accepted as new. - /// A group that starts above `frame_start` is also replaceable: it cannot answer a - /// request from there, so the wider producer takes the slot. Readers already - /// draining the old one keep their own handle. + /// A dead (aborted or evicted) incarnation holds nothing, so a fresh group can serve the + /// key again; subscribers may have seen its start, so it stays as the eviction watermark. + /// Best effort: nothing remembers a key whose slot is already gone, so a publisher + /// re-sending a long-evicted key is accepted as new. A group that starts above + /// `frame_start` holds nothing either: it cannot answer a request from there, so the wider + /// producer takes the slot, and readers already draining the old one keep their own handle. /// /// A fetched backfill never holds the key against the feed: subscribers read only /// the feed's groups, so its copy takes the slot, and the fetch's readers keep theirs. - fn claim_key(&mut self, key: u64, frame_start: u64) -> Result<()> { - if self.holding_group(key, frame_start).is_some() { - return Err(Error::Duplicate); - } - self.displace(key); - Ok(()) - } - - /// The copy of the feed's `key` that still answers from `frame_start`, if any. fn holding_group(&self, key: u64, frame_start: u64) -> Option<&group::Handle> { self.lookup.get(&key).filter(|slot| slot.visible)?; self.covering_group(key, frame_start) @@ -4566,18 +4556,18 @@ impl Producer { /// It says nothing about the starts around it: groups may be created out of order, and /// an aborted or evicted start created again. A gap it leaves is skipped only once the /// producer says it will not fill it, with [`Self::skip_groups`] or [`Self::append_group`]. - /// A start already skipped is refused with [`Error::Skipped`], one held by another group - /// with [`Error::Duplicate`], and the reserved start `u64::MAX` with + /// Returns `None` while another live group holds the start. A start already skipped is + /// refused with [`Error::Skipped`], and the reserved start `u64::MAX` with /// [`Error::BoundsExceeded`]. /// /// Readers and group demand reach it at once, but the track counts it as content (its /// live edge, or the successor that ages the group before it) only once its first frame /// opens or it finishes. - pub fn create_group(&self, group: group::Info) -> Result { - match self.create_group_inner(group, None)? { - Received::Group(group) => Ok(group), + pub fn create_group(&self, group: group::Info) -> Result> { + Ok(self.create_group_inner(group, None)?.map(|received| match received { + Received::Group(group) => group, Received::Held(_) => unreachable!("only a received copy waits on another"), - } + })) } /// A received copy starts at its wire offset before any reader can see it. @@ -4586,10 +4576,11 @@ impl Producer { /// this copy with [`Error::Duplicate`], and one still arriving is returned to wait on. #[cfg(feature = "async")] pub(crate) fn create_group_at(&self, group: group::Info, start: u64) -> Result { - self.create_group_inner(group, Some(start)) + self.create_group_inner(group, Some(start))?.ok_or(Error::Duplicate) } - fn create_group_inner(&self, info: group::Info, received: Option) -> Result { + /// `None` when a live copy already answers from the requested frame. + fn create_group_inner(&self, info: group::Info, received: Option) -> Result> { // Reserved, so every group fits an exclusive range. if info.start == u64::MAX { return Err(coding::BoundsExceeded.into()); @@ -4607,22 +4598,25 @@ impl Producer { let content = if received.is_some() { if let Some(holding) = state.holding_group(info.start, start) { if holding.is_settled() { - return Err(Error::Duplicate); + return Ok(None); } let arriving = holding.clone(); state.holds.entry(info.start).or_default().push(arriving.clone()); - return Ok(Received::Held(Hold { + return Ok(Some(Received::Held(Hold { arriving, track: self.state.downgrade(), key: info.start, - })); + }))); } state.content_for_copy(info.start)? } else { None }; + if state.holding_group(info.start, start).is_some() { + return Ok(None); + } let track = state.info.clone().unwrap(); - state.claim_key(info.start, start)?; + state.displace(info.start); let mut group = group::Producer::new(info, track, state.cache.clone()).with_meter(state.ingress.meter()); if start != 0 { group.bound(group::Bounds { start, end: None })?; @@ -4653,7 +4647,7 @@ impl Producer { group.handle().settle_head(adopted); } deferred.wake(); - Ok(Received::Group(group)) + Ok(Some(Received::Group(group))) } /// Create the next group, starting at `start`: after every group this track holds. @@ -5650,7 +5644,7 @@ impl Finished { /// Create an older group below the end, which arrived late; see [`Producer::create_group`]. /// /// A key at or past the end is refused with [`Error::Closed`]. - pub fn create_group(&self, group: group::Info) -> Result { + pub fn create_group(&self, group: group::Info) -> Result> { self.producer.create_group(group) } @@ -12590,7 +12584,7 @@ mod test { producer.drop_groups(15..25, StreamError::Cancel); indexed(); // Still arriving, so the next drop ends it and covers it again. - let _recreated = producer.create_group(group::Info { start: 17 }).unwrap(); + let _recreated = producer.create_group(group::Info { start: 17 }).unwrap().unwrap(); indexed(); producer.drop_groups(14..26, StreamError::Old); indexed(); @@ -12708,10 +12702,10 @@ mod test { let producer = track_producer("test", Info::default()); producer .create_group(group::Info { start: 0 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); - let open = producer.create_group(group::Info { start: 1 }).unwrap(); + let open = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); producer.drop_groups(0..2, StreamError::Cancel); let drops: Vec<_> = producer.state.read().drops.iter().map(|(run, _)| run.clone()).collect(); @@ -12731,7 +12725,7 @@ mod test { let consumer = producer.consume(); let mut lives = Vec::new(); for key in 0..2 { - let mut live = producer.create_group(group::Info { start: key }).unwrap(); + let mut live = producer.create_group(group::Info { start: key }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); @@ -12766,7 +12760,7 @@ mod test { async fn arriving_head(producer: &Producer) -> (group::Producer, group::Producer) { let dynamic = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); @@ -12882,7 +12876,7 @@ mod test { let waiter = kio::Waiter::noop(); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert!(feed.poll_group(0, &waiter).is_pending()); @@ -12977,14 +12971,14 @@ mod test { fn a_late_group_below_the_largest_changes_nothing() { let mut producer = track_producer("test", Info::default()); let noop = kio::Waiter::noop(); - let mut framed = producer.create_group(group::Info { start: 2 }).unwrap(); + let mut framed = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); framed .write_frame(crate::Timestamp::unscaled(framed.start), &b"a"[..]) .unwrap(); framed.finish().unwrap(); producer .create_group(group::Info { start: 5 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer.finish_at(Position::group(6)).unwrap(); @@ -12994,7 +12988,7 @@ mod test { assert_eq!(reader.poll_largest(&noop), Poll::Ready(None)); // Late content below the end is still admitted; it just isn't the largest. - let mut late = producer.create_group(group::Info { start: 4 }).unwrap(); + let mut late = producer.create_group(group::Info { start: 4 }).unwrap().unwrap(); late.write_frame(crate::Timestamp::unscaled(late.start), &b"b"[..]) .unwrap(); assert_eq!(reader.poll_largest(&noop), Poll::Ready(None)); @@ -13008,7 +13002,7 @@ mod test { fn a_recreated_largest_group_is_reported_before_the_end() { let mut producer = track_producer("test", Info::default()); let noop = kio::Waiter::noop(); - let mut first = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut first = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); first .write_frame(crate::Timestamp::unscaled(first.start), &b"a"[..]) .unwrap(); @@ -13022,7 +13016,7 @@ mod test { "the aborted group can be recreated" ); - let mut again = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut again = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); for payload in [&b"a"[..], b"b"] { again .write_frame(crate::Timestamp::unscaled(again.start), payload) @@ -13044,7 +13038,7 @@ mod test { let mut producer = track_producer("test", Info::timed()); let dynamic = producer.requests(); let noop = kio::Waiter::noop(); - let mut first = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut first = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); first.write_frame(first.key_time(), &b"a"[..]).unwrap(); first.abort(Error::Cancel).unwrap(); producer.finish_at(Position::group(1)).unwrap(); @@ -13173,7 +13167,7 @@ mod test { // An older report or frame does not move it back. producer.report_largest(Position { group: 7, frame: 1 }, false); - let mut _open = producer.create_group(group::Info { start: 2 }).unwrap(); + let mut _open = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); _open .write_frame(crate::Timestamp::unscaled(_open.start), &b"a"[..]) .unwrap(); @@ -13234,7 +13228,7 @@ mod test { /// Write group `key` with `frames` frames, left open. fn framed(producer: &Producer, key: u64, frames: usize) -> group::Producer { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); for _ in 0..frames { group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) @@ -13321,7 +13315,7 @@ mod test { assert!(reader.poll_drop(&waiter).is_pending()); producer.drop_groups(5..6, StreamError::Cancel); assert!(reader.poll_drop(&waiter).is_pending(), "outside the range"); - let _group = producer.create_group(group::Info { start: 3 }).unwrap(); + let _group = producer.create_group(group::Info { start: 3 }).unwrap().unwrap(); assert_eq!( reader.poll_drop(&waiter), Poll::Ready((5..6, Hole::drop(StreamError::Cancel))), @@ -13334,7 +13328,7 @@ mod test { #[test] fn a_group_missing_its_head_lags() { let producer = track_producer("test", Info::default()); - let mut headless = producer.create_group(group::Info { start: 4 }).unwrap(); + let mut headless = producer.create_group(group::Info { start: 4 }).unwrap().unwrap(); headless.start_at(2).unwrap(); for _ in 0..3 { headless @@ -13594,7 +13588,7 @@ mod test { /// Append the next 500 ms group, presenting at its start. fn append_half_second(producer: &mut Producer) -> u64 { let start = producer.state.read().latest_group.map_or(0, |latest| latest + 500); - let mut group = producer.create_group(group::Info { start }).unwrap(); + let mut group = producer.create_group(group::Info { start }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(start).unwrap(), &b"x"[..]) .unwrap(); @@ -13625,7 +13619,7 @@ mod test { // Measured from the newest frame, not the latest group's start. let producer = half_second_groups(); - let mut group = producer.create_group(group::Info { start: 5500 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 5500 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(5900).unwrap(), &b"x"[..]) .unwrap(); @@ -13746,7 +13740,7 @@ mod test { producer.received(); producer.starts_at_keys(); for key in 0..10 { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key * 500).unwrap(), &b"x"[..]) .unwrap(); @@ -13767,7 +13761,7 @@ mod test { producer.received(); producer.starts_at_keys(); let groups: Vec<_> = (0..10) - .map(|key| producer.create_group(group::Info { start: key }).unwrap()) + .map(|key| producer.create_group(group::Info { start: key }).unwrap().unwrap()) .collect(); let mut reader = producer.subscribe(joining(Range::live(), Duration::from_secs(2))); assert_eq!(ready_groups(&mut reader), Vec::::new(), "nothing to measure by"); @@ -13790,9 +13784,9 @@ mod test { for _ in (0..=2500).step_by(500) { append_half_second(&mut producer); } - let aborted = producer.create_group(group::Info { start: 3000 }).unwrap(); + let aborted = producer.create_group(group::Info { start: 3000 }).unwrap().unwrap(); aborted.abort(Error::Cancel).unwrap(); - let mut group = producer.create_group(group::Info { start: 3500 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 3500 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(3500).unwrap(), &b"x"[..]) .unwrap(); @@ -13810,7 +13804,7 @@ mod test { fn a_live_join_rounds_its_min_age_up_to_whole_ticks() { let producer = track_producer("test", Info::timed()); for start in 0..=2 { - let mut group = producer.create_group(group::Info { start }).unwrap(); + let mut group = producer.create_group(group::Info { start }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(start).unwrap(), &b"x"[..]) .unwrap(); @@ -13825,7 +13819,7 @@ mod test { #[test] fn a_live_join_measures_from_groups_still_held() { let producer = half_second_groups(); - let aborted = producer.create_group(group::Info { start: 10_000 }).unwrap(); + let aborted = producer.create_group(group::Info { start: 10_000 }).unwrap().unwrap(); aborted.abort(Error::Cancel).unwrap(); let mut reader = producer.subscribe(joining(Range::live(), Duration::from_secs(2))); assert_eq!(ready_groups(&mut reader)[0], 3000); @@ -13988,7 +13982,7 @@ mod test { }; for (object, ok) in [(50, false), (100, true)] { let mut producer = track_producer("test", None); - let mut group = producer.create_group(group::Info { start: 2 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); group.set_wire(wire.clone()).unwrap(); for id in [0, 100] { let mut frame = group @@ -14091,7 +14085,7 @@ mod test { async fn dropped_group_writer_aborts_and_releases_its_cached_copy() { let pool = cache::Pool::unbounded(); let producer = track_producer_pooled("test", pool.clone()); - let mut group = producer.create_group(group::Info { start: 3 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 3 }).unwrap().unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); @@ -14113,7 +14107,7 @@ mod test { #[kio::test] async fn dropped_group_writer_is_absent_and_its_key_can_be_recreated() { let producer = track_producer("test", Info::timed()); - let mut group = producer.create_group(group::Info { start: 3 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 3 }).unwrap().unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); @@ -14130,6 +14124,7 @@ mod test { )); let mut replacement = producer .create_group(group::Info { start: 3 }) + .unwrap() .expect("the dead copy is replaceable"); replacement .write_frame(replacement.key_time(), bytes::Bytes::from_static(b"head")) @@ -14146,7 +14141,7 @@ mod test { async fn dropped_group_writer_preserves_the_committed_resume_position() { let producer = track_producer("test", Info::timed()); let consumer = producer.consume(); - let mut group = producer.create_group(group::Info { start: 3 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 3 }).unwrap().unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); @@ -14219,7 +14214,7 @@ mod test { #[cfg(feature = "async")] async fn aging_out_a_finished_group_keeps_the_clean_end() { let producer = track_producer("test", Info::timed()); - let mut group = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut consumer = group.consume(); group @@ -14230,7 +14225,7 @@ mod test { // The group stays open well past the LRU window, then the next period starts. elapse(&producer, cache::DEFAULT_EXPIRY * 2); group.finish().unwrap(); - let _next = producer.create_group(group::Info { start: 1 }).unwrap(); + let _next = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); assert!(consumer.next_frame().await.unwrap().is_none()); } @@ -14245,7 +14240,7 @@ mod test { let mut subscriber = producer.subscribe(None); // A finished group with one frame per step of the read loop below. - let mut group = producer.create_group(0u64.into()).unwrap(); + let mut group = producer.create_group(0u64.into()).unwrap().unwrap(); for _ in 0..10 { group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); } @@ -14253,7 +14248,7 @@ mod test { let mut reading = subscriber.assert_group(); // A sibling written at the same time that nobody ever reads. - producer.create_group(1u64.into()).unwrap().finish().unwrap(); + producer.create_group(1u64.into()).unwrap().unwrap().finish().unwrap(); // Each step stays well inside the retention window, but the whole read // spans several windows. New groups keep the expiry scan running. @@ -14264,7 +14259,7 @@ mod test { matches!(frame, Ok(Some(_))), "an actively-read group must not expire mid-read (step {seq})" ); - producer.create_group(seq.into()).unwrap().finish().unwrap(); + producer.create_group(seq.into()).unwrap().unwrap().finish().unwrap(); } let state = producer.state.read(); @@ -14282,7 +14277,7 @@ mod test { let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(None); - let mut group = producer.create_group(0u64.into()).unwrap(); + let mut group = producer.create_group(0u64.into()).unwrap().unwrap(); for _ in 0..20 { group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); } @@ -14298,7 +14293,7 @@ mod test { matches!(frame, Ok(Some(_))), "a slow prefetch reader must not expire mid-read (step {seq})" ); - producer.create_group(seq.into()).unwrap().finish().unwrap(); + producer.create_group(seq.into()).unwrap().unwrap().finish().unwrap(); } } @@ -14311,11 +14306,11 @@ mod test { let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(replay()); - let mut group = producer.create_group(0u64.into()).unwrap(); + let mut group = producer.create_group(0u64.into()).unwrap().unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); group.finish().unwrap(); // A second group so seq 0 leaves the protected live edge. - producer.create_group(1u64.into()).unwrap().finish().unwrap(); + producer.create_group(1u64.into()).unwrap().unwrap().finish().unwrap(); // Deliver just inside the window: the delivery stamps the group. elapse(&producer, cache::DEFAULT_EXPIRY - Duration::from_secs(1)); @@ -14324,7 +14319,7 @@ mod test { // Almost another full window passes: far beyond the write, inside the // delivery stamp. The new group runs the expiry scan. elapse(&producer, cache::DEFAULT_EXPIRY - Duration::from_secs(1)); - producer.create_group(2u64.into()).unwrap().finish().unwrap(); + producer.create_group(2u64.into()).unwrap().unwrap().finish().unwrap(); let frame = reading.read_frame().await.unwrap(); assert!(frame.is_some(), "a just-delivered group must not expire unread"); @@ -14336,9 +14331,9 @@ mod test { #[test] fn streaming_frame_writes_keep_the_group_alive() { let producer = track_producer("test", Info::timed()); - let straggler = producer.create_group(0u64.into()).unwrap(); + let straggler = producer.create_group(0u64.into()).unwrap().unwrap(); // The live edge moves on, so the straggler is demoted and expirable. - producer.create_group(1u64.into()).unwrap().finish().unwrap(); + producer.create_group(1u64.into()).unwrap().unwrap().finish().unwrap(); let mut frame = straggler .create_frame(frame::Info { @@ -14351,7 +14346,7 @@ mod test { for seq in 2..12u64 { elapse(&producer, cache::DEFAULT_EXPIRY / 2); frame.write(bytes::Bytes::from_static(b"x")).unwrap(); - producer.create_group(seq.into()).unwrap().finish().unwrap(); + producer.create_group(seq.into()).unwrap().unwrap().finish().unwrap(); } let straggler = frame.finish().unwrap(); straggler.finish().unwrap(); @@ -14370,9 +14365,9 @@ mod test { #[test] fn coalesced_frame_completion_keeps_the_group_alive() { let producer = track_producer("test", Info::timed()); - let straggler = producer.create_group(0u64.into()).unwrap(); + let straggler = producer.create_group(0u64.into()).unwrap().unwrap(); // The live edge moves on, so the straggler is demoted and expirable. - producer.create_group(1u64.into()).unwrap().finish().unwrap(); + producer.create_group(1u64.into()).unwrap().unwrap().finish().unwrap(); let mut frame = straggler .create_frame(frame::Info { @@ -14390,7 +14385,7 @@ mod test { straggler.finish().unwrap(); // A new group runs the expiry scan. - producer.create_group(2u64.into()).unwrap().finish().unwrap(); + producer.create_group(2u64.into()).unwrap().unwrap().finish().unwrap(); let state = producer.state.read(); assert!( @@ -14409,7 +14404,7 @@ mod test { subscriber.set_range(..1); for seq in 0..2u64 { - let mut group = producer.create_group(seq.into()).unwrap(); + let mut group = producer.create_group(seq.into()).unwrap().unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); group.finish().unwrap(); } @@ -14427,7 +14422,7 @@ mod test { // Almost another full window passes: far beyond the write, inside the // re-offer stamp. The new group runs the expiry scan. elapse(&producer, cache::DEFAULT_EXPIRY - Duration::from_secs(1)); - producer.create_group(2u64.into()).unwrap().finish().unwrap(); + producer.create_group(2u64.into()).unwrap().unwrap().finish().unwrap(); let frame = reading.read_frame().await.unwrap(); assert!(frame.is_some(), "a just-re-offered group must not expire unread"); @@ -14464,7 +14459,7 @@ mod test { let waiter = kio::Waiter::noop(); producer .create_group(group::Info { start: high }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let Poll::Ready(Ok(Some(group))) = subscriber.poll_recv_group(&waiter) else { @@ -14477,7 +14472,7 @@ mod test { elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); // Below the reader's floor: never handed out. @@ -14908,7 +14903,7 @@ mod test { let woken = Arc::new(std::sync::atomic::AtomicBool::new(false)); let waiter = kio::Waiter::new(futures::task::waker(Arc::new(FlagWake(woken.clone())))); assert!(reading.poll_read_frame(&waiter).is_pending()); - let _successor = producer.create_group(group::Info { start: 1 }).unwrap(); + let _successor = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); assert!( woken.swap(false, Ordering::SeqCst), "{info:?}: the header never woke the read" @@ -15417,7 +15412,7 @@ mod test { producer.set_idle(); open.abort(Error::Cancel).unwrap(); - let mut answer = producer.create_group(group::Info { start: 2 }).unwrap(); + let mut answer = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); producer.set_live(Some(Position::group(2)), None).unwrap(); answer .write_frame(Timestamp::from_millis(533).unwrap(), bytes::Bytes::from_static(b"")) @@ -15709,7 +15704,7 @@ mod test { let waiter = kio::Waiter::noop(); assert!(subscriber.poll_drop(&waiter).is_pending(), "nothing was given up"); - let mut again = producer.create_group(group::Info { start: 1 }).unwrap(); + let mut again = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); producer.set_live(Some(Position::group(1)), None).unwrap(); again .write_frame(Timestamp::from_millis(1000).unwrap(), bytes::Bytes::from_static(b"x")) @@ -16158,7 +16153,7 @@ mod test { fn a_late_lower_group_within_the_budget_is_delivered() { let producer = track_producer("test", Info::timed()); for (key, millis) in [(5, 1000), (6, 2000), (7, 3000)] { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(millis).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -16172,7 +16167,7 @@ mod test { // Arriving below everything already delivered is not what makes content stale: // the budget is the only gate, and this straggler's timestamp is within it. A // consumer that needs key order reorders (or drops) it itself. - let mut late = producer.create_group(group::Info { start: 4 }).unwrap(); + let mut late = producer.create_group(group::Info { start: 4 }).unwrap().unwrap(); late.write_frame(Timestamp::from_millis(500).unwrap(), bytes::Bytes::from_static(b"late")) .unwrap(); late.finish().unwrap(); @@ -16856,7 +16851,7 @@ mod test { let mut next = std::pin::pin!(held.read_frame()); assert!(next.as_mut().poll(&mut cx).is_pending()); - let mut received = producer.create_group(group::Info { start: 2 }).unwrap(); + let mut received = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); woken.store(false, Ordering::SeqCst); assert!( next.as_mut().poll(&mut cx).is_pending(), @@ -16885,7 +16880,7 @@ mod test { producer.subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(60)))); producer.finish_at(Position::group(2)).unwrap(); let mut received: Vec<_> = (0..2) - .map(|key| producer.create_group(group::Info { start: key }).unwrap()) + .map(|key| producer.create_group(group::Info { start: key }).unwrap().unwrap()) .collect(); let mut first = subscriber.assert_group(); let mut second = subscriber.assert_group(); @@ -16920,7 +16915,7 @@ mod test { let waiter = kio::Waiter::new(futures::task::waker(Arc::new(FlagWake(woken.clone())))); assert!(producer.poll_past(0, &waiter).is_pending()); - let mut group = producer.create_group(group::Info { start: 1 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); woken.store(false, Ordering::SeqCst); assert!( producer.poll_past(0, &waiter).is_pending(), @@ -16943,7 +16938,7 @@ mod test { let mut subscriber = producer .subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(60)))); producer.finish_at(Position::group(1)).unwrap(); - let group = producer.create_group(group::Info { start: 0 }).unwrap(); + let group = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut reading = subscriber.assert_group(); assert_eq!(reading.start, 0); @@ -17595,7 +17590,7 @@ mod test { fn cold_fetch_expires_without_waiting_for_the_upstream_group() { let mut producer = track_producer("test", Info::timed()); let _dynamic = producer.requests(); - let mut successor = producer.create_group(group::Info { start: 1 }).unwrap(); + let mut successor = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); successor .write_frame(Timestamp::from_millis(1000).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -17654,7 +17649,7 @@ mod test { // Nothing below the floor is waited for, and a group above it reads at once. producer .create_group(group::Info { start: 3 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(subscriber.assert_group().start, 3); @@ -17828,7 +17823,7 @@ mod test { // A high timestamp on a lower key is not a live edge: a group whose frames run // past where its successor starts sits there. Only groups above the candidate // anchor the measure, so it cannot convict the group that follows it. - let mut straggler = producer.create_group(0u64.into()).unwrap(); + let mut straggler = producer.create_group(0u64.into()).unwrap().unwrap(); for millis in [0, 60_000] { straggler .write_frame(Timestamp::from_millis(millis).unwrap(), bytes::Bytes::from_static(b"x")) @@ -17836,7 +17831,7 @@ mod test { } straggler.finish().unwrap(); - let mut next = producer.create_group(1u64.into()).unwrap(); + let mut next = producer.create_group(1u64.into()).unwrap().unwrap(); next.write_frame(next.key_time(), bytes::Bytes::from_static(b"x")) .unwrap(); next.finish().unwrap(); @@ -17876,7 +17871,7 @@ mod test { let ranges = || Subscription::default().with_ranges([Range::groups(0..2), Range::groups(10..12)]); let producer = track_producer("test", Info::timed()); for (key, millis) in [(0, 0), (1, 1000), (8, 8000), (9, 9000)] { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(millis).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -17885,7 +17880,7 @@ mod test { // With no budget, the newest group the ranges cover is the edge. assert_eq!(drain(&mut producer.subscribe(ranges())), vec![9]); - let mut ten = producer.create_group(group::Info { start: 10 }).unwrap(); + let mut ten = producer.create_group(group::Info { start: 10 }).unwrap().unwrap(); ten.write_frame(Timestamp::from_millis(10_000).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); ten.finish().unwrap(); @@ -17902,18 +17897,18 @@ mod test { let budget = Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(15))); let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(budget.clone()); - let mut zero = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut zero = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); zero.write_frame(at(0), bytes::Bytes::from_static(b"x")).unwrap(); let mut held = subscriber.recv_group().await.unwrap().expect("group 0"); assert!(held.read_frame().await.unwrap().is_some()); // The run's own group 10 is held, so its time start names it. - let mut ten = producer.create_group(group::Info { start: 10 }).unwrap(); + let mut ten = producer.create_group(group::Info { start: 10 }).unwrap().unwrap(); ten.write_frame(at(10_000), bytes::Bytes::from_static(b"x")).unwrap(); ten.finish().unwrap(); subscriber.update(budget.with_range(10..20)).unwrap(); for (key, millis) in [(1, 1000), (19, 19_000)] { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(at(millis), bytes::Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); } @@ -18049,7 +18044,7 @@ mod test { let (producer, groups) = (&producers[track], &mut groups[track]); match next(6) { 0 | 1 => { - if let Ok(mut group) = producer.create_group(group::Info { start: key }) { + if let Ok(Some(mut group)) = producer.create_group(group::Info { start: key }) { if next(3) > 0 { group .write_frame(at(key * 10), bytes::Bytes::from_static(b"x")) @@ -18120,7 +18115,7 @@ mod test { fn the_live_index_shrinks_with_the_cache() { let producer = track_producer("test", Info::timed()); let groups: Vec<_> = (0..100) - .map(|key| producer.create_group(group::Info { start: key }).unwrap()) + .map(|key| producer.create_group(group::Info { start: key }).unwrap().unwrap()) .collect(); let runs = Cover::new([0..=999, 1001..=u64::MAX]); let servable = Servable::covering(runs, None, &Arc::default()); @@ -18239,18 +18234,18 @@ mod test { let budget = Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(15))); let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(budget.clone()); - let mut zero = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut zero = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); zero.write_frame(at(0), bytes::Bytes::from_static(b"x")).unwrap(); let mut held = subscriber.recv_group().await.unwrap().expect("group 0"); assert!(held.read_frame().await.unwrap().is_some()); // The run's own group 10 is held, so its time start names it. - let mut ten = producer.create_group(group::Info { start: 10 }).unwrap(); + let mut ten = producer.create_group(group::Info { start: 10 }).unwrap().unwrap(); ten.write_frame(at(10_000), bytes::Bytes::from_static(b"x")).unwrap(); ten.finish().unwrap(); subscriber.control().update(budget.with_range(10..20)).unwrap(); for (key, millis) in [(1, 1000), (19, 19_000)] { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group.write_frame(at(millis), bytes::Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); } @@ -18410,9 +18405,9 @@ mod test { let producer = track_producer("test", Info::timed()); // Arrive out of order: seq 5 first, then 3, then 4. - let _open = producer.create_group(group::Info { start: 5 }).unwrap(); - let _open = producer.create_group(group::Info { start: 3 }).unwrap(); - let _open = producer.create_group(group::Info { start: 4 }).unwrap(); + let _open = producer.create_group(group::Info { start: 5 }).unwrap().unwrap(); + let _open = producer.create_group(group::Info { start: 3 }).unwrap().unwrap(); + let _open = producer.create_group(group::Info { start: 4 }).unwrap().unwrap(); // max_key = 5, which is at the front of the VecDeque. { @@ -18446,7 +18441,7 @@ mod test { // Arrive: seq 5, then seq 3. producer .create_group(group::Info { start: 5 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -18455,7 +18450,7 @@ mod test { // Seq 3 arrives late; max_key is still 5 (at front). producer .create_group(group::Info { start: 3 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -18473,7 +18468,7 @@ mod test { // Seq 2 arrives late, triggering eviction. producer .create_group(group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -18611,7 +18606,7 @@ mod test { let producer = track_producer("test", Info::timed()); let dynamic = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); @@ -18710,12 +18705,12 @@ mod test { let mut producer = track_producer("test", Info::timed()); producer .create_group(group::Info { start: 0 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer.finish_at(Position::group(4)).unwrap(); @@ -18806,7 +18801,7 @@ mod test { let mut ordered = producer.subscribe(replay()).ordered(); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let finished = producer.finish().unwrap(); @@ -18815,7 +18810,7 @@ mod test { Err(Error::Closed) )); - let mut late = finished.create_group(group::Info { start: 0 }).unwrap(); + let mut late = finished.create_group(group::Info { start: 0 }).unwrap().unwrap(); late.write_frame(late.key_time(), &b"late"[..]).unwrap(); let late = late.finish().unwrap(); assert_eq!(late.frame_count(), 1); @@ -18831,7 +18826,7 @@ mod test { #[test] fn finish_at_rejects_a_boundary_at_or_below_the_live_edge() { let mut producer = track_producer("test", Info::timed()); - let _open = producer.create_group(group::Info { start: 5 }).unwrap(); + let _open = producer.create_group(group::Info { start: 5 }).unwrap().unwrap(); // The boundary is exclusive, so it must be strictly above the highest produced // group. 5 or below would orphan groups that already exist. @@ -18845,7 +18840,7 @@ mod test { // boundary can be created. assert!(producer.finish_at(Position::group(6)).is_ok()); assert!(producer.finish_at(Position::group(7)).is_err()); - assert!(producer.create_group(group::Info { start: 4 }).is_ok()); + assert!(producer.create_group(group::Info { start: 4 }).unwrap().is_some()); assert!(producer.create_group(group::Info { start: 6 }).is_err()); } @@ -18855,7 +18850,7 @@ mod test { let mut producer = track_producer_pooled("test", pool.clone()); let end = Position { group: 5, frame: 5 }; producer.finish_at(end).unwrap(); - let mut group = producer.create_group(group::Info { start: 5 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 5 }).unwrap().unwrap(); for _ in 0..5 { group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); } @@ -18893,7 +18888,7 @@ mod test { #[test] fn a_mid_group_end_refuses_to_cut_existing_frames() { let mut producer = track_producer("test", Info::timed()); - let mut group = producer.create_group(group::Info { start: 5 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 5 }).unwrap().unwrap(); for _ in 0..6 { group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); } @@ -18914,7 +18909,7 @@ mod test { if early { producer.finish_at(end).unwrap(); } - let mut group = producer.create_group(group::Info { start: 5 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 5 }).unwrap().unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); if !early { producer.finish_at(end).unwrap(); @@ -18949,7 +18944,7 @@ mod test { let mut producer = track_producer("test", Info::timed()); assert_eq!(producer.finished(), None); - let _open = producer.create_group(group::Info { start: 5 }).unwrap(); + let _open = producer.create_group(group::Info { start: 5 }).unwrap().unwrap(); assert_eq!(producer.finished(), None, "a group does not declare an end"); producer.finish_at(Position::group(9)).unwrap(); @@ -18962,7 +18957,7 @@ mod test { #[test] fn end_reports_the_live_edge_after_finish() { let producer = track_producer("test", Info::timed()); - let _open = producer.create_group(group::Info { start: 5 }).unwrap(); + let _open = producer.create_group(group::Info { start: 5 }).unwrap().unwrap(); producer.finish_shared().unwrap(); assert_eq!(producer.finished(), Some(Position::group(6))); } @@ -18973,7 +18968,7 @@ mod test { let mut producer = track_producer("test", Info::timed()); producer .create_group(group::Info { start: 5 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -18999,7 +18994,7 @@ mod test { // The trailing group arrives (below the boundary), then the track completes. producer .create_group(group::Info { start: 6 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(consumer.assert_group().start, 6); @@ -19021,7 +19016,7 @@ mod test { for key in 0..2 { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -19150,7 +19145,7 @@ mod test { let mut arrival = producer.subscribe(None); let mut ordered = producer.subscribe(None).ordered(); producer.finish_at(Position::group(3)).unwrap(); - let _open = producer.create_group(group::Info { start: 2 }).unwrap(); + let _open = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); // Missing lower groups do not hold either reader for the wire's grace. // The last group's own stream remains open independently of the track end. @@ -19193,15 +19188,15 @@ mod test { // The wire declares where the feed starts. producer.start_at(0).unwrap(); producer.finish_at(Position::group(3)).unwrap(); - let _high = producer.create_group(group::Info { start: 2 }).unwrap(); + let _high = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); assert_eq!(arrival.assert_group().start, 2); assert!(arrival.recv_group().now_or_never().is_none(), "held at the hole"); // The late lower groups are delivered, then the full tail ends the reader. - let _low = producer.create_group(group::Info { start: 0 }).unwrap(); + let _low = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); assert_eq!(arrival.assert_group().start, 0); assert!(arrival.recv_group().now_or_never().is_none(), "group 1 is still owed"); - let _mid = producer.create_group(group::Info { start: 1 }).unwrap(); + let _mid = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); assert_eq!(arrival.assert_group().start, 1); assert!(arrival.recv_group().now_or_never().unwrap().unwrap().is_none()); @@ -19211,7 +19206,7 @@ mod test { let mut arrival = producer.subscribe(replay()); producer.start_at(0).unwrap(); producer.finish_at(Position::group(2)).unwrap(); - let _high = producer.create_group(group::Info { start: 1 }).unwrap(); + let _high = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); assert_eq!(arrival.assert_group().start, 1); assert!(arrival.recv_group().now_or_never().is_none()); // The subscription's max delay is the grace. @@ -19224,7 +19219,7 @@ mod test { let mut arrival = producer.subscribe(replay()); producer.start_at(0).unwrap(); producer.finish_at(Position::group(2)).unwrap(); - let _high = producer.create_group(group::Info { start: 1 }).unwrap(); + let _high = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); assert_eq!(arrival.assert_group().start, 1); drop(producer); assert!(arrival.recv_group().now_or_never().unwrap().unwrap().is_none()); @@ -19246,7 +19241,7 @@ mod test { producer.start_at(0).unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 1); @@ -19297,7 +19292,7 @@ mod test { producer.finish_at(Position::group(2)).unwrap(); producer .create_group(group::Info { start: arrived }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, arrived); @@ -19310,7 +19305,7 @@ mod test { producer .create_group(group::Info { start: missing }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, missing); @@ -19333,7 +19328,7 @@ mod test { elapse(&producer, grace / 2); producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, key); @@ -19373,7 +19368,7 @@ mod test { producer.finish_at(Position::group(2)).unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 1); @@ -19391,7 +19386,7 @@ mod test { producer.finish_at(Position::group(3)).unwrap(); producer .create_group(group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 2); @@ -19420,7 +19415,7 @@ mod test { let mut arrival = producer.subscribe(replay()); producer .create_group(group::Info { start: 0 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 0); @@ -19435,7 +19430,7 @@ mod test { let mut arrival = producer.subscribe(replay()); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 1); @@ -19457,7 +19452,7 @@ mod test { let mut arrival = producer.subscribe(None); producer.start_at(0).unwrap(); producer.finish_at(Position::group(2)).unwrap(); - let _high = producer.create_group(group::Info { start: 1 }).unwrap(); + let _high = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); assert_eq!(arrival.assert_group().start, 1); let _pending = consumer.fetch_group(0, None); @@ -19479,7 +19474,7 @@ mod test { let mut arrival = producer.subscribe(None); producer.start_at(0).unwrap(); producer.finish_at(Position::group(2)).unwrap(); - let high = producer.create_group(group::Info { start: 1 }).unwrap(); + let high = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); high.finish().unwrap(); assert_eq!(arrival.assert_group().start, 1); assert!(arrival.recv_group().now_or_never().is_none(), "held at the hole"); @@ -19504,7 +19499,7 @@ mod test { for key in [1, 0] { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -19528,7 +19523,7 @@ mod test { for key in [0, 2] { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, key); @@ -19555,7 +19550,7 @@ mod test { for key in [0, 1] { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, key); @@ -19563,7 +19558,7 @@ mod test { elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); producer .create_group(group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert!(!producer.state.read().lookup.contains_key(&0), "group 0 was evicted"); @@ -19581,7 +19576,7 @@ mod test { producer.received(); let mut arrival = producer.subscribe(replay()); producer.start_at(0).unwrap(); - let _high = producer.create_group(group::Info { start: 2 }).unwrap(); + let _high = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); assert_eq!(arrival.assert_group().start, 2); assert!(arrival.recv_group().now_or_never().is_none()); @@ -19595,7 +19590,7 @@ mod test { let mut _low = Vec::new(); for key in [0, 1] { - _low.push(producer.create_group(group::Info { start: key }).unwrap()); + _low.push(producer.create_group(group::Info { start: key }).unwrap().unwrap()); assert_eq!(arrival.assert_group().start, key); } assert!(arrival.recv_group().now_or_never().unwrap().unwrap().is_none()); @@ -19609,9 +19604,9 @@ mod test { let mut producer = track_producer("test", Info::timed()); let mut consumer = producer.subscribe(replay()); - let head = producer.create_group(group::Info { start: 0 }).unwrap(); + let head = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); head.finish().unwrap(); - let _tail = producer.create_group(group::Info { start: 1 }).unwrap(); + let _tail = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); producer.finish_at(Position::group(2)).unwrap(); assert_eq!(consumer.assert_group().start, 0); @@ -19711,7 +19706,7 @@ mod test { for key in [0, 2] { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -19736,13 +19731,13 @@ mod test { let demand = producer.demand(); producer .create_group(group::Info { start: 5 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer.finish_at(Position::group(6)).unwrap(); assert!(matches!(producer.poll_closed(&waiter), Poll::Ready(Ok(())))); - let _late = producer.create_group(group::Info { start: 4 }).unwrap(); + let _late = producer.create_group(group::Info { start: 4 }).unwrap().unwrap(); assert!(matches!(producer.poll_closed(&waiter), Poll::Ready(Ok(())))); producer.clone().abort(Error::Cancel).unwrap(); assert!(matches!(producer.poll_closed(&waiter), Poll::Ready(Ok(())))); @@ -19777,11 +19772,11 @@ mod test { for key in 0..2 { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } - let _open = producer.create_group(group::Info { start: 2 }).unwrap(); + let _open = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); producer.abort(Error::Timeout).unwrap(); assert_eq!(arrival.assert_group().start, 0); @@ -19806,7 +19801,7 @@ mod test { let mut consumer = producer.subscribe(None); producer .create_group(group::Info { start: 0 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); drop(producer); @@ -19893,7 +19888,7 @@ mod test { let mut consumer = producer.subscribe(replay()); for key in 0..2 { - let group = producer.create_group(group::Info { start: key }).unwrap(); + let group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group.finish().unwrap(); } producer.finish_at(Position::group(2)).unwrap(); @@ -19914,7 +19909,7 @@ mod test { let mut consumer = producer.subscribe(replay()).ordered(); for key in 0..2 { - let group = producer.create_group(group::Info { start: key }).unwrap(); + let group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group.finish().unwrap(); } producer.finish_at(Position::group(2)).unwrap(); @@ -19940,7 +19935,7 @@ mod test { for key in 0..2 { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -19964,7 +19959,7 @@ mod test { for key in [0, 2] { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -19990,7 +19985,7 @@ mod test { let producer = track_producer("test", Info::timed()); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let producer = producer.finish().unwrap(); @@ -20596,7 +20591,7 @@ mod test { /// Create and finish group `key`, with one frame at `millis` on a timed track. #[cfg(feature = "async")] fn put(producer: &Producer, key: u64, millis: Option) { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); if let Some(millis) = millis { group .write_frame(Timestamp::from_millis(millis).unwrap(), &b"x"[..]) @@ -20676,7 +20671,7 @@ mod test { put(&producer, 5, Some(5000)); assert_eq!(drain_ordered(&mut consumer), [5]); - let mut later = producer.create_group(group::Info { start: 7 }).unwrap(); + let mut later = producer.create_group(group::Info { start: 7 }).unwrap().unwrap(); later .write_frame(Timestamp::from_millis(7000).unwrap(), &b"start"[..]) .unwrap(); @@ -20707,7 +20702,7 @@ mod test { .ordered(); put(&producer, 0, Some(0)); assert_eq!(drain_ordered(&mut consumer), [0]); - let mut edge = producer.create_group(group::Info { start: 4 }).unwrap(); + let mut edge = producer.create_group(group::Info { start: 4 }).unwrap().unwrap(); edge.write_frame(Timestamp::from_millis(4000).unwrap(), &b"edge"[..]) .unwrap(); @@ -20732,7 +20727,7 @@ mod test { .ordered(); put(&producer, 0, None); assert_eq!(drain_ordered(&mut consumer), [0]); - let opener = producer.create_group(group::Info { start: 2 }).unwrap(); + let opener = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); elapse(&producer, Duration::from_millis(40)); put(&producer, 3, None); opener.abort(Error::Cancel).unwrap(); @@ -20763,7 +20758,7 @@ mod test { put(&producer, 4, None); assert_eq!(drain_ordered(&mut consumer), [4], "groups 1 to 3 were dropped"); - let aborted = producer.create_group(group::Info { start: 5 }).unwrap(); + let aborted = producer.create_group(group::Info { start: 5 }).unwrap().unwrap(); aborted.abort(Error::Cancel).unwrap(); producer.modify().unwrap().reclaim_aborted(5); assert!(!producer.state.read().lookup.contains_key(&5), "the slot was reclaimed"); @@ -20814,7 +20809,7 @@ mod test { ); // A group handed out and then cut is read as the failure it is, never reported twice. - let cut = producer.create_group(group::Info { start: 7 }).unwrap(); + let cut = producer.create_group(group::Info { start: 7 }).unwrap().unwrap(); let Poll::Ready(Ok(Some(Item::Group(read)))) = ordered.poll_next_item(&kio::Waiter::noop()) else { panic!("group 7 is ready") }; @@ -21165,7 +21160,7 @@ mod test { // Seq 5 arrives first. producer .create_group(group::Info { start: 5 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let group = consumer @@ -21179,19 +21174,19 @@ mod test { // Seq 3 arrives late, skipped because 3 <= 5. producer .create_group(group::Info { start: 3 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); // Seq 4 arrives late and is also skipped. producer .create_group(group::Info { start: 4 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); // Seq 7 arrives and is returned, after the groups it passed are reported. producer .create_group(group::Info { start: 7 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -21207,12 +21202,12 @@ mod test { // Seq 3 arrives first, then seq 5. Both should be returned in arrival order. producer .create_group(group::Info { start: 3 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 5 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -21247,7 +21242,7 @@ mod test { for key in [u64::MAX - 2, u64::MAX - 1] { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -21296,7 +21291,7 @@ mod test { for key in [1, 2] { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -21329,7 +21324,7 @@ mod test { for key in [1, 3] { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -21354,7 +21349,7 @@ mod test { for key in [1, 2] { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -21379,7 +21374,7 @@ mod test { for key in [2, 1] { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -21410,12 +21405,12 @@ mod test { // Out-of-order arrivals: seq 5 first, then seq 3. producer .create_group(group::Info { start: 5 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 3 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -21442,7 +21437,7 @@ mod test { for s in 0..6 { producer .create_group(group::Info { start: s }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -21470,7 +21465,7 @@ mod test { for s in 0..6 { producer .create_group(group::Info { start: s }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -21502,7 +21497,7 @@ mod test { for s in 0..3 { producer .create_group(group::Info { start: s }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -21516,12 +21511,12 @@ mod test { consumer.set_range(..2); producer .create_group(group::Info { start: 3 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 4 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert!( @@ -21546,28 +21541,28 @@ mod test { // Out-of-order arrivals all within the cap. producer .create_group(group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 5 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 3 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); // One beyond the cap; should be held even though it arrived in the middle. producer .create_group(group::Info { start: 8 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 4 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -21596,7 +21591,7 @@ mod test { for s in 0..3 { producer .create_group(group::Info { start: s }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -21610,7 +21605,7 @@ mod test { assert_eq!(consumer.recv_group().now_or_never().unwrap().unwrap().unwrap().start, 2); consumer.set_range(..3); - let _open = producer.create_group(group::Info { start: 3 }).unwrap(); + let _open = producer.create_group(group::Info { start: 3 }).unwrap().unwrap(); assert!(consumer.recv_group().now_or_never().is_none(), "capped at 3"); let _producer = producer.finish().unwrap(); assert!( @@ -21632,17 +21627,17 @@ mod test { // Reordered burst: the beyond-cap group arrives first. producer .create_group(group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 0 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -21662,31 +21657,31 @@ mod test { consumer.set_range(2..=2); producer .create_group(group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(consumer.recv_group().await.unwrap().unwrap().start, 2); consumer.set_range(..4); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 3 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(consumer.recv_group().await.unwrap().unwrap().start, 3); consumer.set_range(0..=4); producer .create_group(group::Info { start: 0 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 4 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(consumer.recv_group().await.unwrap().unwrap().start, 4); @@ -21703,7 +21698,7 @@ mod test { consumer.set_range(..1); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert!( @@ -21714,7 +21709,7 @@ mod test { consumer.set_range(2..); producer .create_group(group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!( @@ -21735,13 +21730,13 @@ mod test { producer .create_group(group::Info { start: 0 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(consumer.recv_group().now_or_never().unwrap().unwrap().unwrap().start, 0); consumer.set_range(..1); - let straggler = producer.create_group(group::Info { start: 1 }).unwrap(); + let straggler = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); assert!( consumer.recv_group().now_or_never().is_none(), "group 1 parked at the cap" @@ -21766,12 +21761,12 @@ mod test { let mut consumer = producer.subscribe(replay()); producer .create_group(group::Info { start: 0 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -21799,7 +21794,7 @@ mod test { for s in 0..3 { producer .create_group(group::Info { start: s }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -21832,7 +21827,7 @@ mod test { consumer.set_range((Bound::Unbounded, Bound::Included(end.group))); for s in 0..3u64 { - let mut group = producer.create_group(group::Info { start: s }).unwrap(); + let mut group = producer.create_group(group::Info { start: s }).unwrap().unwrap(); for i in 0..3u8 { group.write_frame(group.key_time(), vec![i]).unwrap(); } @@ -21876,7 +21871,7 @@ mod test { )); producer .create_group(group::Info { start: u64::MAX - 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert!(matches!(producer.append_next(), Err(Error::BoundsExceeded(_)))); @@ -22255,7 +22250,7 @@ mod test { let producer = track_producer("test", Info::timed()); let dynamic = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(200).unwrap(); live.write_frame(live.key_time(), b"live".as_slice()).unwrap(); for start in (1..100).rev() { @@ -22297,7 +22292,7 @@ mod test { let producer = track_producer("test", Info::timed()); let dynamic = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(200).unwrap(); live.write_frame(live.key_time(), b"live".as_slice()).unwrap(); let range = |start, end| FetchOptions { @@ -22332,7 +22327,7 @@ mod test { let producer = track_producer("test", Info::timed()); let dynamic = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(200).unwrap(); live.write_frame(live.key_time(), b"live".as_slice()).unwrap(); let fill = async |start: u64, end: Option| { @@ -22396,7 +22391,7 @@ mod test { }; let mut lives = Vec::new(); for key in 0..2 { - let mut live = producer.create_group(group::Info { start: key }).unwrap(); + let mut live = producer.create_group(group::Info { start: key }).unwrap().unwrap(); live.start_at(200).unwrap(); live.write_frame(live.key_time(), b"live".as_slice()).unwrap(); lives.push(live); @@ -22478,7 +22473,7 @@ mod test { // can find it settled. producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); producer.finish_at(Position::group(2)).unwrap(); @@ -22523,7 +22518,7 @@ mod test { let mut arrival = producer.subscribe(replay()); let mut ordered = producer.subscribe(replay()).ordered(); for (key, err) in [(0, Error::App(5)), (1, Error::Cancel)] { - let mut live = producer.create_group(group::Info { start: key }).unwrap(); + let mut live = producer.create_group(group::Info { start: key }).unwrap().unwrap(); live.start_at(200).unwrap(); live.write_frame(live.key_time(), b"live".as_slice()).unwrap(); bounded(key).await; @@ -22675,7 +22670,7 @@ mod test { let consumer = producer.consume(); // The live subscription resumed mid-group, so only the tail is cached. - let mut group = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.start_at(3).unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from_static(b"tail")) @@ -22729,7 +22724,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); @@ -22774,7 +22769,7 @@ mod test { let producer = track_producer("test", Info::timed()); let dynamic = producer.requests(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); @@ -22813,12 +22808,12 @@ mod test { let producer = track_producer("test", Info::timed()); let dynamic = producer.requests(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); live.finish().unwrap(); - let mut newer = producer.create_group(group::Info { start: 1 }).unwrap(); + let mut newer = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); newer .write_frame(Timestamp::from_secs(1).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -22852,7 +22847,7 @@ mod test { let producer = track_producer("test", Info::timed()); let dynamic = producer.requests(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); @@ -22863,7 +22858,7 @@ mod test { let request = dynamic.requested_fill_group().now_or_never().unwrap().unwrap(); assert_eq!(request.key(), 0); - let mut newer = producer.create_group(group::Info { start: 1 }).unwrap(); + let mut newer = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); newer .write_frame(Timestamp::from_millis(1).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -22894,7 +22889,7 @@ mod test { let producer = track_producer("test", None); let dynamic = producer.requests(); for key in 0..2 { - let mut live = producer.create_group(group::Info { start: key }).unwrap(); + let mut live = producer.create_group(group::Info { start: key }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame( crate::Timestamp::unscaled(live.start), @@ -22944,7 +22939,7 @@ mod test { let producer = track_producer("test", None); let dynamic = producer.requests(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame( crate::Timestamp::unscaled(live.start), @@ -22982,7 +22977,7 @@ mod test { let producer = track_producer("test", None); let dynamic = producer.requests(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame( crate::Timestamp::unscaled(live.start), @@ -23020,7 +23015,7 @@ mod test { let consumer = producer.consume(); // The live copy holds frames 0 and 1, the fetched head frames 0 to 2. - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), b"delta".as_slice()).unwrap(); let fetch = consumer.fetch_group(0, None); @@ -23055,7 +23050,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); @@ -23080,7 +23075,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - let mut group = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.start_at(1).unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from_static(b"delta")) @@ -23217,7 +23212,7 @@ mod test { // The feed delivered group 1 and never group 0, which a fetch asks of the source. producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); @@ -23272,7 +23267,7 @@ mod test { let mut reader = consumer.clone(); let noop = kio::Waiter::noop(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); @@ -23332,7 +23327,7 @@ mod test { live.abort(Error::Cancel).unwrap(); // The next group demotes 0 into the eviction order and runs an expiry scan. - let _open = producer.create_group(group::Info { start: 1 }).unwrap(); + let _open = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); let mut group = producer.consume().peek_group(0).expect("the head still serves group 0"); assert_eq!( @@ -23363,12 +23358,12 @@ mod test { let producer = track_producer("test", Info::timed()); let (live, _head) = live_group_with_head(&producer).await; live.finish().unwrap(); - let _open = producer.create_group(group::Info { start: 1 }).unwrap(); + let _open = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); // A fetch hit on the head, past the window the live copy was last written in. producer.consume().fetch_group(0, None).await.unwrap(); - let _open = producer.create_group(group::Info { start: 2 }).unwrap(); + let _open = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); assert!(producer.consume().peek_group(0).is_some(), "a read head keeps its slot"); } @@ -23382,7 +23377,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); @@ -23403,7 +23398,7 @@ mod test { live.abort(Error::Cancel).unwrap(); } - let mut next = producer.create_group(group::Info { start: 1 }).unwrap(); + let mut next = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); for _ in 0..30 { next.write_frame(next.key_time(), bytes::Bytes::from(vec![0u8; 10_000])) .unwrap(); @@ -23962,10 +23957,10 @@ mod test { #[test] fn recreated_key_bounds_eviction_hints() { let (producer, _pool) = pooled_producer(1 << 40); - producer.create_group(5u64.into()).unwrap().finish().unwrap(); + producer.create_group(5u64.into()).unwrap().unwrap().finish().unwrap(); for _ in 0..200 { - let group = producer.create_group(1u64.into()).unwrap(); + let group = producer.create_group(1u64.into()).unwrap().unwrap(); group.abort(Error::Cancel).unwrap(); } @@ -24191,7 +24186,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - producer.create_group(10u64.into()).unwrap().finish().unwrap(); + producer.create_group(10u64.into()).unwrap().unwrap().finish().unwrap(); for key in 1..=5u64 { let pending = consumer.fetch_group(key, None); let req = dynamic @@ -24228,11 +24223,11 @@ mod test { fn recreated_key_delivered_once() { let (producer, _pool) = pooled_producer(1 << 40); - producer.create_group(0u64.into()).unwrap().finish().unwrap(); - let aborted = producer.create_group(1u64.into()).unwrap(); + producer.create_group(0u64.into()).unwrap().unwrap().finish().unwrap(); + let aborted = producer.create_group(1u64.into()).unwrap().unwrap(); aborted.abort(Error::Cancel).unwrap(); - producer.create_group(2u64.into()).unwrap().finish().unwrap(); - producer.create_group(1u64.into()).unwrap().finish().unwrap(); + producer.create_group(2u64.into()).unwrap().unwrap().finish().unwrap(); + producer.create_group(1u64.into()).unwrap().unwrap().finish().unwrap(); let mut subscriber = producer.subscribe(replay()); assert_eq!(subscriber.assert_group().start, 0); @@ -24311,10 +24306,10 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - producer.create_group(0u64.into()).unwrap().finish().unwrap(); - let aborted = producer.create_group(1u64.into()).unwrap(); + producer.create_group(0u64.into()).unwrap().unwrap().finish().unwrap(); + let aborted = producer.create_group(1u64.into()).unwrap().unwrap(); aborted.abort(Error::Cancel).unwrap(); - producer.create_group(2u64.into()).unwrap().finish().unwrap(); + producer.create_group(2u64.into()).unwrap().unwrap().finish().unwrap(); // Re-serve seq 1 as backfill; its slot replaces the aborted one, and the // old arrival entry for seq 1 now resolves to it. @@ -24362,7 +24357,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - producer.create_group(5u64.into()).unwrap().finish().unwrap(); + producer.create_group(5u64.into()).unwrap().unwrap().finish().unwrap(); for key in [2u64, 3u64] { let pending = consumer.fetch_group(key, None); let req = dynamic @@ -24382,7 +24377,7 @@ mod test { elapse(&producer, cache::DEFAULT_EXPIRY / 2 + Duration::from_secs(1)); consumer.fetch_group(2, None).await.unwrap(); elapse(&producer, cache::DEFAULT_EXPIRY / 2 + Duration::from_secs(1)); - producer.create_group(6u64.into()).unwrap().finish().unwrap(); + producer.create_group(6u64.into()).unwrap().unwrap().finish().unwrap(); let consumer = producer.consume(); assert!(consumer.peek_group(2).is_some(), "refreshed backfill survives"); @@ -24501,16 +24496,13 @@ mod test { let producer = track_producer("test", Info::timed()); let consumer = producer.consume(); - let mut group = producer.create_group(group::Info { start: 3 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 3 }).unwrap().unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); // While it lives the slot answers, so the key is taken. - assert!(matches!( - producer.create_group(group::Info { start: 3 }), - Err(Error::Duplicate) - )); + assert!(matches!(producer.create_group(group::Info { start: 3 }), Ok(None))); assert!(consumer.peek_group(3).is_some()); group.abort(Error::Cancel).unwrap(); @@ -24518,6 +24510,7 @@ mod test { assert!(consumer.peek_group(3).is_none(), "an aborted slot is a cache miss"); producer .create_group(group::Info { start: 3 }) + .unwrap() .expect("an aborted slot releases its key") .finish() .unwrap(); @@ -24532,7 +24525,7 @@ mod test { let (producer, _pool) = pooled_producer(1 << 40); let dynamic = producer.requests(); let consumer = producer.consume(); - producer.create_group(5u64.into()).unwrap().finish().unwrap(); + producer.create_group(5u64.into()).unwrap().unwrap().finish().unwrap(); let mut subscriber = producer.subscribe(replay().with_range(5..)); assert_eq!(subscriber.assert_group().start, 5); @@ -24548,7 +24541,7 @@ mod test { .unwrap(); fetched.finish().unwrap(); pending.await.unwrap(); - let _frameless = producer.create_group(group::Info { start: 3 }).unwrap(); + let _frameless = producer.create_group(group::Info { start: 3 }).unwrap().unwrap(); subscriber.update(replay().with_range(0..)).unwrap(); assert_eq!(subscriber.assert_group().start, 3, "offered before its first frame"); @@ -24580,8 +24573,8 @@ mod test { let consumer = producer.consume(); // The publisher starts at seq 5; earlier groups exist only upstream. - producer.create_group(5u64.into()).unwrap().finish().unwrap(); - producer.create_group(6u64.into()).unwrap().finish().unwrap(); + producer.create_group(5u64.into()).unwrap().unwrap().finish().unwrap(); + producer.create_group(6u64.into()).unwrap().unwrap().finish().unwrap(); // Fetch the gap: it lands in the cache and resolves the fetch... let pending = consumer.fetch_group(2, None); @@ -24669,7 +24662,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - producer.create_group(5u64.into()).unwrap().finish().unwrap(); + producer.create_group(5u64.into()).unwrap().unwrap().finish().unwrap(); // Serve a backfill fetch for an old key. let pending = consumer.fetch_group(2, None); @@ -24688,7 +24681,7 @@ mod test { // Age past the pool's LRU window; the next write reclaims the backfill. elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); - producer.create_group(6u64.into()).unwrap().finish().unwrap(); + producer.create_group(6u64.into()).unwrap().unwrap().finish().unwrap(); assert!(consumer.peek_group(2).is_none(), "expired backfill is reclaimed"); assert!(pool.used() < used, "its bytes are released"); @@ -25322,7 +25315,7 @@ mod test { #[cfg(feature = "async")] fn no_fill_below_a_start_resolved_from_the_budget() { let write = |producer: &Producer, key| { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); @@ -26422,7 +26415,7 @@ mod test { taken }; for key in 0..GROUPS { - write(producer.create_group(group::Info { start: key }).map(Some), key); + write(producer.create_group(group::Info { start: key }), key); if key % 4 < pace { take(&mut subscriber); } @@ -26491,7 +26484,7 @@ mod test { group.finish().unwrap(); }; producer.start_at(GROUPS).unwrap(); - write(producer.create_group(group::Info { start: GROUPS }).map(Some), GROUPS); + write(producer.create_group(group::Info { start: GROUPS }), GROUPS); let waiter = kio::Waiter::noop(); assert!(subscriber.poll_next_group(&waiter).is_pending(), "group 0 is a miss"); let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_groups(&waiter) else { @@ -27121,7 +27114,7 @@ mod test { /// Write a finished one-frame group, presented at its key in milliseconds. fn write_group(producer: &Producer, key: u64) { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); @@ -27143,7 +27136,7 @@ mod test { let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(replay()); write_group(&producer, 0); - let open = producer.create_group(group::Info { start: 1 }).unwrap(); + let open = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); assert_eq!(drain_groups(&mut subscriber), [0, 1]); open.abort(Error::Cancel).unwrap(); @@ -27218,7 +27211,7 @@ mod test { /// A group of one untimed frame at `key`. fn write_untimed_group(producer: &Producer, key: u64) { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); @@ -27291,7 +27284,7 @@ mod test { 3 => { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -27314,7 +27307,7 @@ mod test { write_group(&producer, 0); // Group 1 never arrives. let open: Vec<_> = (2..2 + RUN) - .map(|key| producer.create_group(group::Info { start: key }).unwrap()) + .map(|key| producer.create_group(group::Info { start: key }).unwrap().unwrap()) .collect(); assert_eq!( drain_groups(&mut subscriber), @@ -27339,7 +27332,7 @@ mod test { producer.subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(1)))); let mut handed = Vec::new(); for key in (0..20).step_by(2) { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); @@ -27369,7 +27362,7 @@ mod test { let mut subscriber = producer.subscribe(Subscription::default().with_delay(Delay::default().with_max(budget))); let mut open = Vec::new(); for key in (0..=10).step_by(2) { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); @@ -27406,7 +27399,7 @@ mod test { let producer = untimed_producer(); let mut subscriber = producer.subscribe(replay()); for key in (0..2000u64).step_by(2) { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); @@ -27473,7 +27466,7 @@ mod test { req.accept(None).unwrap().expect("a fresh group").finish().unwrap(); producer .create_group(group::Info { start: 0 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let mut late = producer.subscribe(replay().with_ranges([Range::live()])); @@ -27493,7 +27486,7 @@ mod test { }; let mut behind = producer.subscribe(replay().with_ranges([buffering])); let write = |key| { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); @@ -27556,7 +27549,7 @@ mod test { /// A group `key` whose first frame lands at `millis`, or the write's refusal. A /// refused group is aborted, as a caller would. fn start_at_millis(producer: &Producer, key: u64, millis: u64) -> Result { - let mut group = producer.create_group(group::Info { start: key })?; + let mut group = producer.create_group(group::Info { start: key })?.expect("a fresh group"); match group.write_frame(Timestamp::from_millis(millis).unwrap(), &b"x"[..]) { Ok(()) => Ok(group), Err(err) => { @@ -27661,7 +27654,7 @@ mod test { let producer = track_producer("test", Info::timed()); start_at_millis(&producer, 0, 0).unwrap().finish().unwrap(); start_at_millis(&producer, 1, 1000).unwrap().finish().unwrap(); - let mut delayed = producer.create_group(group::Info { start: 2 }).unwrap(); + let mut delayed = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); evict(&producer, 1); let refused = delayed.write_frame(Timestamp::from_millis(500).unwrap(), &b"x"[..]); @@ -27722,7 +27715,7 @@ mod test { fn a_resumed_partial_group_is_neither_checked_nor_a_bound() { let producer = track_producer("test", Info::timed()); start_at_millis(&producer, 0, 1000).unwrap().finish().unwrap(); - let mut partial = producer.create_group(group::Info { start: 1 }).unwrap(); + let mut partial = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); partial.start_at(3).unwrap(); partial .write_frame(Timestamp::from_millis(2100).unwrap(), &b"x"[..]) @@ -27735,7 +27728,7 @@ mod test { fn an_untimed_track_takes_groups_in_any_order() { let producer = untimed_producer(); for key in [5, 3, 4] { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); @@ -27826,7 +27819,7 @@ mod test { let key = next(KEYS); match next(5) { 0 | 1 => { - if let Ok(mut group) = producer.create_group(group::Info { start: key }) { + if let Ok(Some(mut group)) = producer.create_group(group::Info { start: key }) { if next(2) == 0 { group .write_frame(at(key * 20), bytes::Bytes::from_static(b"x")) @@ -27897,7 +27890,7 @@ mod test { for key in 0..1000 { producer .create_group(group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -28081,7 +28074,7 @@ mod test { reader.poll_drop(&waiter).is_pending(), "the groups above it are not all read" ); - let _group = producer.create_group(group::Info { start: 6 }).unwrap(); + let _group = producer.create_group(group::Info { start: 6 }).unwrap().unwrap(); assert_eq!(reader.poll_drop(&waiter), Poll::Ready((5..6, Hole::stale(budget)))); } @@ -28215,7 +28208,7 @@ mod test { let dynamic = producer.requests(); let budget = Duration::from_millis(500); producer.give_up(0..2, Hole::stale(budget)); - producer.create_group(3u64.into()).unwrap().finish().unwrap(); + producer.create_group(3u64.into()).unwrap().unwrap().finish().unwrap(); let reader = |max: Duration, range: Range| { producer.subscribe( Subscription::default() @@ -28638,7 +28631,7 @@ mod test { pool.resize(capacity); let mut read = None; for key in 2 * RUNS..2 * RUNS + 64 { - let mut group = producer.create_group(group::Info { start: key }).unwrap(); + let mut group = producer.create_group(group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), vec![0u8; 16 * 1024]) .unwrap(); @@ -28761,7 +28754,7 @@ mod test { assert!(producer.state.read().skipped(0), "a skip above the edge stays"); // The write's own expiry scan finds the skip, with nothing else to rearm it. - let _group = producer.create_group(group::Info { start: 10 }).unwrap(); + let _group = producer.create_group(group::Info { start: 10 }).unwrap().unwrap(); let state = producer.state.read(); assert!(!state.skipped(0), "the edge passed the skip"); assert_eq!(state.drops_bill.size(), 0, "its bill went with it"); @@ -28776,7 +28769,7 @@ mod test { let waiter = kio::Waiter::noop(); // Presented just after group 0, since its key in milliseconds overflows. let write_far = |producer: &Producer| { - let mut group = producer.create_group(group::Info { start: FAR }).unwrap(); + let mut group = producer.create_group(group::Info { start: FAR }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(1).unwrap(), &b"x"[..]) .unwrap(); @@ -28809,7 +28802,7 @@ mod test { fn an_aborted_key_is_created_again() { let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(replay().with_range(0..)); - let group = producer.create_group(group::Info { start: 0 }).unwrap(); + let group = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.abort(Error::Stream(StreamError::Cancel)).unwrap(); write_group(&producer, 0); producer.append_next().unwrap().finish().unwrap(); @@ -28978,9 +28971,9 @@ mod test { fn a_drop_ends_a_held_group_with_its_error() { let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(replay()); - let mut open = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut open = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); open.write_frame(open.key_time(), &b"a"[..]).unwrap(); - let mut finished = producer.create_group(group::Info { start: 1 }).unwrap(); + let mut finished = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); finished.write_frame(finished.key_time(), &b"b"[..]).unwrap(); finished.finish().unwrap(); @@ -29017,7 +29010,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(1).unwrap(); live.write_frame(live.key_time(), &b"delta"[..]).unwrap(); let _fetch = consumer.fetch_group(0, None); @@ -29045,12 +29038,12 @@ mod test { let producer = track_producer("test", Info::timed()); let mut arrival = producer.subscribe(replay()); let mut ordered = producer.subscribe(replay()).ordered(); - let mut cut = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut cut = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); cut.write_frame(cut.key_time(), &b"a"[..]).unwrap(); cut.abort(Error::App(5)).unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let _producer = producer.finish().unwrap(); @@ -29084,12 +29077,12 @@ mod test { ] { let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(replay()); - let mut group = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut group = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); group.write_frame(group.key_time(), &b"a"[..]).unwrap(); group.abort(err.clone()).unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); assert_eq!(subscriber.assert_group().start, 1, "{err:?}"); @@ -29104,15 +29097,15 @@ mod test { fn a_cut_outlives_the_sweep_until_it_expires() { let pool = cache::Pool::new(cache::Config::default().with_expiry(Duration::from_secs(10))); let producer = track_producer_pooled("test", pool.clone()); - let mut cut = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut cut = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); cut.write_frame(cut.key_time(), &b"a"[..]).unwrap(); cut.abort(Error::App(5)).unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); - let _live = producer.create_group(group::Info { start: 2 }).unwrap(); + let _live = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); elapse(&producer, Duration::from_secs(1)); pool.sweep(); @@ -29146,10 +29139,10 @@ mod test { let mut ordered = producer.subscribe(replay()).ordered().with_range(..1); producer .create_group(group::Info { start: 0 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); - let mut cut = producer.create_group(group::Info { start: 1 }).unwrap(); + let mut cut = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); cut.write_frame(cut.key_time(), &b"a"[..]).unwrap(); cut.abort(Error::App(5)).unwrap(); @@ -29213,7 +29206,7 @@ mod test { let producer = track_producer("test", Info::timed()); write_group(&producer, 0); write_group(&producer, 1000); - let mut partial = producer.create_group(group::Info { start: 2000 }).unwrap(); + let mut partial = producer.create_group(group::Info { start: 2000 }).unwrap().unwrap(); partial.start_at(1).unwrap(); partial .write_frame(Timestamp::from_millis(2500).unwrap(), bytes::Bytes::from_static(b"x")) @@ -29235,7 +29228,7 @@ mod test { for order in [Order::Ascending, Order::Descending] { let producer = track_producer("test", Info::timed()); let _groups: Vec<_> = (2..10) - .map(|second| producer.create_group(group::Info { start: second * 1000 }).unwrap()) + .map(|second| producer.create_group(group::Info { start: second * 1000 }).unwrap().unwrap()) .collect(); let since = [Range { start: Anchor::Time(2500), @@ -29260,7 +29253,7 @@ mod test { let producer = track_producer("test", Info::timed()); let _groups: Vec<_> = [0, 400, 600] .into_iter() - .map(|key| producer.create_group(group::Info { start: key }).unwrap()) + .map(|key| producer.create_group(group::Info { start: key }).unwrap().unwrap()) .collect(); let mut subscriber = producer.subscribe(replay().with_ranges([Range { start: Anchor::Time(0), @@ -29498,7 +29491,7 @@ mod test { let pool = producer.broadcast.pool.clone(); let dynamic = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(32).unwrap(); live.write_frame(live.key_time(), vec![32; size]).unwrap(); assert!( @@ -29580,7 +29573,7 @@ mod test { #[cfg(feature = "async")] async fn tail_owner_survives_slot_removal_but_not_live_recreation() { let producer = track_producer("test", Info::timed()); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(8).unwrap(); live.write_frame(live.key_time(), b"eight".as_slice()).unwrap(); let mut tails = Vec::new(); @@ -29631,7 +29624,7 @@ mod test { refill.write_frame(refill.key_time(), b"zero".as_slice()).unwrap(); let refill = refill.finish().unwrap(); refill.abort(Error::Cancel).unwrap(); - let mut recreated = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut recreated = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); recreated.start_at(8).unwrap(); recreated .write_frame(recreated.key_time(), b"new eight".as_slice()) @@ -29665,7 +29658,7 @@ mod test { ..Default::default() }); let producer = Producer::new(broadcast, "test", Info::timed()); - let mut first = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut first = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); first.start_at(4).unwrap(); let mut first_read = first.consume().with_range(4..); let mut first = first @@ -29787,7 +29780,7 @@ mod test { frame.finish().unwrap() } let producer = track_producer("test", Info::timed()); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(2).unwrap(); live.set_wire(wire(100)).unwrap(); let live = write(live, 100, b"a"); @@ -29898,7 +29891,7 @@ mod test { } let info = Info::timed().with_compression(Compression::Deflate); let reference = track_producer("reference", info.clone()); - let mut source = reference.create_group(group::Info { start: 0 }).unwrap(); + let mut source = reference.create_group(group::Info { start: 0 }).unwrap().unwrap(); let expected: Vec<_> = (0..9) .map(|index| bytes::Bytes::from(format!("shared dictionary frame {index}; ").repeat(64))) .collect(); @@ -29917,7 +29910,7 @@ mod test { let producer = track_producer("test", info.clone()); let requests = producer.requests(); let consumer = producer.consume(); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(8).unwrap(); let live = ingest(live, &stored[8]); let mut raw_live = live.consume().with_range(8..).compressed(); @@ -30011,7 +30004,7 @@ mod test { #[cfg(feature = "async")] async fn canonical_owner_follows_an_evicted_streaming_frame_reader() { let producer = track_producer("test", Info::timed()); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); live.start_at(4).unwrap(); let observing = live.handle(); let mut reader = live.consume().with_range(4..); @@ -30085,7 +30078,7 @@ mod test { #[test] fn canonical_content_preserves_individually_valid_disjoint_ranges() { let producer = track_producer("test", Info::timed()); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); const FRAMES: usize = 8192; live.start_at(FRAMES as u64).unwrap(); for _ in 0..FRAMES { @@ -30120,7 +30113,7 @@ mod test { const POOL: u64 = 4 * 1024 * 1024; let pool = cache::Pool::new(cache::Config::default().with_capacity(POOL)); let producer = track_producer_pooled("test", pool.clone()); - let mut live = producer.create_group(group::Info { start: 0 }).unwrap(); + let mut live = producer.create_group(group::Info { start: 0 }).unwrap().unwrap(); let mut reader = live.consume(); let mut late = live.consume(); // 48 MiB, past the 32 MiB tail: pool debt sheds first. @@ -30738,7 +30731,7 @@ mod test { #[test] fn a_read_with_more_to_come_parks() { let producer = track_producer("test", Info::timed()); - producer.create_group(0u64.into()).unwrap().finish().unwrap(); + producer.create_group(0u64.into()).unwrap().unwrap().finish().unwrap(); let mut open = producer.subscribe(replay().with_range(0..)); assert_eq!(read_now(&mut open, false), Some(Some(0))); @@ -30751,7 +30744,7 @@ mod test { let mut owed = producer.subscribe(replay().with_range(0..2)); assert_eq!(read_now(&mut owed, false), Some(Some(0))); assert_eq!(read_now(&mut owed, false), None, "group 1 may still arrive"); - producer.create_group(1u64.into()).unwrap().finish().unwrap(); + producer.create_group(1u64.into()).unwrap().unwrap().finish().unwrap(); assert_eq!(read_now(&mut owed, false), Some(Some(1))); assert_eq!(read_now(&mut owed, false), Some(None)); } @@ -30762,7 +30755,7 @@ mod test { fn a_bounded_read_ends_past_dropped_and_stale_groups() { let producer = track_producer("test", Info::timed()); let mut dropped = producer.subscribe(replay().with_range(0..2)); - producer.create_group(0u64.into()).unwrap().finish().unwrap(); + producer.create_group(0u64.into()).unwrap().unwrap().finish().unwrap(); assert_eq!(read_now(&mut dropped, false), Some(Some(0))); assert_eq!(read_now(&mut dropped, false), None); producer.drop_groups(1..2, StreamError::NotFound); @@ -30773,7 +30766,7 @@ mod test { let producer = track_producer("test", Info::timed()); // Group 1 runs on past where group 0 could still present. for (key, frames) in [(0u64, &[0u64][..]), (1, &[1_000, 1_100])] { - let mut group = producer.create_group(key.into()).unwrap(); + let mut group = producer.create_group(key.into()).unwrap().unwrap(); for at in frames { group .write_frame(Timestamp::from_millis(*at).unwrap(), bytes::Bytes::from_static(b"f")) @@ -30798,7 +30791,7 @@ mod test { #[test] fn a_parked_bounded_read_waits_past_its_end() { let producer = track_producer("test", Info::timed()); - producer.create_group(0u64.into()).unwrap().finish().unwrap(); + producer.create_group(0u64.into()).unwrap().unwrap().finish().unwrap(); let mut reader = producer.subscribe(replay().with_range(0..1)).parked(); assert_eq!(read_now(&mut reader, false), Some(Some(0))); assert_eq!(read_now(&mut reader, false), None); @@ -30812,8 +30805,8 @@ mod test { // A received copy, whose missing groups may still arrive. producer.received(); let dynamic = producer.requests(); - producer.create_group(0u64.into()).unwrap().finish().unwrap(); - producer.create_group(2u64.into()).unwrap().finish().unwrap(); + producer.create_group(0u64.into()).unwrap().unwrap().finish().unwrap(); + producer.create_group(2u64.into()).unwrap().unwrap().finish().unwrap(); let producer = producer.finish().unwrap(); // From group 0, which a time start names without a lookup, through the hole at 1. let mut reader = producer.subscribe(replay().with_order(Order::Ascending).with_range(0..2)); @@ -30843,7 +30836,7 @@ mod test { async fn a_hole_below_an_undeclared_start_is_asked_after_a_bounded_grace() { let (producer, _pool) = pooled_producer(1 << 40); let dynamic = producer.requests(); - producer.create_group(10u64.into()).unwrap().finish().unwrap(); + producer.create_group(10u64.into()).unwrap().unwrap().finish().unwrap(); let mut reader = producer.subscribe( Subscription::default() .with_delay(crate::track::Delay::default().with_max(None)) @@ -30864,7 +30857,7 @@ mod test { // With no fill handler, the hole is given up once the grace passed. let (producer, _pool) = pooled_producer(1 << 40); - producer.create_group(10u64.into()).unwrap().finish().unwrap(); + producer.create_group(10u64.into()).unwrap().unwrap().finish().unwrap(); let mut reader = producer.subscribe( Subscription::default() .with_delay(crate::track::Delay::default().with_max(None)) @@ -30888,7 +30881,7 @@ mod test { } let dynamic = producer.requests(); producer.start_at(10).unwrap(); - producer.create_group(10u64.into()).unwrap().finish().unwrap(); + producer.create_group(10u64.into()).unwrap().unwrap().finish().unwrap(); let mut reader = producer.subscribe( Subscription::default() .with_delay(crate::track::Delay::default().with_max(None)) @@ -30978,7 +30971,7 @@ mod test { // Group 2k+1 runs on past where group 2k could still present, so 2k is stale. let at = 2_000 * round; for (key, frames) in [(2 * round, vec![at]), (2 * round + 1, vec![at + 1_000, at + 1_100])] { - let mut group = producer.create_group(key.into()).unwrap(); + let mut group = producer.create_group(key.into()).unwrap().unwrap(); for at in frames { group .write_frame(Timestamp::from_millis(at).unwrap(), bytes::Bytes::from_static(b"f")) @@ -31009,7 +31002,7 @@ mod test { .with_range(0..), ); for (key, frames) in [(0u64, &[0u64][..]), (1, &[1_000, 1_100])] { - let mut group = producer.create_group(key.into()).unwrap(); + let mut group = producer.create_group(key.into()).unwrap().unwrap(); for at in frames { group .write_frame(Timestamp::from_millis(*at).unwrap(), bytes::Bytes::from_static(b"f")) @@ -31037,7 +31030,7 @@ mod test { async fn an_unfillable_hole_below_the_start_wakes_its_reader() { let (mut producer, _pool) = pooled_producer(1 << 40); producer.start_at(10).unwrap(); - producer.create_group(10u64.into()).unwrap().finish().unwrap(); + producer.create_group(10u64.into()).unwrap().unwrap().finish().unwrap(); let mut reader = producer.subscribe( Subscription::default() .with_delay(crate::track::Delay::default().with_max(None)) diff --git a/rs/moq-net/src/model/track/miss.rs b/rs/moq-net/src/model/track/miss.rs index c1ae7c43692..661a1af8088 100644 --- a/rs/moq-net/src/model/track/miss.rs +++ b/rs/moq-net/src/model/track/miss.rs @@ -1657,7 +1657,7 @@ mod tests { for key in [0, 2] { track .create_group(crate::group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -1718,7 +1718,7 @@ mod tests { for key in [4, 0] { track .create_group(crate::group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -1767,7 +1767,7 @@ mod tests { // again, and reclaiming the cut removes the cached incarnation before the probe. track .create_group(crate::group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .abort(Error::Cancel) .unwrap(); track.drop_groups(2..3, crate::StreamError::Old); @@ -1792,7 +1792,7 @@ mod tests { drop(state); track .create_group(crate::group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let state = track.state.read(); @@ -1863,7 +1863,7 @@ mod tests { for key in [4, 0] { track .create_group(crate::group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -1909,7 +1909,7 @@ mod tests { // still a hole: the refusal stands and the hole is given up, not asked again. track .create_group(crate::group::Info { start: 2 }) - .unwrap() + .unwrap().unwrap() .abort(Error::Cancel) .unwrap(); let state = track.state.read(); @@ -1940,7 +1940,7 @@ mod tests { for key in [0, 2, 4] { track .create_group(crate::group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -1991,7 +1991,7 @@ mod tests { drop(state); track .create_group(crate::group::Info { start: 1 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let state = track.state.read(); @@ -2052,7 +2052,7 @@ mod tests { for key in 0..3 { track .create_group(crate::group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -2110,7 +2110,7 @@ mod tests { track .create_group(crate::group::Info { start: 4 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let state = track.state.read(); @@ -2223,7 +2223,7 @@ mod tests { let key = next(KEYS); match next(6) { 0..=2 => { - if let Ok(mut group) = track.create_group(crate::group::Info { start: key }) { + if let Ok(Some(mut group)) = track.create_group(crate::group::Info { start: key }) { if next(4) > 0 { group .write_frame(at(key * 20), bytes::Bytes::from_static(b"x")) @@ -2320,7 +2320,7 @@ mod tests { for &key in keys.iter().rev() { track .create_group(crate::group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -2426,7 +2426,7 @@ mod tests { for key in [0, 2, 4, 6, 8] { track .create_group(crate::group::Info { start: key }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); } @@ -2502,7 +2502,7 @@ mod tests { track.start_at(8).unwrap(); track .create_group(crate::group::Info { start: 8 }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let track = track.finish().unwrap(); diff --git a/rs/moq-net/tests/integration/answer_behind_cache.rs b/rs/moq-net/tests/integration/answer_behind_cache.rs index b235c2ae882..324b5226289 100644 --- a/rs/moq-net/tests/integration/answer_behind_cache.rs +++ b/rs/moq-net/tests/integration/answer_behind_cache.rs @@ -20,7 +20,7 @@ fn produce_origin(hop: u64) -> origin::Producer { } fn write_group(track: &track::Producer, payload: &'static [u8]) { - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); group .write_frame(moq_net::Timestamp::unscaled(group.start), payload) .unwrap(); @@ -133,7 +133,7 @@ async fn a_reset_newest_group_answers_the_group_before(version: &str) { .create_track("audio", track::Info::default().with_timescale(None)) .unwrap(); route.announce().unwrap(); - let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); g0.write_frame(moq_net::Timestamp::unscaled(g0.start), &b"0a"[..]) .unwrap(); @@ -161,7 +161,7 @@ async fn a_reset_newest_group_answers_the_group_before(version: &str) { .unwrap(); assert_eq!(next_group(&mut subscriber).await.unwrap(), (0, b"0a".to_vec())); g0.finish().unwrap(); - let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); g1.write_frame(moq_net::Timestamp::unscaled(g1.start), &b"1a"[..]) .unwrap(); assert_eq!(next_group(&mut subscriber).await.unwrap(), (1, b"1a".to_vec())); @@ -191,7 +191,7 @@ async fn a_reset_newest_group_answers_the_group_before(version: &str) { .unwrap(); // The upper relay answers the resubscription before the feed moves on. kio::clock::sleep(Duration::from_secs(1)).await; - let mut g2 = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); + let mut g2 = track.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); g2.write_frame(moq_net::Timestamp::unscaled(g2.start), &b"2a"[..]) .unwrap(); loop { diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index f4cdc1d71c9..802a769ba36 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -154,7 +154,7 @@ async fn a_start_group_arrives_whole() { false => moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), }; let published = publish(info); - let mut group = published.track.create_group(moq_net::group::Info { start: 5 }).unwrap(); + let mut group = published.track.create_group(moq_net::group::Info { start: 5 }).unwrap().unwrap(); write(&mut group, 0..head); let mut fixture = relay( published, diff --git a/rs/moq-net/tests/integration/drop_record.rs b/rs/moq-net/tests/integration/drop_record.rs index bac43090c65..5a08dca635e 100644 --- a/rs/moq-net/tests/integration/drop_record.rs +++ b/rs/moq-net/tests/integration/drop_record.rs @@ -37,7 +37,7 @@ fn timed() -> Info { /// Write group `key` presented at `millis`, and finish it. fn write(source: &track::Producer, key: u64, millis: u64) { - let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(millis).unwrap(), &b"x"[..]) .unwrap(); @@ -411,7 +411,7 @@ async fn an_origin_eviction_drop_is_forwarded_final() { let mut reader = chain.subscribe(reading(None, [support::keys(0..)])).await; chain.upstream.server_transport.hold_unis(); let write = |key: u64| { - let mut group = chain.source.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = chain.source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), vec![0u8; PAYLOAD]) .unwrap(); @@ -493,7 +493,7 @@ async fn an_ordered_reader_is_told_of_every_group_the_origin_evicted() { .ordered(); chain.upstream.server_transport.hold_unis(); for key in 0..WRITTEN { - let mut group = chain.source.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = chain.source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), vec![0u8; PAYLOAD]) .unwrap(); @@ -545,7 +545,7 @@ async fn a_run_dropped_before_the_first_group_settles_a_later_range() { let chain = Chain::new([LITE07, LITE07], [forever(), forever(), forever()]).await; let mut reader = chain.subscribe(reading(None, [support::keys(0..)])).await; for key in 0..2 { - let group = chain.source.create_group(moq_net::group::Info { start: key }).unwrap(); + let group = chain.source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group.abort(moq_net::Error::App(1)).unwrap(); } write(&chain.source, 2, 0); @@ -646,7 +646,7 @@ async fn settle_even(chain: &Chain, runs: u64, stale: Option) { let group = chain .source .create_group(moq_net::group::Info { start: 2 * run }) - .unwrap(); + .unwrap().unwrap(); group.abort(moq_net::Error::App(1)).unwrap(); } } diff --git a/rs/moq-net/tests/integration/fetch_from_feed.rs b/rs/moq-net/tests/integration/fetch_from_feed.rs index a5052edff9b..305666cb07b 100644 --- a/rs/moq-net/tests/integration/fetch_from_feed.rs +++ b/rs/moq-net/tests/integration/fetch_from_feed.rs @@ -161,7 +161,7 @@ async fn an_unfed_fetch_is_a_miss() { write(&relay.track, b"1"); // The publisher skips group 2, so the feed goes past it. - let mut skipped = relay.track.create_group(moq_net::group::Info { start: 3 }).unwrap(); + let mut skipped = relay.track.create_group(moq_net::group::Info { start: 3 }).unwrap().unwrap(); skipped .write_frame(moq_net::Timestamp::unscaled(skipped.start), &b"3"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index 0ae952f2979..c1b774d39f5 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -329,7 +329,7 @@ async fn a_relay_serves_a_bounded_read_of_history_without_subscribing_upstream() /// Write group `key` of [`frames`] to a live track. fn write_group(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); for frame in frames(key) { group.write_frame(group.at_start(), frame).unwrap(); } diff --git a/rs/moq-net/tests/integration/group_order.rs b/rs/moq-net/tests/integration/group_order.rs index c94d8e901fd..36c40664839 100644 --- a/rs/moq-net/tests/integration/group_order.rs +++ b/rs/moq-net/tests/integration/group_order.rs @@ -89,7 +89,7 @@ fn write_backlog(track: &moq_net::track::Producer) -> Vec Vec<(u64, usiz first_hop.hold_unis(); } - let mut old = track.create_group(moq_net::group::Info { start: 5 }).unwrap(); + let mut old = track.create_group(moq_net::group::Info { start: 5 }).unwrap().unwrap(); for _ in 0..3 { old.write_frame(Timestamp::from_millis(5).unwrap(), &b"old"[..]) .unwrap(); } old.finish().unwrap(); - let mut live = track.create_group(moq_net::group::Info { start: 6 }).unwrap(); + let mut live = track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); for _ in 0..2 { live.write_frame(Timestamp::from_millis(6).unwrap(), &b"live"[..]) .unwrap(); @@ -252,13 +252,13 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { }); crate::support::wanted(track.demand()).await.unwrap(); upstream.server_transport.hold_unis(); - let mut old = track.create_group(moq_net::group::Info { start: 5 }).unwrap(); + let mut old = track.create_group(moq_net::group::Info { start: 5 }).unwrap().unwrap(); for _ in 0..3 { old.write_frame(Timestamp::from_millis(5).unwrap(), &b"old"[..]) .unwrap(); } old.finish().unwrap(); - let mut live = track.create_group(moq_net::group::Info { start: 6 }).unwrap(); + let mut live = track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); for _ in 0..2 { live.write_frame(Timestamp::from_millis(6).unwrap(), &b"live"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/idle_cancel_refetch.rs b/rs/moq-net/tests/integration/idle_cancel_refetch.rs index 48c783a8a58..48a0cc58f15 100644 --- a/rs/moq-net/tests/integration/idle_cancel_refetch.rs +++ b/rs/moq-net/tests/integration/idle_cancel_refetch.rs @@ -34,11 +34,11 @@ async fn a_group_cut_by_an_idle_cancel_is_refetched_whole() { .unwrap(); broadcast.announce().unwrap(); - let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); g0.write_frame(moq_net::Timestamp::unscaled(g0.start), &b"0a"[..]) .unwrap(); g0.finish().unwrap(); - let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); + let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); g1.write_frame(moq_net::Timestamp::unscaled(g1.start), &b"1a"[..]) .unwrap(); @@ -83,7 +83,7 @@ async fn a_group_cut_by_an_idle_cancel_is_refetched_whole() { g1.write_frame(moq_net::Timestamp::unscaled(g1.start), &b"1b"[..]) .unwrap(); g1.finish().unwrap(); - let mut g2 = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); + let mut g2 = track.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); g2.write_frame(moq_net::Timestamp::unscaled(g2.start), &b"2a"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/late_lower_group.rs b/rs/moq-net/tests/integration/late_lower_group.rs index d850dbe155f..6c803f47b66 100644 --- a/rs/moq-net/tests/integration/late_lower_group.rs +++ b/rs/moq-net/tests/integration/late_lower_group.rs @@ -46,7 +46,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { /// Four frames starting at `key` seconds, so a group created late still starts /// below the one after it. fn write_group(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); for frame in 0..4 { let timestamp = Timestamp::from_millis(key * 1000 + frame).unwrap(); group.write_frame(timestamp, &b"x"[..]).unwrap(); diff --git a/rs/moq-net/tests/integration/model.rs b/rs/moq-net/tests/integration/model.rs index 001aa929ee1..011c1814e7a 100644 --- a/rs/moq-net/tests/integration/model.rs +++ b/rs/moq-net/tests/integration/model.rs @@ -26,7 +26,7 @@ fn origin_front_serves_media_with_only_explicit_polls() { track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) .unwrap(); - let mut group = track.create_group(group::Info { start: 7 }).unwrap(); + let mut group = track.create_group(group::Info { start: 7 }).unwrap().unwrap(); group.write_frame(Timestamp::from_millis(7).unwrap(), b"media").unwrap(); group.finish().unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index fda4f0e6993..98e3909ba85 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -61,7 +61,7 @@ async fn read(version: Option<&str>, range: Range) -> Result, Error> { .unwrap(); broadcast.announce().unwrap(); for key in (0..5).map(|second| second * 1000) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group.write_frame(millis(key), &b"x"[..]).unwrap(); group.finish().unwrap(); } @@ -198,13 +198,13 @@ async fn a_relative_start_reports_the_publishers_start_over_a_frameless_newest_g .unwrap(); broadcast.announce().unwrap(); for key in 0..5 { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(moq_net::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); group.finish().unwrap(); } - let mut newest = track.create_group(moq_net::group::Info { start: 5 }).unwrap(); + let mut newest = track.create_group(moq_net::group::Info { start: 5 }).unwrap().unwrap(); let subscriber = produce_origin(2); let _pair = peer("moq-lite-07-wip".parse::().unwrap(), &publisher, &subscriber).await; @@ -261,7 +261,7 @@ async fn a_sparse_request_counts_its_relative_start_back_as_the_publisher_did() .unwrap(); broadcast.announce().unwrap(); for key in 0..10 { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group.write_frame(millis(key), &b"x"[..]).unwrap(); group.finish().unwrap(); } diff --git a/rs/moq-net/tests/integration/range_fill.rs b/rs/moq-net/tests/integration/range_fill.rs index 86ca51d01eb..7312a3daef4 100644 --- a/rs/moq-net/tests/integration/range_fill.rs +++ b/rs/moq-net/tests/integration/range_fill.rs @@ -61,7 +61,7 @@ impl Fixture { broadcast.announce().unwrap(); for index in 0..groups { let mut group = match spacing { - 1 => track.create_group(moq_net::group::Info { start: index }).unwrap(), + 1 => track.create_group(moq_net::group::Info { start: index }).unwrap().unwrap(), spacing => track .append_group(Timestamp::from_millis(index * spacing).unwrap()) .unwrap(), @@ -152,7 +152,7 @@ async fn evicted_history_is_recovered_once_on_its_own_subscription() { assert_eq!(fixture.opened(FETCH), 0, "nothing fetched"); // The live subscription goes on. - let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap(); + let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(6000).unwrap(), b"x".as_slice()) .unwrap(); @@ -236,7 +236,7 @@ async fn a_recovery_takes_a_skip_inside_it() { let fixture = Fixture::new(2).await; fixture.track.skip_groups(2..3); for start in 3..6 { - let mut group = fixture.track.create_group(moq_net::group::Info { start }).unwrap(); + let mut group = fixture.track.create_group(moq_net::group::Info { start }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(start * 1000).unwrap(), b"x".as_slice()) .unwrap(); @@ -252,7 +252,7 @@ async fn a_recovery_takes_a_skip_inside_it() { assert_eq!(receive(&mut second, 3).await, [1, 3, 4].into()); // The live subscription goes on. - let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap(); + let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(6000).unwrap(), b"x".as_slice()) .unwrap(); diff --git a/rs/moq-net/tests/integration/range_union_fit.rs b/rs/moq-net/tests/integration/range_union_fit.rs index 57e113767da..0ca63fd5fef 100644 --- a/rs/moq-net/tests/integration/range_union_fit.rs +++ b/rs/moq-net/tests/integration/range_union_fit.rs @@ -30,7 +30,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { } fn write_group(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/received_rewind.rs b/rs/moq-net/tests/integration/received_rewind.rs index bf290b781d9..ed84227c9e8 100644 --- a/rs/moq-net/tests/integration/received_rewind.rs +++ b/rs/moq-net/tests/integration/received_rewind.rs @@ -33,7 +33,7 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { /// A group starting at `key` milliseconds. fn write_group(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); let timestamp = millis(key); group.write_frame(timestamp, &b"x"[..]).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-net/tests/integration/route_audit/mod.rs b/rs/moq-net/tests/integration/route_audit/mod.rs index 9137b1dcd26..b46c4da93b4 100644 --- a/rs/moq-net/tests/integration/route_audit/mod.rs +++ b/rs/moq-net/tests/integration/route_audit/mod.rs @@ -286,7 +286,7 @@ impl Feed { while !stopped.load(Ordering::Relaxed) { let start = key * CADENCE.as_millis() as u64; for track in &tracks { - let mut group = track.create_group(group::Info { start }).unwrap(); + let mut group = track.create_group(group::Info { start }).unwrap().unwrap(); let frame = payload(tag, key, kio::clock::now()); group .write_frame(Timestamp::from_millis(start).unwrap(), frame) diff --git a/rs/moq-net/tests/integration/route_change.rs b/rs/moq-net/tests/integration/route_change.rs index d2fb37e4d12..21dd601aec4 100644 --- a/rs/moq-net/tests/integration/route_change.rs +++ b/rs/moq-net/tests/integration/route_change.rs @@ -980,7 +980,7 @@ async fn redundant_pair_follows_the_next_instance(version: &str, loss: Loss) { let mut rx = read(first.track("video").unwrap().subscribe(prefs.clone()).await.unwrap()); let write = |replicas: &mut Vec, key: u64| { for replica in replicas.iter_mut() { - let mut group = replica.track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = replica.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame( Timestamp::from_micros(1_000_000 + key * 1_000).unwrap(), @@ -1333,7 +1333,7 @@ async fn producer_replaced(version: &str) { .unwrap(); // The application owns where the replacement starts, so it continues explicitly. - let mut group = second.create_group(moq_net::group::Info { start: 2 }).unwrap(); + let mut group = second.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); for frame in 0..FRAMES { group.write_frame(group.at_start(), payload(2, frame)).unwrap(); assert_eq!(next(&mut rx).await, (2, payload(2, frame)), "{version}"); diff --git a/rs/moq-net/tests/integration/route_cluster.rs b/rs/moq-net/tests/integration/route_cluster.rs index 7b6d3aa6811..2bf98a5c38e 100644 --- a/rs/moq-net/tests/integration/route_cluster.rs +++ b/rs/moq-net/tests/integration/route_cluster.rs @@ -235,7 +235,7 @@ impl Publisher { /// Write group `key` in full. fn group(&self, key: u64) { - let mut group = self.track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = self.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); for frame in 0..FRAMES { let timestamp = Timestamp::from_micros(1_000_000 + key * 100_000 + frame * 1_000).unwrap(); group.write_frame(timestamp, tagged(self.name, key, frame)).unwrap(); diff --git a/rs/moq-net/tests/integration/shared_copy_start.rs b/rs/moq-net/tests/integration/shared_copy_start.rs index 40443ffc561..364ad54974a 100644 --- a/rs/moq-net/tests/integration/shared_copy_start.rs +++ b/rs/moq-net/tests/integration/shared_copy_start.rs @@ -22,7 +22,7 @@ const TIMEOUT: Duration = Duration::from_secs(10); const STEP: u64 = 100; fn write(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/slow_joiner.rs b/rs/moq-net/tests/integration/slow_joiner.rs index ac31b59d98c..3a4be85799b 100644 --- a/rs/moq-net/tests/integration/slow_joiner.rs +++ b/rs/moq-net/tests/integration/slow_joiner.rs @@ -69,7 +69,7 @@ async fn stalled_read(version: Version, budget: Duration) -> BTreeSet { *gate.write().ok().unwrap() = false; for key in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index fdec725c616..89ce179de17 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -435,16 +435,16 @@ async fn a_waiting_late_group_lets_a_newer_group_through() { } // Unfinished, so its stream holds the only credit. - let mut held = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); + let mut held = track.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); held.write_frame(held.at_start(), b"held".as_slice()).unwrap(); assert_eq!(next!("the held group arrives").start, 2, "{version}"); // Late and below the held stream: it waits for credit it cannot make room for. - let mut late = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut late = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); late.write_frame(late.at_start(), b"late".as_slice()).unwrap(); late.finish().unwrap(); - let mut newer = track.create_group(moq_net::group::Info { start: 3 }).unwrap(); + let mut newer = track.create_group(moq_net::group::Info { start: 3 }).unwrap().unwrap(); newer.write_frame(newer.at_start(), b"new".as_slice()).unwrap(); newer.finish().unwrap(); // Lite-07 drops the late group as OLD when the newer one takes its place, and this @@ -507,18 +507,18 @@ async fn a_shed_late_group_lets_a_newer_group_through() { } // Unfinished, so its stream holds the only credit. - let mut held = track.create_group(moq_net::group::Info { start: 3 }).unwrap(); + let mut held = track.create_group(moq_net::group::Info { start: 3 }).unwrap().unwrap(); held.write_frame(held.at_start(), b"held".as_slice()).unwrap(); assert_eq!(next!("the held group arrives").start, 3, "{version}"); // Group 1 waits for credit it cannot make room for, and group 0 ranks below it. for key in [1, 0] { - let mut late = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut late = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); late.write_frame(late.at_start(), b"late".as_slice()).unwrap(); late.finish().unwrap(); } - let mut newer = track.create_group(moq_net::group::Info { start: 4 }).unwrap(); + let mut newer = track.create_group(moq_net::group::Info { start: 4 }).unwrap().unwrap(); newer.write_frame(newer.at_start(), b"new".as_slice()).unwrap(); newer.finish().unwrap(); assert_eq!( @@ -641,20 +641,20 @@ async fn a_closing_stream_does_not_rank_a_waiting_group() { let mut subscriber = remote.track("0").unwrap().subscribe(prefs).await.unwrap(); // Group 7 finishes, so its stream waits for the acknowledgement; group 10 holds the other. - let mut closing = track.create_group(moq_net::group::Info { start: 7 }).unwrap(); + let mut closing = track.create_group(moq_net::group::Info { start: 7 }).unwrap().unwrap(); closing.write_frame(closing.at_start(), b"closing".as_slice()).unwrap(); closing.finish().unwrap(); - let mut held = track.create_group(moq_net::group::Info { start: 10 }).unwrap(); + let mut held = track.create_group(moq_net::group::Info { start: 10 }).unwrap().unwrap(); held.write_frame(held.at_start(), b"held".as_slice()).unwrap(); kio::clock::sleep(SETTLE).await; // Ranked above group 7 but below group 10: it can only wait for group 7's credit. - let mut late = track.create_group(moq_net::group::Info { start: 8 }).unwrap(); + let mut late = track.create_group(moq_net::group::Info { start: 8 }).unwrap().unwrap(); late.write_frame(late.at_start(), b"late".as_slice()).unwrap(); late.finish().unwrap(); kio::clock::sleep(SETTLE).await; - let mut newer = track.create_group(moq_net::group::Info { start: 11 }).unwrap(); + let mut newer = track.create_group(moq_net::group::Info { start: 11 }).unwrap().unwrap(); newer.write_frame(newer.at_start(), b"new".as_slice()).unwrap(); newer.finish().unwrap(); diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index ef62cda2e4f..e2cd7369a97 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -33,7 +33,7 @@ fn timed() -> Info { } fn write_group(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); @@ -282,7 +282,7 @@ async fn range_fixture_history(version: &str, relay: bool, history: u64) -> Rang let track = broadcast.broadcast().create_track("quiet", timed()).unwrap(); broadcast.announce().unwrap(); for key in 0..history { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), b"x".as_slice()) .unwrap(); @@ -417,7 +417,7 @@ async fn draft22_updates_both_bounds_across_cached_groups() { .await .expect("the narrowed range never reached the publisher"); reader.update(initial.with_ranges([support::keys(0..)])).unwrap(); - let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap(); + let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(6).unwrap(), b"later".as_slice()) .unwrap(); @@ -488,7 +488,7 @@ async fn draft22_carries_time_ends_as_group_ids() { async fn draft22_can_widen_while_the_current_group_is_quiet() { for relay in [false, true] { let fixture = range_fixture(relay).await; - let mut quiet = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap(); + let mut quiet = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); quiet .write_frame(Timestamp::from_millis(6).unwrap(), b"head".as_slice()) .unwrap(); @@ -576,7 +576,7 @@ async fn draft18_updates_narrow_then_widen() { .await .unwrap_or_else(|_| panic!("{version} relay={relay}: narrowing did not reach the publisher")); for key in 6..8 { - let mut group = fixture.track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = fixture.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), key.to_be_bytes().as_slice()) .unwrap(); @@ -628,7 +628,7 @@ async fn empty_ranges_retire_the_wire_and_can_widen_again() { reader.poll_recv_group(&kio::Waiter::noop()), std::task::Poll::Ready(Ok(None)) )); - let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap(); + let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(6).unwrap(), b"sibling".as_slice()) .unwrap(); @@ -657,7 +657,7 @@ async fn empty_ranges_retire_the_wire_and_can_widen_again() { ) .await .unwrap_or_else(|_| panic!("{version} relay={relay}: empty demand retained a wire subscription")); - let mut group = fixture.track.create_group(moq_net::group::Info { start: 7 }).unwrap(); + let mut group = fixture.track.create_group(moq_net::group::Info { start: 7 }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(7).unwrap(), b"resumed".as_slice()) .unwrap(); @@ -706,7 +706,7 @@ async fn draft22_cold_widening_finishes_the_largest_group() { .await .unwrap_or_else(|_| panic!("relay={relay}: narrowing to {future} stalled")); for key in start..future { - let mut group = fixture.track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = fixture.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), key.to_be_bytes().as_slice()) .unwrap(); @@ -842,7 +842,7 @@ async fn holes_through_a_relay(version: &str, budget: Option) { let name = format!("{version} {order:?} budget={budget:?}"); let fixture = range_fixture_history(version, true, 0).await; for key in (0..=9).filter(|key| *key != ABSENT) { - let mut group = fixture.track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = fixture.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); if key == DROPPED { group.abort(moq_net::Error::App(1)).unwrap(); continue; @@ -887,7 +887,7 @@ async fn holes_through_a_relay(version: &str, budget: Option) { let mut group = fixture .track .create_group(moq_net::group::Info { start: LIVE_MILLIS }) - .unwrap(); + .unwrap().unwrap(); group .write_frame(Timestamp::from_millis(LIVE_MILLIS).unwrap(), b"x".as_slice()) .unwrap(); diff --git a/rs/moq-net/tests/integration/track_abort_over_session.rs b/rs/moq-net/tests/integration/track_abort_over_session.rs index 2a173063982..9d4911d425a 100644 --- a/rs/moq-net/tests/integration/track_abort_over_session.rs +++ b/rs/moq-net/tests/integration/track_abort_over_session.rs @@ -92,14 +92,14 @@ async fn recreate(finish: bool) { let track = broadcast.broadcast().create_track("video", timed()).unwrap(); let remote = origin.consume().request("bench", None).await.unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); - let mut open = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); + let mut open = track.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); open.write_frame(open.at_start(), b"head".as_ref()).unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.start, 2); group.read_frame().await.unwrap().unwrap(); track.abort(moq_net::Error::Cancel).unwrap(); let fresh = broadcast.broadcast().create_track("video", timed()).unwrap(); - let mut next = fresh.create_group(moq_net::group::Info { start: 3 }).unwrap(); + let mut next = fresh.create_group(moq_net::group::Info { start: 3 }).unwrap().unwrap(); next.write_frame(Timestamp::from_millis(1).unwrap(), b"next".as_ref()) .unwrap(); drop(open); diff --git a/rs/moq-net/tests/integration/warm_backfill.rs b/rs/moq-net/tests/integration/warm_backfill.rs index 4aaaf4b9787..6f338261d33 100644 --- a/rs/moq-net/tests/integration/warm_backfill.rs +++ b/rs/moq-net/tests/integration/warm_backfill.rs @@ -82,7 +82,7 @@ async fn a_newcomer_on_a_warm_relay_gets_the_backfill() { ) .unwrap(); for key in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); @@ -116,7 +116,7 @@ async fn a_refused_transport_backfill_keeps_delivering_live() { .create_track("video", Info::default().with_timescale(Timescale::MILLI)) .unwrap(); for key in 0..GROUPS { - let mut group = source.create_group(key.into()).unwrap(); + let mut group = source.create_group(key.into()).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); @@ -126,7 +126,7 @@ async fn a_refused_transport_backfill_keeps_delivering_live() { let mut subscriber = kio::clock::timeout(TIMEOUT, subscribe(&relay)).await.unwrap(); let got = kio::clock::timeout(TIMEOUT, received(&mut subscriber)).await.unwrap(); assert_eq!(got, BTreeSet::from([GROUPS - 1]), "{version}: only the live edge"); - let mut group = source.create_group(GROUPS.into()).unwrap(); + let mut group = source.create_group(GROUPS.into()).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(GROUPS * 1000).unwrap(), &b"live"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/wide_key.rs b/rs/moq-net/tests/integration/wide_key.rs index 3b0ca165d1b..72b1dbabc58 100644 --- a/rs/moq-net/tests/integration/wide_key.rs +++ b/rs/moq-net/tests/integration/wide_key.rs @@ -59,7 +59,7 @@ async fn largest_quic_key_reaches_the_subscriber() { true => Timestamp::unscaled(key), false => Timestamp::from_micros(key.min((1 << 61) - 1)).unwrap(), }; - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group.write_frame(timestamp, b"ladder".as_ref()).unwrap(); group.finish().unwrap(); let mut got = kio::clock::timeout(Duration::from_secs(5), sub.recv_group()) @@ -115,7 +115,7 @@ async fn wide_key_fails_only_its_subscription() { let wide = broadcast.broadcast().create_track("wide", timed()).unwrap(); let narrow = broadcast.broadcast().create_track("narrow", timed()).unwrap(); broadcast.announce().unwrap(); - let mut group = wide.create_group(moq_net::group::Info { start: WIDE }).unwrap(); + let mut group = wide.create_group(moq_net::group::Info { start: WIDE }).unwrap().unwrap(); group.write_frame(latest(), b"wide".as_ref()).unwrap(); let mut group = narrow.append_next().unwrap(); group.write_frame(Timestamp::ZERO, b"narrow".as_ref()).unwrap(); @@ -212,7 +212,7 @@ async fn a_later_wide_group_fails_only_that_subscription() { assert_eq!(group.start, 0); assert_eq!(group.read_frame().await.unwrap().unwrap().payload, b"first".as_ref()); - let mut group = wide.create_group(moq_net::group::Info { start: WIDE }).unwrap(); + let mut group = wide.create_group(moq_net::group::Info { start: WIDE }).unwrap().unwrap(); group.write_frame(latest(), b"wide".as_ref()).unwrap(); let result = kio::clock::timeout(Duration::from_secs(5), sub.recv_group()) diff --git a/rs/moq-net/tests/integration/widened_max_age.rs b/rs/moq-net/tests/integration/widened_max_age.rs index f3917f4f0b9..b065eaf6366 100644 --- a/rs/moq-net/tests/integration/widened_max_age.rs +++ b/rs/moq-net/tests/integration/widened_max_age.rs @@ -94,7 +94,7 @@ impl Chain { fn populate(&self) { for key in 0..GROUPS { - let mut group = self.source.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = self.source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); @@ -314,7 +314,7 @@ async fn wider_newcomers_after_the_first_pull_nothing_upstream() { .unwrap(); let source = broadcast.broadcast().create_track("video", timed()).unwrap(); for key in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); @@ -375,7 +375,7 @@ async fn a_legacy_viewer_beating_a_relay_copy_joins_at_the_live_edge() { let source = route.broadcast().create_track("video", timed()).unwrap(); route.announce().unwrap(); for key in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap(); + let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); diff --git a/rs/moq-relay/tests/integration/connection.rs b/rs/moq-relay/tests/integration/connection.rs index 8f18e54fb88..0b5c441a3f6 100644 --- a/rs/moq-relay/tests/integration/connection.rs +++ b/rs/moq-relay/tests/integration/connection.rs @@ -64,7 +64,7 @@ async fn largest_quic_sequence_reaches_the_subscriber() { true => moq_net::Timestamp::unscaled(sequence), false => moq_net::Timestamp::from_micros(sequence.min((1 << 61) - 1)).unwrap(), }; - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); group.write_frame(timestamp, b"ladder".as_ref()).unwrap(); group.finish().unwrap(); let mut got = kio::clock::timeout(TIMEOUT, sub.recv_group()) diff --git a/rs/moq-relay/tests/integration/quic_sim.rs b/rs/moq-relay/tests/integration/quic_sim.rs index f130593f1fc..ce82a012cc5 100644 --- a/rs/moq-relay/tests/integration/quic_sim.rs +++ b/rs/moq-relay/tests/integration/quic_sim.rs @@ -147,7 +147,7 @@ async fn deliver(network: &Network, publish: &Relay, subscribe: &Relay) -> Vec) { { let mut group = track .create_group(moq_net::group::Info { start: 0 }) + .unwrap() .expect("create group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"g0".as_ref()) @@ -1549,6 +1554,7 @@ async fn route_reannounce_test(version: Option<&str>) { { let mut group = track .create_group(moq_net::group::Info { start: 1 }) + .unwrap() .expect("create group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"g1".as_ref()) diff --git a/rs/moq-tokio/tests/integration/relay_fill.rs b/rs/moq-tokio/tests/integration/relay_fill.rs index 5c9cc78c940..27b98a074d7 100644 --- a/rs/moq-tokio/tests/integration/relay_fill.rs +++ b/rs/moq-tokio/tests/integration/relay_fill.rs @@ -167,7 +167,9 @@ async fn relay(version: Version) -> anyhow::Result<()> { ) .expect("a free name"); for sequence in 0..GROUPS { - let mut group = track.create_group(moq_net::group::Info { start: sequence })?; + let mut group = track + .create_group(moq_net::group::Info { start: sequence })? + .expect("a fresh group"); group.write_frame( Timestamp::from_millis(sequence * 1000)?, format!("group {sequence}").into_bytes(), diff --git a/rs/moq-tokio/tests/integration/sim.rs b/rs/moq-tokio/tests/integration/sim.rs index ea9462d381b..b2091d0cf75 100644 --- a/rs/moq-tokio/tests/integration/sim.rs +++ b/rs/moq-tokio/tests/integration/sim.rs @@ -213,7 +213,7 @@ async fn serve(network: &Network, version: Version, seed: u64) -> Arrivals { let mut source = source.clone(); while source.subscription_changed().await.unwrap().is_none() {} for sequence in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = source.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let timestamp = Timestamp::from_millis(sequence * INTERVAL.as_millis() as u64).unwrap(); group.write_frame(timestamp, vec![sequence as u8; FRAME]).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-tokio/tests/integration/sim_client.rs b/rs/moq-tokio/tests/integration/sim_client.rs index d8f4c53e28d..9e7fb6a2e75 100644 --- a/rs/moq-tokio/tests/integration/sim_client.rs +++ b/rs/moq-tokio/tests/integration/sim_client.rs @@ -272,7 +272,7 @@ impl Publisher { let mut source = self.track.clone(); while source.subscription_changed().await.unwrap().is_none() {} for sequence in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = source.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let timestamp = Timestamp::from_millis(sequence * INTERVAL.as_millis() as u64).unwrap(); group.write_frame(timestamp, vec![sequence as u8; FRAME]).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-transcode/src/lib.rs b/rs/moq-transcode/src/lib.rs index 80e6fa68502..3bd4ee70114 100644 --- a/rs/moq-transcode/src/lib.rs +++ b/rs/moq-transcode/src/lib.rs @@ -497,7 +497,7 @@ mod tests { for sequence in 0..groups { let start = key(sequence, sequence * frames * 33_333); - let mut group = track.create_group(start.into()).unwrap(); + let mut group = track.create_group(start.into()).unwrap().unwrap(); for index in 0..frames { let timestamp = (sequence * frames + index) * 33_333; if index == 0 { @@ -570,7 +570,7 @@ mod tests { .unwrap(); let gray = vec![0x80u8; 320 * 240 * 4]; for sequence in 0..3 { - let mut group = source._track.create_group(sequence.into()).unwrap(); + let mut group = source._track.create_group(sequence.into()).unwrap().unwrap(); encoder.cut().unwrap(); let timestamps: Vec<_> = (0..5).map(|index| (sequence * 5 + index) * 33_333).collect(); for ×tamp in ×tamps { @@ -974,7 +974,7 @@ mod tests { let source_fetches = source._track.requests(); // The live edge, left open: a live encode that opened its copy would hold the session // until it ends, which it never does here. - let mut live = source._track.create_group(9u64.into()).unwrap(); + let mut live = source._track.create_group(9u64.into()).unwrap().unwrap(); write_keyframe(&mut live); let config = Config { @@ -1457,7 +1457,7 @@ mod tests { #[tokio::test] async fn retirement_rides_out_an_open_live_group() { let mut source = source_catalog(320, 240); - let mut group = source._track.create_group(0u64.into()).unwrap(); + let mut group = source._track.create_group(0u64.into()).unwrap().unwrap(); write_keyframe(&mut group); let config = Config { @@ -1681,7 +1681,7 @@ mod tests { /// A fetch dropped before its group is encoded never opens that encode, and /// the request goes with it. A later fetch of the same group is a new /// request: the abandoned one must not still be encoding into the cache, - /// where this accept would come back `Duplicate`. + /// where this accept would come back `None`. #[tokio::test] async fn an_abandoned_fetch_encodes_nothing() { let source = source_catalog(320, 240); @@ -1782,7 +1782,7 @@ mod tests { let _source_fetches = source._track.requests(); // Two frames, so the output's largest moves once both are encoded. - let mut group = source._track.create_group(0u64.into()).unwrap(); + let mut group = source._track.create_group(0u64.into()).unwrap().unwrap(); let mut encoder = moq_video::encode::Encoder::new(&{ let mut config = moq_video::encode::Config::new(320, 240, moq_video::FrameRate::new(30, 1).unwrap()); config.kind = moq_video::encode::Kind::Software; @@ -1892,7 +1892,7 @@ mod tests { } } }; - let mut group = source._track.create_group(0u64.into()).unwrap(); + let mut group = source._track.create_group(0u64.into()).unwrap().unwrap(); write(&mut group, &[0, 33_333]); let config = Config { @@ -1931,7 +1931,7 @@ mod tests { // Queue the next source group first, so it is waiting for the live // path by the time it sees the demand go. - let mut next = source._track.create_group(1u64.into()).unwrap(); + let mut next = source._track.create_group(1u64.into()).unwrap().unwrap(); write(&mut next, &[66_666]); drop(fetching); @@ -2032,7 +2032,7 @@ mod tests { assert!(asked.delay.max.is_some(), "the feed asks for its publisher's history"); // The live path opens output group 0 on the source's first frame. - let mut lost = source._track.create_group(0u64.into()).unwrap(); + let mut lost = source._track.create_group(0u64.into()).unwrap().unwrap(); write(&mut lost, &[0, 33_333]); let rung = consumer.track("video/120p").unwrap(); let mut edge = rung.clone(); @@ -2050,7 +2050,7 @@ mod tests { assert!(partial.await.is_err(), "the lost group was finished short"); // The next group arrives whole. - let mut next = source._track.create_group(1u64.into()).unwrap(); + let mut next = source._track.create_group(1u64.into()).unwrap().unwrap(); write(&mut next, &[66_666, 99_999]); next.finish().unwrap(); @@ -2554,7 +2554,7 @@ mod tests { let transcoder = tokio::spawn(run(source.broadcast.consume(), output, config)); let mut rung = subscribe(&consumer, "video/120p").await; - let mut group = source._track.create_group(0u64.into()).unwrap(); + let mut group = source._track.create_group(0u64.into()).unwrap().unwrap(); write_keyframe(&mut group); group.finish().unwrap(); match finish { diff --git a/rs/moq-transcode/src/rung.rs b/rs/moq-transcode/src/rung.rs index 5c87ebf6aaf..b21189e8d75 100644 --- a/rs/moq-transcode/src/rung.rs +++ b/rs/moq-transcode/src/rung.rs @@ -476,28 +476,24 @@ async fn live(rung: &Rung, producer: &mut moq_net::track::Producer) -> Result Some(Writing(Some(output))), - // A fetch task is already serving this group (a consumer - // fetched a group at the live edge before the live loop - // reached it). The fetch is authoritative and its group - // reaches every subscriber through the shared track cache, - // so skip it here. Residual: if that fetch then fails and - // aborts the group, this rung skips one GOP until the next - // keyframe. - // - // The two paths stay separate writers on purpose. This one - // rides the shared feed (one decoder for every rung) and keeps - // its encoder's rate control across groups; a fetch decodes one - // past group on its own, at whatever pace the source serves it, - // with a fresh codec pair. Folding the fetch into this loop - // would either stall the live edge behind a past group's decode - // or give up the shared decode, and the track cache already - // settles who writes a group: the first `create_group` or - // `accept` wins, and the other sees `Duplicate`. - Err(moq_net::Error::Duplicate) => None, - Err(err) => return Err(err.into()), - }; + // `None`: a fetch task is already serving this group (a consumer + // fetched a group at the live edge before the live loop + // reached it). The fetch is authoritative and its group + // reaches every subscriber through the shared track cache, + // so skip it here. Residual: if that fetch then fails and + // aborts the group, this rung skips one GOP until the next + // keyframe. + // + // The two paths stay separate writers on purpose. This one + // rides the shared feed (one decoder for every rung) and keeps + // its encoder's rate control across groups; a fetch decodes one + // past group on its own, at whatever pace the source serves it, + // with a fresh codec pair. Folding the fetch into this loop + // would either stall the live edge behind a past group's decode + // or give up the shared decode, and the track cache already + // settles who writes a group: the first `create_group` or + // `accept` wins, and the other gets `None`. + current = producer.create_group(info)?.map(|output| Writing(Some(output))); } Some(Item::Frame(frame)) => { // No open group: attached mid-group, skipped a duplicate, or @@ -1215,7 +1211,7 @@ mod tests { }; let mut reader = track.subscribe(ascending(7)); track.start_at(10).unwrap(); - let mut live = track.create_group(moq_net::group::Info { start: 10 }).unwrap(); + let mut live = track.create_group(moq_net::group::Info { start: 10 }).unwrap().unwrap(); live.write_frame(moq_net::Timestamp::from_millis(10).unwrap(), &b"x"[..]) .unwrap(); live.finish().unwrap(); @@ -1366,7 +1362,7 @@ mod tests { track.start_at(HOUR).unwrap(); track .create_group(moq_net::group::Info { start: HOUR }) - .unwrap() + .unwrap().unwrap() .finish() .unwrap(); let waiter = kio::Waiter::noop(); @@ -1436,7 +1432,7 @@ mod tests { .with_order(moq_net::track::Order::Ascending), ); track.start_at(10).unwrap(); - let mut live = track.create_group(moq_net::group::Info { start: 10 }).unwrap(); + let mut live = track.create_group(moq_net::group::Info { start: 10 }).unwrap().unwrap(); live.write_frame(moq_net::Timestamp::from_millis(10).unwrap(), &b"x"[..]) .unwrap(); live.finish().unwrap(); @@ -1659,7 +1655,7 @@ mod tests { let track = broadcast .create_track("video/120p", hang::container::track_info(hang::catalog::PRIORITY.video)) .unwrap(); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); let guard = active.attach(&active.rendition(&rung)); // The second frame cannot be expressed in the container's timescale, so it diff --git a/rs/moq-video/src/decode/consumer.rs b/rs/moq-video/src/decode/consumer.rs index ae1df6460c2..9ada9021dda 100644 --- a/rs/moq-video/src/decode/consumer.rs +++ b/rs/moq-video/src/decode/consumer.rs @@ -827,7 +827,7 @@ mod tests { .unwrap(); let wire = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Video); let write = |sequence, stamps: &[u64]| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let frames: Vec<_> = stamps .iter() .enumerate() @@ -986,7 +986,7 @@ mod tests { .unwrap(); let wire = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Video); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); let mut landed = std::collections::BTreeMap::new(); for (index, frame) in [0u64, 3, 1, 2].into_iter().enumerate() { landed.insert(frame, Instant::now()); @@ -1039,7 +1039,7 @@ mod tests { .unwrap(); let wire = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Video); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); let frames: Vec<_> = (0..FRAMES) .map(|index| moq_mux::container::Frame { timestamp: Timestamp::from_micros(index * 33_333).unwrap(), @@ -1243,7 +1243,7 @@ mod tests { .unwrap(); let wire = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Video); let write = |sequence, stamps: &[u64]| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); let frames: Vec<_> = stamps .iter() .enumerate() @@ -1530,7 +1530,7 @@ mod tests { landed.push(Instant::now()); let mut group = track .create_group(moq_net::group::Info { start: sequence as u64 }) - .unwrap(); + .unwrap().unwrap(); wire.write( &mut group, &[moq_mux::container::Frame { @@ -1585,7 +1585,7 @@ mod tests { .unwrap(); let wire = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Video); - let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); + let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); for keyframe in [true, false] { wire.write( &mut group, diff --git a/test/interop/clients/rust/control.rs b/test/interop/clients/rust/control.rs index 6428bdbf232..fb582ccab34 100644 --- a/test/interop/clients/rust/control.rs +++ b/test/interop/clients/rust/control.rs @@ -15,7 +15,9 @@ async fn main() -> anyhow::Result<()> { .broadcast() .create_track("video", moq_net::track::Info::default().with_priority(2)) .context("the track already exists")?; - let mut group = track.create_group(moq_net::group::Info { start: 4 })?; + let mut group = track + .create_group(moq_net::group::Info { start: 4 })? + .context("the group already exists")?; for byte in [1, 2] { group.write_frame(moq_net::Timestamp::unscaled(group.start), vec![byte])?; } From 55723f37c900d1a68d4354ceecf34342418798e5 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 21:29:17 -0800 Subject: [PATCH 3/8] chore: format, API report, and finish the create-group quest Co-Authored-By: Claude Opus 5.5 --- .../src/container/consumer.backlog.test.ts | 2 +- .../container/consumer.backpressure.test.ts | 2 +- js/hang/src/container/consumer.holes.test.ts | 2 +- .../container/consumer.nonsequential.test.ts | 2 +- .../src/container/consumer.ordered.test.ts | 2 +- .../src/container/consumer.outoforder.test.ts | 2 +- js/hang/src/container/consumer.skips.test.ts | 2 +- .../src/container/consumer.startup.test.ts | 2 +- js/hang/src/container/consumer.test.ts | 2 +- js/hang/src/container/consumer.warmup.test.ts | 2 +- js/net/api/index.api.md | 4 +- js/net/bench/drift.ts | 2 +- js/net/bench/track.ts | 2 +- js/net/src/cache.test.ts | 2 +- js/net/src/flate/group.test.ts | 2 +- js/net/src/group.test.ts | 2 +- js/net/src/lite/subscriber.test.ts | 2 +- js/net/src/net-cleanups.test.ts | 2 +- js/net/src/ordered.test.ts | 2 +- js/net/src/track.test.ts | 2 +- js/watch/src/audio/playout.test.ts | 2 +- quest/m2/outcome-enums/create-group.md | 23 -- quest/m3/error-matches.md | 3 +- rs/libmoq/src/consume.rs | 6 +- rs/libmoq/src/test.rs | 10 +- rs/moq-archive/src/consumer/tests.rs | 5 +- rs/moq-audio/src/decode/consumer.rs | 20 +- rs/moq-cli/src/archive.rs | 5 +- rs/moq-cli/src/play/video.rs | 6 +- rs/moq-e2ee/src/tests.rs | 18 +- rs/moq-e2ee/src/track.rs | 4 +- rs/moq-hls/src/export/mod.rs | 14 +- rs/moq-mux/src/container/consumer.rs | 53 +++- rs/moq-mux/src/container/source.rs | 25 +- rs/moq-mux/src/container/ts/export_test.rs | 23 +- rs/moq-net/benches/origin.rs | 5 +- rs/moq-net/benches/ranges.rs | 12 +- rs/moq-net/benches/tail.rs | 3 +- rs/moq-net/benches/track.rs | 20 +- rs/moq-net/src/ietf/publisher.rs | 21 +- rs/moq-net/src/ietf/subscriber.rs | 12 +- rs/moq-net/src/ietf/subscriber/tracks.rs | 5 +- rs/moq-net/src/lite/publisher.rs | 22 +- rs/moq-net/src/lite/subscriber.rs | 18 +- rs/moq-net/src/model/broadcast.rs | 3 +- rs/moq-net/src/model/origin.rs | 3 +- rs/moq-net/src/model/resume.rs | 9 +- rs/moq-net/src/model/track.rs | 257 ++++++++++++------ rs/moq-net/src/model/track/miss.rs | 39 ++- rs/moq-net/tests/integration/compress.rs | 6 +- rs/moq-net/tests/integration/drop_record.rs | 26 +- .../tests/integration/fetch_from_feed.rs | 6 +- rs/moq-net/tests/integration/fetch_only.rs | 5 +- rs/moq-net/tests/integration/group_order.rs | 5 +- .../tests/integration/late_lower_group.rs | 5 +- rs/moq-net/tests/integration/range_anchors.rs | 15 +- rs/moq-net/tests/integration/range_fill.rs | 23 +- .../tests/integration/range_union_fit.rs | 5 +- .../tests/integration/received_rewind.rs | 5 +- rs/moq-net/tests/integration/route_change.rs | 6 +- rs/moq-net/tests/integration/route_cluster.rs | 6 +- .../tests/integration/shared_copy_start.rs | 5 +- rs/moq-net/tests/integration/slow_joiner.rs | 5 +- rs/moq-net/tests/integration/stream_credit.rs | 5 +- .../tests/integration/subscribe_ranges.rs | 55 +++- rs/moq-net/tests/integration/warm_backfill.rs | 5 +- rs/moq-net/tests/integration/wide_key.rs | 15 +- .../tests/integration/widened_max_age.rs | 16 +- rs/moq-relay/tests/integration/connection.rs | 5 +- rs/moq-relay/tests/integration/quic_sim.rs | 5 +- rs/moq-tokio/tests/integration/sim.rs | 5 +- rs/moq-tokio/tests/integration/sim_client.rs | 5 +- rs/moq-transcode/src/rung.rs | 3 +- rs/moq-video/src/decode/consumer.rs | 13 +- 74 files changed, 682 insertions(+), 261 deletions(-) delete mode 100644 quest/m2/outcome-enums/create-group.md diff --git a/js/hang/src/container/consumer.backlog.test.ts b/js/hang/src/container/consumer.backlog.test.ts index 688256de818..35d1796c9f3 100644 --- a/js/hang/src/container/consumer.backlog.test.ts +++ b/js/hang/src/container/consumer.backlog.test.ts @@ -7,10 +7,10 @@ import { Duration, type Installed, Instant, now } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { Time, Track, Varint } from "@moq/net"; import { race } from "@moq/signals"; +import { defined } from "../defined.test-util.ts"; import { Consumer } from "./consumer.ts"; import { Jitter } from "./jitter.ts"; import { Format } from "./legacy.ts"; -import { defined } from "../defined.test-util.ts"; let clock: Manual; let installed: Installed; diff --git a/js/hang/src/container/consumer.backpressure.test.ts b/js/hang/src/container/consumer.backpressure.test.ts index f962bab2f45..41d599731af 100644 --- a/js/hang/src/container/consumer.backpressure.test.ts +++ b/js/hang/src/container/consumer.backpressure.test.ts @@ -2,10 +2,10 @@ import { expect, spyOn, test } from "bun:test"; import { Duration, Elapsed, Instant, timeout } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { Time, Track } from "@moq/net"; +import { defined } from "../defined.test-util.ts"; import { Consumer, type Read } from "./consumer.ts"; import { encodeFrame, Format } from "./legacy.ts"; import type { Frame } from "./types.ts"; -import { defined } from "../defined.test-util.ts"; // Counts decoded samples, so a test can tell how many the consumer holds ahead of its reads. class Counting extends Format { diff --git a/js/hang/src/container/consumer.holes.test.ts b/js/hang/src/container/consumer.holes.test.ts index af81f8edd15..33c0bf8bb47 100644 --- a/js/hang/src/container/consumer.holes.test.ts +++ b/js/hang/src/container/consumer.holes.test.ts @@ -3,9 +3,9 @@ import { Duration, now } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { Time, Track } from "@moq/net"; import { Signal } from "@moq/signals"; +import { defined } from "../defined.test-util.ts"; import { Consumer, type Read } from "./consumer.ts"; import { encodeFrame, Format } from "./legacy.ts"; -import { defined } from "../defined.test-util.ts"; const flush = () => new Promise((resolve) => setImmediate(resolve)); diff --git a/js/hang/src/container/consumer.nonsequential.test.ts b/js/hang/src/container/consumer.nonsequential.test.ts index 687bef43271..21d211746c7 100644 --- a/js/hang/src/container/consumer.nonsequential.test.ts +++ b/js/hang/src/container/consumer.nonsequential.test.ts @@ -3,9 +3,9 @@ import { Duration, type Installed } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { type Group, Time, Track, Varint } from "@moq/net"; import { AudioConfigSchema } from "../catalog/audio.ts"; +import { defined } from "../defined.test-util.ts"; import { Consumer } from "./consumer.ts"; import { Format as LegacyFormat } from "./legacy.ts"; -import { defined } from "../defined.test-util.ts"; // Standalone from consumer.test.ts so it only pulls the Legacy format, not the CMAF decoder. diff --git a/js/hang/src/container/consumer.ordered.test.ts b/js/hang/src/container/consumer.ordered.test.ts index 1239a201912..d2625a01877 100644 --- a/js/hang/src/container/consumer.ordered.test.ts +++ b/js/hang/src/container/consumer.ordered.test.ts @@ -5,9 +5,9 @@ import { Duration } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { Time, Track } from "@moq/net"; import { u53 } from "../catalog/integers.ts"; +import { defined } from "../defined.test-util.ts"; import { Consumer, type Read } from "./consumer.ts"; import { encodeFrame, Format } from "./legacy.ts"; -import { defined } from "../defined.test-util.ts"; const flush = () => new Promise((resolve) => setImmediate(resolve)); diff --git a/js/hang/src/container/consumer.outoforder.test.ts b/js/hang/src/container/consumer.outoforder.test.ts index bc1cde7ff6f..6159c189829 100644 --- a/js/hang/src/container/consumer.outoforder.test.ts +++ b/js/hang/src/container/consumer.outoforder.test.ts @@ -2,9 +2,9 @@ import { afterEach, beforeEach, expect, test } from "bun:test"; import { Duration, type Installed } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { type Group, Time, Track, Varint } from "@moq/net"; +import { defined } from "../defined.test-util.ts"; import { Consumer } from "./consumer.ts"; import { Format as LegacyFormat } from "./legacy.ts"; -import { defined } from "../defined.test-util.ts"; // Standalone from consumer.test.ts so it only pulls the Legacy format, not the CMAF decoder. diff --git a/js/hang/src/container/consumer.skips.test.ts b/js/hang/src/container/consumer.skips.test.ts index 4b1ef4b737f..ce7f54651a2 100644 --- a/js/hang/src/container/consumer.skips.test.ts +++ b/js/hang/src/container/consumer.skips.test.ts @@ -2,9 +2,9 @@ import { expect, spyOn, test } from "bun:test"; import { Duration } from "@moq/clock"; import { Time, Track, Varint } from "@moq/net"; import { Signal } from "@moq/signals"; +import { defined } from "../defined.test-util.ts"; import { Consumer } from "./consumer.ts"; import { Format } from "./legacy.ts"; -import { defined } from "../defined.test-util.ts"; const flush = () => new Promise((resolve) => setImmediate(resolve)); diff --git a/js/hang/src/container/consumer.startup.test.ts b/js/hang/src/container/consumer.startup.test.ts index 091edb9d3d9..0efa9061780 100644 --- a/js/hang/src/container/consumer.startup.test.ts +++ b/js/hang/src/container/consumer.startup.test.ts @@ -2,9 +2,9 @@ import { expect, onTestFinished, spyOn, test } from "bun:test"; import { Duration } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { type Group, Error as NetError, StreamCode, Time, Track } from "@moq/net"; +import { defined } from "../defined.test-util.ts"; import { Consumer, type Read } from "./consumer.ts"; import { encodeFrame, Format } from "./legacy.ts"; -import { defined } from "../defined.test-util.ts"; function setup(maxDelay = 100) { const clock = new Manual(); diff --git a/js/hang/src/container/consumer.test.ts b/js/hang/src/container/consumer.test.ts index 7b9836e4a66..3706906e016 100644 --- a/js/hang/src/container/consumer.test.ts +++ b/js/hang/src/container/consumer.test.ts @@ -6,11 +6,11 @@ import { Format as LocFormat } from "@moq/loc"; import { type Group, Error as NetError, SessionCode, StreamCode, Time, Track, Varint } from "@moq/net"; import { decodeInitSegment, type InitSegment } from "../cmaf/decode.ts"; import { Format as CmafFormat } from "../cmaf/format.ts"; +import { defined } from "../defined.test-util.ts"; import { Consumer, type Read } from "./consumer.ts"; import type { Format as ContainerFormat } from "./format.ts"; import { Format as LegacyFormat, Producer as LegacyProducer } from "./legacy.ts"; import type { Frame } from "./types.ts"; -import { defined } from "../defined.test-util.ts"; const FIXTURES = JSON.parse(readFileSync(new URL("../cmaf/fixtures.json", import.meta.url), "utf8")); function fragment(name: string): Uint8Array { diff --git a/js/hang/src/container/consumer.warmup.test.ts b/js/hang/src/container/consumer.warmup.test.ts index cdc9738aa99..25f13cf7328 100644 --- a/js/hang/src/container/consumer.warmup.test.ts +++ b/js/hang/src/container/consumer.warmup.test.ts @@ -2,9 +2,9 @@ import { expect, onTestFinished, spyOn, test } from "bun:test"; import { Duration } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { type Group, Time, Track } from "@moq/net"; +import { defined } from "../defined.test-util.ts"; import { Consumer, type Read } from "./consumer.ts"; import { encodeFrame, Format } from "./legacy.ts"; -import { defined } from "../defined.test-util.ts"; const BUDGET = 500; diff --git a/js/net/api/index.api.md b/js/net/api/index.api.md index 096ceaada06..873c85210ae 100644 --- a/js/net/api/index.api.md +++ b/js/net/api/index.api.md @@ -726,7 +726,7 @@ export namespace Track { abort(error: Error): void; close(): void; readonly closed: Signals.GetPromise; - createGroup(key: bigint): Group.Producer; + createGroup(key: bigint): Group.Producer | undefined; info(): Promise; readonly name: string; requests(): Track.Requests; @@ -795,7 +795,7 @@ export namespace Track { appendGroup(start: Time.Timestamp): Group.Producer; close(): void; get closed(): Signals.GetPromise; - createGroup(key: bigint): Group.Producer; + createGroup(key: bigint): Group.Producer | undefined; demand(): Track.Demand; fail(error: Error): Track.Finished; finish(): Track.Finished; diff --git a/js/net/bench/drift.ts b/js/net/bench/drift.ts index 9db1427db29..798ccbc9152 100644 --- a/js/net/bench/drift.ts +++ b/js/net/bench/drift.ts @@ -2,8 +2,8 @@ import { Duration } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { type Group, Time, Track } from "@moq/net"; -import { hooks } from "../src/internal.ts"; import { defined } from "../src/defined.test-util.ts"; +import { hooks } from "../src/internal.ts"; /** Read live frames after a retained window, checking every delivered payload. */ export async function run(): Promise { diff --git a/js/net/bench/track.ts b/js/net/bench/track.ts index bebc8e13ef8..b0e2a1751dc 100644 --- a/js/net/bench/track.ts +++ b/js/net/bench/track.ts @@ -2,11 +2,11 @@ import { Duration } from "@moq/clock"; import { DEFAULT_EXPIRY } from "../src/cache.ts"; +import { defined } from "../src/defined.test-util.ts"; import type { Consumer as GroupConsumer, Producer as GroupProducer } from "../src/group.ts"; import { Timescale, Timestamp } from "../src/time.ts"; import { Producer, type Subscriber } from "../src/track.ts"; import { GivenUp } from "../src/util/given_up.ts"; -import { defined } from "../src/defined.test-util.ts"; const retainedCounts = [25, 100, 400, 1500]; const subscriberCounts = [1, 4, 16]; diff --git a/js/net/src/cache.test.ts b/js/net/src/cache.test.ts index 6eea6e2d09b..e02475c305b 100644 --- a/js/net/src/cache.test.ts +++ b/js/net/src/cache.test.ts @@ -2,12 +2,12 @@ import { expect, test } from "bun:test"; import { Duration, yieldNow } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import * as cache from "./cache.ts"; +import { defined } from "./defined.test-util.ts"; import { StreamCode, StreamError, TooFarBehind } from "./error.ts"; import { hooks, staleHole } from "./internal.ts"; import { groupsOf } from "./mock.ts"; import { Timestamp } from "./time.ts"; import { Producer as TrackProducer } from "./track.ts"; -import { defined } from "./defined.test-util.ts"; // Run `fn` on a manual clock, stepped in milliseconds. async function withClock(fn: (clock: { advance: (ms: number) => Promise }) => Promise | void) { diff --git a/js/net/src/flate/group.test.ts b/js/net/src/flate/group.test.ts index ce0f5603853..6738c5773d1 100644 --- a/js/net/src/flate/group.test.ts +++ b/js/net/src/flate/group.test.ts @@ -1,4 +1,5 @@ import { expect, spyOn, test } from "bun:test"; +import { defined } from "../defined.test-util.ts"; import { StreamCode } from "../error.ts"; import { Producer as Group } from "../group.ts"; import { hooks } from "../internal.ts"; @@ -7,7 +8,6 @@ import { Producer as Track } from "../track.ts"; import { Decoder } from "./decoder.ts"; import { Encoder } from "./encoder.ts"; import { encodable } from "./group.ts"; -import { defined } from "../defined.test-util.ts"; const payload = new TextEncoder().encode("one shared compression window ".repeat(100)); diff --git a/js/net/src/group.test.ts b/js/net/src/group.test.ts index 09ab7958cce..d21a70249a7 100644 --- a/js/net/src/group.test.ts +++ b/js/net/src/group.test.ts @@ -2,6 +2,7 @@ import { expect, test } from "bun:test"; import { Duration, yieldNow } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { Signal } from "@moq/signals"; +import { defined } from "./defined.test-util.ts"; import { FrameTooLarge, StreamCode, StreamError } from "./error.ts"; import { encodable } from "./flate/group.ts"; import { Producer } from "./group.ts"; @@ -9,7 +10,6 @@ import { hooks, type Replacement } from "./internal.ts"; import { textFrame } from "./mock.ts"; import { Timestamp } from "./time.ts"; import { Producer as TrackProducer } from "./track.ts"; -import { defined } from "./defined.test-util.ts"; const dec = new TextDecoder(); diff --git a/js/net/src/lite/subscriber.test.ts b/js/net/src/lite/subscriber.test.ts index 95928a8868e..73f2d0cb94a 100644 --- a/js/net/src/lite/subscriber.test.ts +++ b/js/net/src/lite/subscriber.test.ts @@ -7,6 +7,7 @@ import type { Grant } from "../auth.ts"; import type { AuthSession } from "../auth_session.ts"; import { Viewers } from "../bandwidth.ts"; import type { Probe as ProbeStats } from "../connection/stats.ts"; +import { defined } from "../defined.test-util.ts"; import { error, fromTransport, @@ -63,7 +64,6 @@ import { import { Minted, Subscriber } from "./subscriber.ts"; import { Track, TrackInfo } from "./track.ts"; import { hasLengthFirst, Version, versionName } from "./version.ts"; -import { defined } from "../defined.test-util.ts"; test("closing the subscriber suppresses probe stream warnings", async () => { let readable!: ReadableStreamDefaultController; diff --git a/js/net/src/net-cleanups.test.ts b/js/net/src/net-cleanups.test.ts index cd6d3ff2b6f..d809f339c49 100644 --- a/js/net/src/net-cleanups.test.ts +++ b/js/net/src/net-cleanups.test.ts @@ -3,6 +3,7 @@ import { Duration } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { accept } from "./connection/accept.ts"; import { connect } from "./connection/connect.ts"; +import { defined } from "./defined.test-util.ts"; import { ConnectTimeout } from "./error.ts"; import { Producer as GroupProducer } from "./group.ts"; import { Connection as LiteConnection } from "./lite/connection.ts"; @@ -10,7 +11,6 @@ import { ALPN_03, ALPN_04, Version } from "./lite/version.ts"; import { createMockTransportPair } from "./mock.ts"; import { Timestamp } from "./time.ts"; import { Producer as TrackProducer } from "./track.ts"; -import { defined } from "./defined.test-util.ts"; test("group read handles independently replay buffered and future frames", async () => { const group = new GroupProducer(0n); diff --git a/js/net/src/ordered.test.ts b/js/net/src/ordered.test.ts index 41899056591..87616e826b7 100644 --- a/js/net/src/ordered.test.ts +++ b/js/net/src/ordered.test.ts @@ -3,12 +3,12 @@ import { expect, test } from "bun:test"; import { Duration, sleep } from "@moq/clock"; import { Manual } from "@moq/clock/test"; +import { defined } from "./defined.test-util.ts"; import { StreamCode, StreamError } from "./error.ts"; import { hooks, staleHole } from "./internal.ts"; import { textFrame } from "./mock.ts"; import { Timestamp } from "./time.ts"; import { type Ordered, Producer as TrackProducer } from "./track.ts"; -import { defined } from "./defined.test-util.ts"; // A session-fed copy owes holes; an in-process producer does not. function receivedTrack() { diff --git a/js/net/src/track.test.ts b/js/net/src/track.test.ts index 7b1f52140ad..9f13058b104 100644 --- a/js/net/src/track.test.ts +++ b/js/net/src/track.test.ts @@ -3,6 +3,7 @@ import { Duration, Instant, Wall, yieldNow } from "@moq/clock"; import { Manual } from "@moq/clock/test"; import { race } from "@moq/signals"; import { DEFAULT_EXPIRY } from "./cache.ts"; +import { defined } from "./defined.test-util.ts"; import { ProtocolViolation, Skipped, StreamCode, StreamError, TimestampMismatch, TooFarBehind } from "./error.ts"; import type { Consumer as GroupConsumer, Producer as GroupProducer } from "./group.ts"; import { Version as IetfVersion } from "./ietf/version.ts"; @@ -21,7 +22,6 @@ import { } from "./track.ts"; import { unwanted } from "./util/demand.ts"; import { LIVE, rangesStart, union } from "./window.ts"; -import { defined } from "./defined.test-util.ts"; const enc = new TextEncoder(); const dec = new TextDecoder(); diff --git a/js/watch/src/audio/playout.test.ts b/js/watch/src/audio/playout.test.ts index b68cbeafa2c..10eaa9aea9a 100644 --- a/js/watch/src/audio/playout.test.ts +++ b/js/watch/src/audio/playout.test.ts @@ -4,10 +4,10 @@ import { Manual } from "@moq/clock/test"; import * as Container from "@moq/hang/container"; import { Time, Track, Varint } from "@moq/net"; import { Signal } from "@moq/signals"; +import { defined } from "../defined.test-util.ts"; import { STRETCH } from "../sync"; import { maxDelay, target } from "./latency"; import { AudioRingBuffer } from "./ring-buffer"; -import { defined } from "../defined.test-util.ts"; // Replay recorded-shape arrival traces through the ring and count what a listener would hear: // quanta rendered short (an underrun) and samples the ring threw away (a skip). The ring is sized diff --git a/quest/m2/outcome-enums/create-group.md b/quest/m2/outcome-enums/create-group.md deleted file mode 100644 index a70096ebdeb..00000000000 --- a/quest/m2/outcome-enums/create-group.md +++ /dev/null @@ -1,23 +0,0 @@ -# [M] A held group start is a value, not an error - -## Goal - -`moq_net::track::Producer::create_group` reports a start another live group -already holds as a value (`Result>`), as the fill -`accept`s do, not `Err(Error::Duplicate)`, so moq-transcode's rung and the -ietf subscriber's `open_fill_group` stop matching it. js/net's `createGroup`, -which throws `duplicate group`, returns `undefined` the same way. - -## Plan - -Found by [small-public](https://github.com/moq-dev/moq/pull/9150), which -reshaped `create_track` and the fill `accept`s but left `create_group` out of -its Goal. The matches to remove: `rs/moq-transcode/src/rung.rs` (the live -path and a fetch racing to write one group) and `rs/moq-net/src/ietf/subscriber.rs` -(`open_fill_group`, a widened fetch range refilling a group the copy owns). -Most callers create a fresh start and unwrap, so the migration is mostly -mechanical; the recommendation is `Result>`, matching the fill -`accept`s. - -Public API: breaking in moq-net (`create_group`) and js/net (`createGroup`). -Wire: none. diff --git a/quest/m3/error-matches.md b/quest/m3/error-matches.md index 7ff03e68cec..0d130fdd95f 100644 --- a/quest/m3/error-matches.md +++ b/quest/m3/error-matches.md @@ -56,7 +56,8 @@ Not here: moq-lite's control streams ([control-stream-recv](/quest/m3/control-stream-recv.md)), the moq-json stream producer and moqsink ([error-outcomes-rest](/quest/m3/error-outcomes-rest.md)), moq-quic's stream errors (reshaped in -[moq-dev/moq#9152](https://github.com/moq-dev/moq/pull/9152)), `Duplicate` ([create-group](/quest/m2/outcome-enums/create-group.md)), and +[moq-dev/moq#9152](https://github.com/moq-dev/moq/pull/9152)), `create_group`'s `Duplicate` (a value since +[moq-dev/moq#9223](https://github.com/moq-dev/moq/pull/9223)), and moq-e2ee ([e2ee-format](/quest/m3/e2ee-format.md)). Public API: none expected, except a moq-net clean end becoming `Ok(None)`, diff --git a/rs/libmoq/src/consume.rs b/rs/libmoq/src/consume.rs index 6d97bd68b4e..57ef43b1e75 100644 --- a/rs/libmoq/src/consume.rs +++ b/rs/libmoq/src/consume.rs @@ -1658,7 +1658,11 @@ mod tests { } fn write(&mut self, start: u64, micros: u64) { - let mut group = self.track.create_group(moq_net::group::Info { start }).unwrap().unwrap(); + let mut group = self + .track + .create_group(moq_net::group::Info { start }) + .unwrap() + .unwrap(); hang::container::Frame { timestamp: moq_net::Timestamp::from_micros(micros).unwrap(), payload: bytes::Bytes::from_static(b"frame"), diff --git a/rs/libmoq/src/test.rs b/rs/libmoq/src/test.rs index eabe4ba3991..4fd8f609702 100644 --- a/rs/libmoq/src/test.rs +++ b/rs/libmoq/src/test.rs @@ -5429,7 +5429,10 @@ fn a_group_request_nobody_reads_is_withdrawn() { let producer = state.publish.track_producer(Id::try_from(track).unwrap()).unwrap(); let reader = producer.subscribe(ascending(7, None)); producer.start_at(10).unwrap(); - let mut group = producer.create_group(moq_net::group::Info { start: 10 }).unwrap().unwrap(); + let mut group = producer + .create_group(moq_net::group::Info { start: 10 }) + .unwrap() + .unwrap(); group .write_frame(moq_net::Timestamp::from_millis(10).unwrap(), &b"live"[..]) .unwrap(); @@ -5474,7 +5477,10 @@ fn a_rejected_group_request_binds_only_its_readers() { let mut state = State::lock(); let producer = state.publish.track_producer(Id::try_from(track).unwrap()).unwrap(); producer.start_at(10).unwrap(); - let mut group = producer.create_group(moq_net::group::Info { start: 10 }).unwrap().unwrap(); + let mut group = producer + .create_group(moq_net::group::Info { start: 10 }) + .unwrap() + .unwrap(); group .write_frame(moq_net::Timestamp::from_millis(10).unwrap(), &b"live"[..]) .unwrap(); diff --git a/rs/moq-archive/src/consumer/tests.rs b/rs/moq-archive/src/consumer/tests.rs index 5a4c4994e37..524086ca96c 100644 --- a/rs/moq-archive/src/consumer/tests.rs +++ b/rs/moq-archive/src/consumer/tests.rs @@ -1136,7 +1136,10 @@ async fn a_reader_follows_a_real_dvr_through_its_rotations() { sleep(Duration::from_millis(1)).await; } let write = |sequence: u64| { - let mut group = video.create_group(group::Info { start: sequence * 1000 }).unwrap().unwrap(); + let mut group = video + .create_group(group::Info { start: sequence * 1000 }) + .unwrap() + .unwrap(); let pts = Timestamp::from_millis(sequence * 1000).unwrap(); group.write_frame(pts, Bytes::from(format!("{sequence}"))).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-audio/src/decode/consumer.rs b/rs/moq-audio/src/decode/consumer.rs index f07e85c2653..3d59c75382a 100644 --- a/rs/moq-audio/src/decode/consumer.rs +++ b/rs/moq-audio/src/decode/consumer.rs @@ -2966,7 +2966,10 @@ mod tests { let start = kio::clock::now(); for &(at, sequence, media) in events { tokio::time::advance(Duration::from_millis(at).saturating_sub(start.elapsed())).await; - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let frame = moq_mux::container::Frame { timestamp: Timestamp::from_micros(media * 1000).unwrap(), duration: None, @@ -3074,7 +3077,10 @@ mod tests { let container = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Audio); let payload: Bytes = vec![0u8; 160 * size_of::()].into(); let write = |sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let frame = moq_mux::container::Frame { timestamp: Timestamp::from_micros(sequence * 20_000).unwrap(), duration: None, @@ -3132,7 +3138,10 @@ mod tests { let container = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Audio); let payload: Bytes = vec![0u8; 160 * size_of::()].into(); let write = |sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let frame = moq_mux::container::Frame { timestamp: Timestamp::from_micros(sequence * 20_000).unwrap(), duration: None, @@ -3190,7 +3199,10 @@ mod tests { let container = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Audio); let payload: Bytes = vec![0u8; 160 * size_of::()].into(); let write = |sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let frame = moq_mux::container::Frame { timestamp: Timestamp::from_micros(sequence * 20_000).unwrap(), duration: None, diff --git a/rs/moq-cli/src/archive.rs b/rs/moq-cli/src/archive.rs index 888527aa083..9a38943b447 100644 --- a/rs/moq-cli/src/archive.rs +++ b/rs/moq-cli/src/archive.rs @@ -629,7 +629,10 @@ mod tests { .with_max_age(None); let video = source.create_track("video", info).unwrap(); for sequence in 0..2 { - let mut group = video.create_group(group::Info { start: sequence * 1000 }).unwrap().unwrap(); + let mut group = video + .create_group(group::Info { start: sequence * 1000 }) + .unwrap() + .unwrap(); let pts = Timestamp::from_millis(sequence * 1000).unwrap(); group.write_frame(pts, format!("frame {sequence}")).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-cli/src/play/video.rs b/rs/moq-cli/src/play/video.rs index fc8bed60e83..8776bd9919d 100644 --- a/rs/moq-cli/src/play/video.rs +++ b/rs/moq-cli/src/play/video.rs @@ -864,7 +864,8 @@ mod tests { let write = |sequence, stamps: Vec| { let mut group = published .create_group(moq_net::group::Info { start: sequence }) - .unwrap().unwrap(); + .unwrap() + .unwrap(); let frames: Vec<_> = stamps .into_iter() .enumerate() @@ -1303,7 +1304,8 @@ mod tests { let write = |sequence: u64| { let mut group = published .create_group(moq_net::group::Info { start: sequence }) - .unwrap().unwrap(); + .unwrap() + .unwrap(); format().write(&mut group, &[frame(sequence * 100, true)]).unwrap(); group.finish().unwrap(); }; diff --git a/rs/moq-e2ee/src/tests.rs b/rs/moq-e2ee/src/tests.rs index b2571b19b03..919665ed9e6 100644 --- a/rs/moq-e2ee/src/tests.rs +++ b/rs/moq-e2ee/src/tests.rs @@ -1240,7 +1240,11 @@ fn grouped_authentication_ends_track() { let mut key = pair.generation.key(semantic, Domain::Group).unwrap(); let mut payload = key.protect(1, 0, b"ok", MAX_GROUPED_PAYLOAD).unwrap().to_vec(); payload[0] ^= 1; - let mut bad = pair.net.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); + let mut bad = pair + .net + .create_group(moq_net::group::Info { start: 1 }) + .unwrap() + .unwrap(); bad.write_frame(ms(2), payload).unwrap(); bad.finish().unwrap(); @@ -1307,14 +1311,22 @@ fn grouped_failure_wakes_pending_reads_and_releases_demand() { // One authentic frame, then silence. The group and the track stay open. let semantic = pair.semantic.as_str(); let mut key = pair.generation.key(semantic, Domain::Group).unwrap(); - let mut open = pair.net.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); + let mut open = pair + .net + .create_group(moq_net::group::Info { start: 0 }) + .unwrap() + .unwrap(); let open_demand = open.demand(); open.write_frame(ms(1), key.protect(0, 0, b"ok", MAX_GROUPED_PAYLOAD).unwrap()) .unwrap(); let mut payload = key.protect(1, 0, b"nope", MAX_GROUPED_PAYLOAD).unwrap().to_vec(); payload[0] ^= 1; - let mut bad = pair.net.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); + let mut bad = pair + .net + .create_group(moq_net::group::Info { start: 1 }) + .unwrap() + .unwrap(); let bad_demand = bad.demand(); bad.write_frame(ms(2), payload).unwrap(); diff --git a/rs/moq-e2ee/src/track.rs b/rs/moq-e2ee/src/track.rs index 7ee09761b08..f239c560217 100644 --- a/rs/moq-e2ee/src/track.rs +++ b/rs/moq-e2ee/src/track.rs @@ -61,7 +61,9 @@ impl Producer { /// holds it, [`Error::Identity`](crate::Error::Identity) if it exceeds `2^53-1`, or a net error. pub fn create_group(&mut self, start: u64) -> Result { let (_, inner) = self.claim.allocate(Some(start), |start| { - self.inner.create_group(moq_net::group::Info { start })?.ok_or(crate::Error::Reuse) + self.inner + .create_group(moq_net::group::Info { start })? + .ok_or(crate::Error::Reuse) })?; Ok(self.group(inner)) } diff --git a/rs/moq-hls/src/export/mod.rs b/rs/moq-hls/src/export/mod.rs index 3b665fab0fd..5e2da03cec5 100644 --- a/rs/moq-hls/src/export/mod.rs +++ b/rs/moq-hls/src/export/mod.rs @@ -3630,7 +3630,8 @@ mod tests { let mut group = self .track .create_group(moq_net::group::Info { start: sequence }) - .unwrap().unwrap(); + .unwrap() + .unwrap(); for index in 0..frames.max(1) { let micros = (pts_ms + index * INTERVAL.as_millis() as u64 / 10) * 1_000; let frame = vp8_frame(micros, index == 0); @@ -3655,7 +3656,8 @@ mod tests { let mut group = self .track .create_group(moq_net::group::Info { start: sequence }) - .unwrap().unwrap(); + .unwrap() + .unwrap(); let mut payload = KEYFRAME.to_vec(); payload[6..8].copy_from_slice(&width.to_le_bytes()); payload[8..10].copy_from_slice(&height.to_le_bytes()); @@ -3678,7 +3680,8 @@ mod tests { let mut group = self .track .create_group(moq_net::group::Info { start: sequence }) - .unwrap().unwrap(); + .unwrap() + .unwrap(); let frame = vp8_frame(pts_ms * 1_000, true); hang::container::Frame { timestamp: frame.timestamp, @@ -4065,7 +4068,10 @@ mod tests { .step_by(100) .map(|ms| vp8_frame(ms * 1_000, ms == pts_ms)) .collect(); - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let bytes = muxer.fragment(sequence as u32, &frames, None).unwrap(); group.write_frame(frames[0].timestamp, bytes).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-mux/src/container/consumer.rs b/rs/moq-mux/src/container/consumer.rs index 78ba59763f2..ef83c033ab7 100644 --- a/rs/moq-mux/src/container/consumer.rs +++ b/rs/moq-mux/src/container/consumer.rs @@ -1917,7 +1917,10 @@ mod tests { /// Write a finished group with explicit sequence and timestamps (Container::Legacy(crate::container::Kind::Data) format). fn write_group(track: &mut moq_net::track::Producer, sequence: u64, timestamps: &[Timestamp]) { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); for ×tamp in timestamps { let frame = Frame { timestamp, @@ -2012,7 +2015,10 @@ mod tests { } fn write_marker_group(track: &mut moq_net::track::Producer, sequence: u64, timestamp: Timestamp) { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); Container::Legacy(crate::container::Kind::Audio) .write( &mut group, @@ -2116,7 +2122,10 @@ mod tests { Container::Legacy(crate::container::Kind::Data), ); write_group(&mut track, 0, &[ts(0), ts(10_000)]); - let mut group = track.create_group(moq_net::group::Info { start: 20_000 }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: 20_000 }) + .unwrap() + .unwrap(); group.write_frame(ts(20_000), Bytes::new()).unwrap(); group.finish().unwrap(); let _track = track.finish().unwrap(); @@ -2952,7 +2961,10 @@ mod tests { let mut reader = Consumer::new(subscription, Container::Legacy(crate::container::Kind::Video)); let wire = Container::Legacy(crate::container::Kind::Video); for (sequence, start) in [(0, 0), (1, 33_000)] { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let frame = |timestamp: u64, payload| Frame { timestamp: ts(timestamp), payload, @@ -3049,7 +3061,8 @@ mod tests { write_group(&mut track, 0, &[ts(0)]); track .create_group(moq_net::group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); write_group(&mut track, 2, &[ts(1_000)]); @@ -5976,10 +5989,16 @@ mod tests { ), DurationWire, ); - let mut group0 = track.create_group(moq_net::group::Info { start: 1_000_000 }).unwrap().unwrap(); + let mut group0 = track + .create_group(moq_net::group::Info { start: 1_000_000 }) + .unwrap() + .unwrap(); write_duration_frame(&mut group0, ts(0), ts(33_000)); group0.finish().unwrap(); - let mut group1 = track.create_group(moq_net::group::Info { start: 1_090_000 }).unwrap().unwrap(); + let mut group1 = track + .create_group(moq_net::group::Info { start: 1_090_000 }) + .unwrap() + .unwrap(); write_duration_frame(&mut group1, ts(33_000), ts(33_000)); group1.finish().unwrap(); let _track = track.finish().unwrap(); @@ -6070,7 +6089,10 @@ mod tests { sequence: u64, timestamp: Timestamp, ) -> moq_net::group::Producer { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group, @@ -6388,7 +6410,10 @@ mod tests { let mut consumer = container_max_delay_only(track.subscribe(None), max_delay); consumer.set_max_buffer(4096); for sequence in 0..2u64 { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group, @@ -6427,7 +6452,10 @@ mod tests { async fn a_hole_in_a_drained_backlog_is_late_from_the_earliest_arrival_past_it() { let mut track = track_producer("test", hang::container::track_info(hang::catalog::PRIORITY.video)); let marker = |track: &mut moq_net::track::Producer, sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); group.write_frame(ts(sequence * 10_000), Bytes::new()).unwrap(); group.finish().unwrap(); }; @@ -6484,7 +6512,10 @@ mod tests { Container::Legacy(crate::container::Kind::Data), ); for sequence in 0..256 { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); Container::Legacy(crate::container::Kind::Data) .write( &mut group, diff --git a/rs/moq-mux/src/container/source.rs b/rs/moq-mux/src/container/source.rs index 6bce43f9001..60703522064 100644 --- a/rs/moq-mux/src/container/source.rs +++ b/rs/moq-mux/src/container/source.rs @@ -1295,7 +1295,10 @@ mod tests { // One 24 ms frame per group, as the TS import publishes MPEG-1 audio. let wire = HangContainer::Legacy(crate::container::Kind::Audio); let write = |sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); wire.write(&mut group, &[raw_frame(sequence * 24_000, b"audio", true)]) .unwrap(); group.finish().unwrap(); @@ -1379,7 +1382,10 @@ mod tests { let wire = HangContainer::Legacy(crate::container::Kind::Audio); let pes = |pes: u64| { for sequence in pes * 5..pes * 5 + 5 { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); wire.write(&mut group, &[raw_frame(sequence * 24_000, b"audio", true)]) .unwrap(); group.finish().unwrap(); @@ -1520,7 +1526,10 @@ mod tests { let (track, mut export) = audio_export().await; let wire = HangContainer::Legacy(crate::container::Kind::Audio); let group = |sequence: u64, timestamp: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); wire.write(&mut group, &[raw_frame(timestamp, b"audio", true)]).unwrap(); group }; @@ -1553,7 +1562,10 @@ mod tests { let (track, mut export) = audio_export().await; let wire = HangContainer::Legacy(crate::container::Kind::Audio); for (sequence, timestamp, payload) in [(0, 0, b"audio".as_slice()), (2, 1_000_000, b"".as_slice())] { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); wire.write(&mut group, &[raw_frame(timestamp, payload, true)]).unwrap(); group.finish().unwrap(); } @@ -1604,7 +1616,10 @@ mod tests { ), (2, vec![raw_frame(100_000, b"resumed", true)]), ] { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); wire.write(&mut group, &frames).unwrap(); group.finish().unwrap(); } diff --git a/rs/moq-mux/src/container/ts/export_test.rs b/rs/moq-mux/src/container/ts/export_test.rs index 942e6505da3..41dabcd60d8 100644 --- a/rs/moq-mux/src/container/ts/export_test.rs +++ b/rs/moq-mux/src/container/ts/export_test.rs @@ -1010,7 +1010,10 @@ async fn export_trims_leading_pictures_after_each_delivery_break() { (11, vec![200, 180, 190, 210]), (13, vec![400, 380, 390, 410]), ] { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let frames: Vec<_> = stamps .into_iter() .enumerate() @@ -1315,7 +1318,8 @@ async fn export_declared(reorder: u8, groups: &[&[u64]]) -> (Export = stamps .iter() .enumerate() @@ -6358,7 +6362,10 @@ async fn a_start_group_cut_short_goes_out() { rig.at(tick * VIDEO_US).await; if tick.is_multiple_of(GOP) { group.finish().unwrap(); - group = track.create_group(moq_net::group::Info { start: tick / GOP }).unwrap().unwrap(); + group = track + .create_group(moq_net::group::Info { start: tick / GOP }) + .unwrap() + .unwrap(); } wire.write(&mut group, &[picture(tick)]).unwrap(); out.extend(poll_frames(&mut export)); @@ -8647,7 +8654,10 @@ async fn a_skipped_group_flags_the_clock() { for sequence in 0..80 + 2 * missing { kio::clock::sleep_until(start.saturating_add(Duration::from_millis(sequence * 100))).await; if !(20..20 + missing).contains(&sequence) && !(40 + missing..40 + 2 * missing).contains(&sequence) { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); for k in 0..5u64 { let frame = Frame { timestamp: Timestamp::from_millis(60_000 + sequence * 100 + k * 20).unwrap(), @@ -8791,7 +8801,10 @@ async fn a_timeline_restarting_at_zero_fails_the_export() { for sequence in 0..11u64 { kio::clock::sleep_until(start.saturating_add(Duration::from_secs(sequence))).await; let base = if sequence < 10 { sequence * 1_000 } else { 0 }; - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); for k in 0..50u64 { let millis = if sequence == 10 && k == 0 { 9_001 } else { base + k * 20 }; let frame = Frame { diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index 93dc92455f8..773d306ca74 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -1736,7 +1736,10 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { .unwrap(); let track = broadcast.broadcast().create_track("0", timed()).unwrap(); for key in order { - let mut group = track.create_group(moq_net::group::Info { start: key as u64 }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key as u64 }) + .unwrap() + .unwrap(); group.write_frame(at(key as u64), b"f".as_ref()).unwrap(); group.finish().unwrap(); } diff --git a/rs/moq-net/benches/ranges.rs b/rs/moq-net/benches/ranges.rs index f7c15f5ecc9..38cd7120cdc 100644 --- a/rs/moq-net/benches/ranges.rs +++ b/rs/moq-net/benches/ranges.rs @@ -137,7 +137,11 @@ impl TimeCap { } pub(crate) fn step(&mut self) { - let mut group = self.track.create_group(group::Info { start: self.next }).unwrap().unwrap(); + let mut group = self + .track + .create_group(group::Info { start: self.next }) + .unwrap() + .unwrap(); let mut handed = drain(&mut self.reader); group.write_frame(millis(self.next), Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); @@ -277,7 +281,11 @@ impl TimeGaps { pub(crate) fn step(&mut self) { // Each a millisecond after the last, from where the history ended. - let mut group = self.track.create_group(group::Info { start: self.next }).unwrap().unwrap(); + let mut group = self + .track + .create_group(group::Info { start: self.next }) + .unwrap() + .unwrap(); let mut handed = drain(&mut self.reader); group.write_frame(millis(self.next), Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-net/benches/tail.rs b/rs/moq-net/benches/tail.rs index 095e3987137..8dbcde56b3a 100644 --- a/rs/moq-net/benches/tail.rs +++ b/rs/moq-net/benches/tail.rs @@ -48,7 +48,8 @@ impl Held { for key in 1..=groups as u64 { track .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } diff --git a/rs/moq-net/benches/track.rs b/rs/moq-net/benches/track.rs index 8d954137aab..97902c253a6 100644 --- a/rs/moq-net/benches/track.rs +++ b/rs/moq-net/benches/track.rs @@ -395,7 +395,11 @@ impl HighKey { } fn write(&self, key: u64) { - let mut group = self.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = self + .track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::unscaled(key), self.payload.clone()) .unwrap(); @@ -1424,7 +1428,11 @@ impl Sparse { true => at(key), false => moq_net::Timestamp::unscaled(key), }; - let mut group = self.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = self + .track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group.write_frame(timestamp, Bytes::from_static(b"x")).unwrap(); group.finish().unwrap(); let Poll::Ready(Ok(Some(read))) = self.sub.poll_recv_group(&kio::Waiter::noop()) else { @@ -1645,7 +1653,10 @@ impl GapFlush { track::Subscription::default().with_delay(track::Delay::default().with_max(Duration::from_secs(3600))), ); let mut hand_out = |key: u64| { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group.write_frame(at(key), Bytes::from_static(b"x")).unwrap(); let Poll::Ready(Ok(Some(read))) = sub.poll_recv_group(&kio::Waiter::noop()) else { panic!("the group is cached"); @@ -1674,7 +1685,8 @@ impl GapFlush { let mut group = self .track .create_group(moq_net::group::Info { start: TWO_HOURS }) - .unwrap().unwrap(); + .unwrap() + .unwrap(); group.write_frame(at(TWO_HOURS), Bytes::from_static(b"x")).unwrap(); let Poll::Ready(Ok(Some(read))) = self.sub.poll_recv_group(&kio::Waiter::noop()) else { panic!("the group is cached"); diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index c3deb3b53a5..105ae09cf14 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -21755,8 +21755,18 @@ mod range_tests { "video", crate::track::Info::timed(), ); - track.create_group(group::Info { start: 7 }).unwrap().unwrap().finish().unwrap(); - track.create_group(group::Info { start: 8 }).unwrap().unwrap().finish().unwrap(); + track + .create_group(group::Info { start: 7 }) + .unwrap() + .unwrap() + .finish() + .unwrap(); + track + .create_group(group::Info { start: 8 }) + .unwrap() + .unwrap() + .finish() + .unwrap(); // Next Group against a live edge of 8 asks for 9, which does not exist yet. let mut subscriber = track.subscribe(None); @@ -21767,7 +21777,12 @@ mod range_tests { ); // The group it asked for is what it gets once published. - track.create_group(group::Info { start: 9 }).unwrap().unwrap().finish().unwrap(); + track + .create_group(group::Info { start: 9 }) + .unwrap() + .unwrap() + .finish() + .unwrap(); let group = subscriber.recv_group().await.unwrap().expect("group 9"); assert_eq!(group.start, 9); } diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 3a113d3b99e..27dd9756ca0 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -6476,9 +6476,8 @@ impl OpenGroup { // Stats (groups/frames/bytes) are counted in the model as the group is written, // through the tagged `track::Producer`. // A stream for a group the copy already holds is refused: the model has one producer per group. - let create = |track: &mut track::Producer| { - track.create_group(group::Info { start: key })?.ok_or(Error::Duplicate) - }; + let create = + |track: &mut track::Producer| track.create_group(group::Info { start: key })?.ok_or(Error::Duplicate); loop { match self.step { @@ -17289,7 +17288,12 @@ mod stitch_tests { let dynamic = run.track.requests(); let consumer = run.track.consume(); run.track.start_at(last + 1).unwrap(); - run.track.create_group((last + 1).into()).unwrap().unwrap().finish().unwrap(); + run.track + .create_group((last + 1).into()) + .unwrap() + .unwrap() + .finish() + .unwrap(); // From group 0, which a time start names whatever is held, so the history below // the feed is asked as a miss rather than looked up. let mut reading = consumer diff --git a/rs/moq-net/src/ietf/subscriber/tracks.rs b/rs/moq-net/src/ietf/subscriber/tracks.rs index f7bb1321771..0cc59eb4863 100644 --- a/rs/moq-net/src/ietf/subscriber/tracks.rs +++ b/rs/moq-net/src/ietf/subscriber/tracks.rs @@ -2385,7 +2385,10 @@ mod tests { .producer .clone() .unwrap(); - let mut group = copy.create_group(crate::model::group::Info { start: 5 }).unwrap().unwrap(); + let mut group = copy + .create_group(crate::model::group::Info { start: 5 }) + .unwrap() + .unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), b"key".as_slice()) .unwrap(); diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index 771ac07124b..9f1344d3be6 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -3417,7 +3417,10 @@ mod test { let mut subscriber = producer.subscribe(None); let write = |producer: &mut track::Producer, key: u64| { - let mut group = producer.create_group(crate::group::Info { start: key }).unwrap().unwrap(); + let mut group = producer + .create_group(crate::group::Info { start: key }) + .unwrap() + .unwrap(); group.write_frame(group.key_time(), b"x".to_vec()).unwrap(); group.finish().unwrap(); }; @@ -3454,7 +3457,10 @@ mod test { ); let write = |producer: &mut track::Producer, key: u64| { - let mut group = producer.create_group(crate::group::Info { start: key }).unwrap().unwrap(); + let mut group = producer + .create_group(crate::group::Info { start: key }) + .unwrap() + .unwrap(); group.write_frame(group.key_time(), b"x".to_vec()).unwrap(); group.finish().unwrap(); }; @@ -3480,7 +3486,8 @@ mod test { // The last group is 6 (exclusive 7), but only group 5 has been produced so far. producer .create_group(group::Info { start: 5 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer.finish_at(track::Position::group(7)).unwrap(); @@ -3502,7 +3509,8 @@ mod test { // then the track finishes. producer .create_group(group::Info { start: 6 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); match recv_next(&mut subscriber, false).await.unwrap() { @@ -3558,7 +3566,8 @@ mod test { producer .create_group(group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); match recv_next(&mut subscriber, false).await.unwrap() { @@ -3569,7 +3578,8 @@ mod test { // Group 1 lands after group 2 was already served. producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); match recv_next(&mut subscriber, false).now_or_never() { diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index cbe9a8dd087..6296aab2dcc 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -5701,7 +5701,11 @@ mod tests { group.finish().map(drop) }; let arrive = |serving: &mut ServeLoop, key| { - let group = serving.serving.create_group(crate::group::Info { start: key }).unwrap().unwrap(); + let group = serving + .serving + .create_group(crate::group::Info { start: key }) + .unwrap() + .unwrap(); (group, Reading::open(&tail, Some(key), now())) }; @@ -5806,7 +5810,11 @@ mod tests { groups: first..last + 1, }) }; - let mut group = serving.serving.create_group(crate::group::Info { start: 5 }).unwrap().unwrap(); + let mut group = serving + .serving + .create_group(crate::group::Info { start: 5 }) + .unwrap() + .unwrap(); group .write_frame(crate::Timestamp::from_millis(5).unwrap(), &b"x"[..]) .unwrap(); @@ -8193,7 +8201,11 @@ mod tests { let established = h.wire().len(); let arrive = |serving: &ServeLoop, key| { - let mut group = serving.serving.create_group(group::Info { start: key }).unwrap().unwrap(); + let mut group = serving + .serving + .create_group(group::Info { start: key }) + .unwrap() + .unwrap(); for frame in [&b"key"[..], b"abc", b"d"] { group .write_frame(crate::Timestamp::unscaled(group.start), frame) diff --git a/rs/moq-net/src/model/broadcast.rs b/rs/moq-net/src/model/broadcast.rs index 9736a6e7ef6..d4d063eccb0 100644 --- a/rs/moq-net/src/model/broadcast.rs +++ b/rs/moq-net/src/model/broadcast.rs @@ -2033,7 +2033,8 @@ mod test { // The new consumer should receive the new group, which continues past the first's. producer2 .create_group(crate::group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); track2.assert_group(); diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 374ca1c834e..cf5a05ffb48 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -15274,7 +15274,8 @@ mod tests { let mut group = rig .incumbent_track .create_group(crate::group::Info { start: 5 }) - .unwrap().unwrap(); + .unwrap() + .unwrap(); group.write_frame(group.key_time(), b"five".as_ref()).unwrap(); group.finish().unwrap(); assert_eq!(rig.subscription.recv_group().await.unwrap().unwrap().start, 5); diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 64d49e640c3..763939fcb8a 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -5530,7 +5530,11 @@ mod test { group.write_frame(ts(0), b"a".as_ref()).unwrap(); group.finish().unwrap(); // Groups 1 and 2 are missing below the end: a fetch asks for them. - a.create_group(group::Info { start: 3 }).unwrap().unwrap().finish().unwrap(); + a.create_group(group::Info { start: 3 }) + .unwrap() + .unwrap() + .finish() + .unwrap(); let last = a.consume(); let a = a.finish().unwrap(); routes.end(Ok(())); @@ -10566,7 +10570,8 @@ mod test { let mut sub = subscribe(&logical, Duration::from_secs(if widen { 2 } else { 10 })); let b = copy(); // Both routes carry the same content, including the unfinished payload. - let writers = [&a, &b].map(|source| source.create_group(group::Info { start: 0 }).unwrap().unwrap()); + let writers = + [&a, &b].map(|source| source.create_group(group::Info { start: 0 }).unwrap().unwrap()); // Each group's writer, held open by its unfinished frame when chunked. let _writers: Vec<_> = writers .into_iter() diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index 7ae43eff75b..8960e186f6c 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -12702,7 +12702,8 @@ mod test { let producer = track_producer("test", Info::default()); producer .create_group(group::Info { start: 0 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let open = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); @@ -12876,7 +12877,8 @@ mod test { let waiter = kio::Waiter::noop(); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert!(feed.poll_group(0, &waiter).is_pending()); @@ -12978,7 +12980,8 @@ mod test { framed.finish().unwrap(); producer .create_group(group::Info { start: 5 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer.finish_at(Position::group(6)).unwrap(); @@ -14459,7 +14462,8 @@ mod test { let waiter = kio::Waiter::noop(); producer .create_group(group::Info { start: high }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let Poll::Ready(Ok(Some(group))) = subscriber.poll_recv_group(&waiter) else { @@ -14472,7 +14476,8 @@ mod test { elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); // Below the reader's floor: never handed out. @@ -17649,7 +17654,8 @@ mod test { // Nothing below the floor is waited for, and a group above it reads at once. producer .create_group(group::Info { start: 3 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(subscriber.assert_group().start, 3); @@ -18441,7 +18447,8 @@ mod test { // Arrive: seq 5, then seq 3. producer .create_group(group::Info { start: 5 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -18450,7 +18457,8 @@ mod test { // Seq 3 arrives late; max_key is still 5 (at front). producer .create_group(group::Info { start: 3 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -18468,7 +18476,8 @@ mod test { // Seq 2 arrives late, triggering eviction. producer .create_group(group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -18705,12 +18714,14 @@ mod test { let mut producer = track_producer("test", Info::timed()); producer .create_group(group::Info { start: 0 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer.finish_at(Position::group(4)).unwrap(); @@ -18801,7 +18812,8 @@ mod test { let mut ordered = producer.subscribe(replay()).ordered(); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let finished = producer.finish().unwrap(); @@ -18968,7 +18980,8 @@ mod test { let mut producer = track_producer("test", Info::timed()); producer .create_group(group::Info { start: 5 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -18994,7 +19007,8 @@ mod test { // The trailing group arrives (below the boundary), then the track completes. producer .create_group(group::Info { start: 6 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(consumer.assert_group().start, 6); @@ -19016,7 +19030,8 @@ mod test { for key in 0..2 { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -19241,7 +19256,8 @@ mod test { producer.start_at(0).unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 1); @@ -19292,7 +19308,8 @@ mod test { producer.finish_at(Position::group(2)).unwrap(); producer .create_group(group::Info { start: arrived }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, arrived); @@ -19305,7 +19322,8 @@ mod test { producer .create_group(group::Info { start: missing }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, missing); @@ -19328,7 +19346,8 @@ mod test { elapse(&producer, grace / 2); producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, key); @@ -19368,7 +19387,8 @@ mod test { producer.finish_at(Position::group(2)).unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 1); @@ -19386,7 +19406,8 @@ mod test { producer.finish_at(Position::group(3)).unwrap(); producer .create_group(group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 2); @@ -19415,7 +19436,8 @@ mod test { let mut arrival = producer.subscribe(replay()); producer .create_group(group::Info { start: 0 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 0); @@ -19430,7 +19452,8 @@ mod test { let mut arrival = producer.subscribe(replay()); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 1); @@ -19499,7 +19522,8 @@ mod test { for key in [1, 0] { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -19523,7 +19547,8 @@ mod test { for key in [0, 2] { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, key); @@ -19550,7 +19575,8 @@ mod test { for key in [0, 1] { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(arrival.assert_group().start, key); @@ -19558,7 +19584,8 @@ mod test { elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); producer .create_group(group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert!(!producer.state.read().lookup.contains_key(&0), "group 0 was evicted"); @@ -19706,7 +19733,8 @@ mod test { for key in [0, 2] { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -19731,7 +19759,8 @@ mod test { let demand = producer.demand(); producer .create_group(group::Info { start: 5 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer.finish_at(Position::group(6)).unwrap(); @@ -19772,7 +19801,8 @@ mod test { for key in 0..2 { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -19801,7 +19831,8 @@ mod test { let mut consumer = producer.subscribe(None); producer .create_group(group::Info { start: 0 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); drop(producer); @@ -19935,7 +19966,8 @@ mod test { for key in 0..2 { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -19959,7 +19991,8 @@ mod test { for key in [0, 2] { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -19985,7 +20018,8 @@ mod test { let producer = track_producer("test", Info::timed()); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let producer = producer.finish().unwrap(); @@ -21160,7 +21194,8 @@ mod test { // Seq 5 arrives first. producer .create_group(group::Info { start: 5 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let group = consumer @@ -21174,19 +21209,22 @@ mod test { // Seq 3 arrives late, skipped because 3 <= 5. producer .create_group(group::Info { start: 3 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); // Seq 4 arrives late and is also skipped. producer .create_group(group::Info { start: 4 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); // Seq 7 arrives and is returned, after the groups it passed are reported. producer .create_group(group::Info { start: 7 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -21202,12 +21240,14 @@ mod test { // Seq 3 arrives first, then seq 5. Both should be returned in arrival order. producer .create_group(group::Info { start: 3 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 5 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -21242,7 +21282,8 @@ mod test { for key in [u64::MAX - 2, u64::MAX - 1] { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -21291,7 +21332,8 @@ mod test { for key in [1, 2] { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -21324,7 +21366,8 @@ mod test { for key in [1, 3] { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -21349,7 +21392,8 @@ mod test { for key in [1, 2] { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -21374,7 +21418,8 @@ mod test { for key in [2, 1] { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -21405,12 +21450,14 @@ mod test { // Out-of-order arrivals: seq 5 first, then seq 3. producer .create_group(group::Info { start: 5 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 3 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -21437,7 +21484,8 @@ mod test { for s in 0..6 { producer .create_group(group::Info { start: s }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -21465,7 +21513,8 @@ mod test { for s in 0..6 { producer .create_group(group::Info { start: s }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -21497,7 +21546,8 @@ mod test { for s in 0..3 { producer .create_group(group::Info { start: s }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -21511,12 +21561,14 @@ mod test { consumer.set_range(..2); producer .create_group(group::Info { start: 3 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 4 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert!( @@ -21541,28 +21593,33 @@ mod test { // Out-of-order arrivals all within the cap. producer .create_group(group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 5 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 3 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); // One beyond the cap; should be held even though it arrived in the middle. producer .create_group(group::Info { start: 8 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 4 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -21591,7 +21648,8 @@ mod test { for s in 0..3 { producer .create_group(group::Info { start: s }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -21627,17 +21685,20 @@ mod test { // Reordered burst: the beyond-cap group arrives first. producer .create_group(group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 0 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -21657,31 +21718,36 @@ mod test { consumer.set_range(2..=2); producer .create_group(group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(consumer.recv_group().await.unwrap().unwrap().start, 2); consumer.set_range(..4); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 3 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(consumer.recv_group().await.unwrap().unwrap().start, 3); consumer.set_range(0..=4); producer .create_group(group::Info { start: 0 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 4 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(consumer.recv_group().await.unwrap().unwrap().start, 4); @@ -21698,7 +21764,8 @@ mod test { consumer.set_range(..1); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert!( @@ -21709,7 +21776,8 @@ mod test { consumer.set_range(2..); producer .create_group(group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!( @@ -21730,7 +21798,8 @@ mod test { producer .create_group(group::Info { start: 0 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(consumer.recv_group().now_or_never().unwrap().unwrap().unwrap().start, 0); @@ -21761,12 +21830,14 @@ mod test { let mut consumer = producer.subscribe(replay()); producer .create_group(group::Info { start: 0 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -21794,7 +21865,8 @@ mod test { for s in 0..3 { producer .create_group(group::Info { start: s }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -21871,7 +21943,8 @@ mod test { )); producer .create_group(group::Info { start: u64::MAX - 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert!(matches!(producer.append_next(), Err(Error::BoundsExceeded(_)))); @@ -22473,7 +22546,8 @@ mod test { // can find it settled. producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); producer.finish_at(Position::group(2)).unwrap(); @@ -23212,7 +23286,8 @@ mod test { // The feed delivered group 1 and never group 0, which a fetch asks of the source. producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); @@ -27284,7 +27359,8 @@ mod test { 3 => { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -27466,7 +27542,8 @@ mod test { req.accept(None).unwrap().expect("a fresh group").finish().unwrap(); producer .create_group(group::Info { start: 0 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let mut late = producer.subscribe(replay().with_ranges([Range::live()])); @@ -27549,7 +27626,9 @@ mod test { /// A group `key` whose first frame lands at `millis`, or the write's refusal. A /// refused group is aborted, as a caller would. fn start_at_millis(producer: &Producer, key: u64, millis: u64) -> Result { - let mut group = producer.create_group(group::Info { start: key })?.expect("a fresh group"); + let mut group = producer + .create_group(group::Info { start: key })? + .expect("a fresh group"); match group.write_frame(Timestamp::from_millis(millis).unwrap(), &b"x"[..]) { Ok(()) => Ok(group), Err(err) => { @@ -27890,7 +27969,8 @@ mod test { for key in 0..1000 { producer .create_group(group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -29043,7 +29123,8 @@ mod test { cut.abort(Error::App(5)).unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let _producer = producer.finish().unwrap(); @@ -29082,7 +29163,8 @@ mod test { group.abort(err.clone()).unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); assert_eq!(subscriber.assert_group().start, 1, "{err:?}"); @@ -29102,7 +29184,8 @@ mod test { cut.abort(Error::App(5)).unwrap(); producer .create_group(group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let _live = producer.create_group(group::Info { start: 2 }).unwrap().unwrap(); @@ -29139,7 +29222,8 @@ mod test { let mut ordered = producer.subscribe(replay()).ordered().with_range(..1); producer .create_group(group::Info { start: 0 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let mut cut = producer.create_group(group::Info { start: 1 }).unwrap().unwrap(); @@ -29228,7 +29312,12 @@ mod test { for order in [Order::Ascending, Order::Descending] { let producer = track_producer("test", Info::timed()); let _groups: Vec<_> = (2..10) - .map(|second| producer.create_group(group::Info { start: second * 1000 }).unwrap().unwrap()) + .map(|second| { + producer + .create_group(group::Info { start: second * 1000 }) + .unwrap() + .unwrap() + }) .collect(); let since = [Range { start: Anchor::Time(2500), diff --git a/rs/moq-net/src/model/track/miss.rs b/rs/moq-net/src/model/track/miss.rs index 661a1af8088..07b006cb570 100644 --- a/rs/moq-net/src/model/track/miss.rs +++ b/rs/moq-net/src/model/track/miss.rs @@ -1657,7 +1657,8 @@ mod tests { for key in [0, 2] { track .create_group(crate::group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -1718,7 +1719,8 @@ mod tests { for key in [4, 0] { track .create_group(crate::group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -1767,7 +1769,8 @@ mod tests { // again, and reclaiming the cut removes the cached incarnation before the probe. track .create_group(crate::group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .abort(Error::Cancel) .unwrap(); track.drop_groups(2..3, crate::StreamError::Old); @@ -1792,7 +1795,8 @@ mod tests { drop(state); track .create_group(crate::group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let state = track.state.read(); @@ -1863,7 +1867,8 @@ mod tests { for key in [4, 0] { track .create_group(crate::group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -1909,7 +1914,8 @@ mod tests { // still a hole: the refusal stands and the hole is given up, not asked again. track .create_group(crate::group::Info { start: 2 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .abort(Error::Cancel) .unwrap(); let state = track.state.read(); @@ -1940,7 +1946,8 @@ mod tests { for key in [0, 2, 4] { track .create_group(crate::group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -1991,7 +1998,8 @@ mod tests { drop(state); track .create_group(crate::group::Info { start: 1 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let state = track.state.read(); @@ -2052,7 +2060,8 @@ mod tests { for key in 0..3 { track .create_group(crate::group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -2110,7 +2119,8 @@ mod tests { track .create_group(crate::group::Info { start: 4 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let state = track.state.read(); @@ -2320,7 +2330,8 @@ mod tests { for &key in keys.iter().rev() { track .create_group(crate::group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -2426,7 +2437,8 @@ mod tests { for key in [0, 2, 4, 6, 8] { track .create_group(crate::group::Info { start: key }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); } @@ -2502,7 +2514,8 @@ mod tests { track.start_at(8).unwrap(); track .create_group(crate::group::Info { start: 8 }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let track = track.finish().unwrap(); diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index 802a769ba36..f71e94213e7 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -154,7 +154,11 @@ async fn a_start_group_arrives_whole() { false => moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), }; let published = publish(info); - let mut group = published.track.create_group(moq_net::group::Info { start: 5 }).unwrap().unwrap(); + let mut group = published + .track + .create_group(moq_net::group::Info { start: 5 }) + .unwrap() + .unwrap(); write(&mut group, 0..head); let mut fixture = relay( published, diff --git a/rs/moq-net/tests/integration/drop_record.rs b/rs/moq-net/tests/integration/drop_record.rs index 5a08dca635e..5c827d354b9 100644 --- a/rs/moq-net/tests/integration/drop_record.rs +++ b/rs/moq-net/tests/integration/drop_record.rs @@ -37,7 +37,10 @@ fn timed() -> Info { /// Write group `key` presented at `millis`, and finish it. fn write(source: &track::Producer, key: u64, millis: u64) { - let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = source + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(millis).unwrap(), &b"x"[..]) .unwrap(); @@ -411,7 +414,11 @@ async fn an_origin_eviction_drop_is_forwarded_final() { let mut reader = chain.subscribe(reading(None, [support::keys(0..)])).await; chain.upstream.server_transport.hold_unis(); let write = |key: u64| { - let mut group = chain.source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = chain + .source + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), vec![0u8; PAYLOAD]) .unwrap(); @@ -493,7 +500,11 @@ async fn an_ordered_reader_is_told_of_every_group_the_origin_evicted() { .ordered(); chain.upstream.server_transport.hold_unis(); for key in 0..WRITTEN { - let mut group = chain.source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = chain + .source + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), vec![0u8; PAYLOAD]) .unwrap(); @@ -545,7 +556,11 @@ async fn a_run_dropped_before_the_first_group_settles_a_later_range() { let chain = Chain::new([LITE07, LITE07], [forever(), forever(), forever()]).await; let mut reader = chain.subscribe(reading(None, [support::keys(0..)])).await; for key in 0..2 { - let group = chain.source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let group = chain + .source + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group.abort(moq_net::Error::App(1)).unwrap(); } write(&chain.source, 2, 0); @@ -646,7 +661,8 @@ async fn settle_even(chain: &Chain, runs: u64, stale: Option) { let group = chain .source .create_group(moq_net::group::Info { start: 2 * run }) - .unwrap().unwrap(); + .unwrap() + .unwrap(); group.abort(moq_net::Error::App(1)).unwrap(); } } diff --git a/rs/moq-net/tests/integration/fetch_from_feed.rs b/rs/moq-net/tests/integration/fetch_from_feed.rs index 305666cb07b..faff1d892a5 100644 --- a/rs/moq-net/tests/integration/fetch_from_feed.rs +++ b/rs/moq-net/tests/integration/fetch_from_feed.rs @@ -161,7 +161,11 @@ async fn an_unfed_fetch_is_a_miss() { write(&relay.track, b"1"); // The publisher skips group 2, so the feed goes past it. - let mut skipped = relay.track.create_group(moq_net::group::Info { start: 3 }).unwrap().unwrap(); + let mut skipped = relay + .track + .create_group(moq_net::group::Info { start: 3 }) + .unwrap() + .unwrap(); skipped .write_frame(moq_net::Timestamp::unscaled(skipped.start), &b"3"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index c1b774d39f5..0787028caca 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -329,7 +329,10 @@ async fn a_relay_serves_a_bounded_read_of_history_without_subscribing_upstream() /// Write group `key` of [`frames`] to a live track. fn write_group(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); for frame in frames(key) { group.write_frame(group.at_start(), frame).unwrap(); } diff --git a/rs/moq-net/tests/integration/group_order.rs b/rs/moq-net/tests/integration/group_order.rs index 36c40664839..6b01b905d72 100644 --- a/rs/moq-net/tests/integration/group_order.rs +++ b/rs/moq-net/tests/integration/group_order.rs @@ -89,7 +89,10 @@ fn write_backlog(track: &moq_net::track::Producer) -> Vec moq_net::origin::Producer { /// Four frames starting at `key` seconds, so a group created late still starts /// below the one after it. fn write_group(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); for frame in 0..4 { let timestamp = Timestamp::from_millis(key * 1000 + frame).unwrap(); group.write_frame(timestamp, &b"x"[..]).unwrap(); diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index 98e3909ba85..50df2f6f765 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -61,7 +61,10 @@ async fn read(version: Option<&str>, range: Range) -> Result, Error> { .unwrap(); broadcast.announce().unwrap(); for key in (0..5).map(|second| second * 1000) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group.write_frame(millis(key), &b"x"[..]).unwrap(); group.finish().unwrap(); } @@ -198,7 +201,10 @@ async fn a_relative_start_reports_the_publishers_start_over_a_frameless_newest_g .unwrap(); broadcast.announce().unwrap(); for key in 0..5 { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(moq_net::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); @@ -261,7 +267,10 @@ async fn a_sparse_request_counts_its_relative_start_back_as_the_publisher_did() .unwrap(); broadcast.announce().unwrap(); for key in 0..10 { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group.write_frame(millis(key), &b"x"[..]).unwrap(); group.finish().unwrap(); } diff --git a/rs/moq-net/tests/integration/range_fill.rs b/rs/moq-net/tests/integration/range_fill.rs index 7312a3daef4..6739f125c59 100644 --- a/rs/moq-net/tests/integration/range_fill.rs +++ b/rs/moq-net/tests/integration/range_fill.rs @@ -61,7 +61,10 @@ impl Fixture { broadcast.announce().unwrap(); for index in 0..groups { let mut group = match spacing { - 1 => track.create_group(moq_net::group::Info { start: index }).unwrap().unwrap(), + 1 => track + .create_group(moq_net::group::Info { start: index }) + .unwrap() + .unwrap(), spacing => track .append_group(Timestamp::from_millis(index * spacing).unwrap()) .unwrap(), @@ -152,7 +155,11 @@ async fn evicted_history_is_recovered_once_on_its_own_subscription() { assert_eq!(fixture.opened(FETCH), 0, "nothing fetched"); // The live subscription goes on. - let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); + let mut group = fixture + .track + .create_group(moq_net::group::Info { start: 6 }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(6000).unwrap(), b"x".as_slice()) .unwrap(); @@ -236,7 +243,11 @@ async fn a_recovery_takes_a_skip_inside_it() { let fixture = Fixture::new(2).await; fixture.track.skip_groups(2..3); for start in 3..6 { - let mut group = fixture.track.create_group(moq_net::group::Info { start }).unwrap().unwrap(); + let mut group = fixture + .track + .create_group(moq_net::group::Info { start }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(start * 1000).unwrap(), b"x".as_slice()) .unwrap(); @@ -252,7 +263,11 @@ async fn a_recovery_takes_a_skip_inside_it() { assert_eq!(receive(&mut second, 3).await, [1, 3, 4].into()); // The live subscription goes on. - let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); + let mut group = fixture + .track + .create_group(moq_net::group::Info { start: 6 }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(6000).unwrap(), b"x".as_slice()) .unwrap(); diff --git a/rs/moq-net/tests/integration/range_union_fit.rs b/rs/moq-net/tests/integration/range_union_fit.rs index 0ca63fd5fef..e34ad7f7510 100644 --- a/rs/moq-net/tests/integration/range_union_fit.rs +++ b/rs/moq-net/tests/integration/range_union_fit.rs @@ -30,7 +30,10 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { } fn write_group(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/received_rewind.rs b/rs/moq-net/tests/integration/received_rewind.rs index ed84227c9e8..b8ca57d1670 100644 --- a/rs/moq-net/tests/integration/received_rewind.rs +++ b/rs/moq-net/tests/integration/received_rewind.rs @@ -33,7 +33,10 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { /// A group starting at `key` milliseconds. fn write_group(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); let timestamp = millis(key); group.write_frame(timestamp, &b"x"[..]).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-net/tests/integration/route_change.rs b/rs/moq-net/tests/integration/route_change.rs index 21dd601aec4..b960c78340a 100644 --- a/rs/moq-net/tests/integration/route_change.rs +++ b/rs/moq-net/tests/integration/route_change.rs @@ -980,7 +980,11 @@ async fn redundant_pair_follows_the_next_instance(version: &str, loss: Loss) { let mut rx = read(first.track("video").unwrap().subscribe(prefs.clone()).await.unwrap()); let write = |replicas: &mut Vec, key: u64| { for replica in replicas.iter_mut() { - let mut group = replica.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = replica + .track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame( Timestamp::from_micros(1_000_000 + key * 1_000).unwrap(), diff --git a/rs/moq-net/tests/integration/route_cluster.rs b/rs/moq-net/tests/integration/route_cluster.rs index 2bf98a5c38e..882ad2bf4c1 100644 --- a/rs/moq-net/tests/integration/route_cluster.rs +++ b/rs/moq-net/tests/integration/route_cluster.rs @@ -235,7 +235,11 @@ impl Publisher { /// Write group `key` in full. fn group(&self, key: u64) { - let mut group = self.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = self + .track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); for frame in 0..FRAMES { let timestamp = Timestamp::from_micros(1_000_000 + key * 100_000 + frame * 1_000).unwrap(); group.write_frame(timestamp, tagged(self.name, key, frame)).unwrap(); diff --git a/rs/moq-net/tests/integration/shared_copy_start.rs b/rs/moq-net/tests/integration/shared_copy_start.rs index 364ad54974a..6cfaff5512c 100644 --- a/rs/moq-net/tests/integration/shared_copy_start.rs +++ b/rs/moq-net/tests/integration/shared_copy_start.rs @@ -22,7 +22,10 @@ const TIMEOUT: Duration = Duration::from_secs(10); const STEP: u64 = 100; fn write(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/slow_joiner.rs b/rs/moq-net/tests/integration/slow_joiner.rs index 3a4be85799b..e4c26997cb4 100644 --- a/rs/moq-net/tests/integration/slow_joiner.rs +++ b/rs/moq-net/tests/integration/slow_joiner.rs @@ -69,7 +69,10 @@ async fn stalled_read(version: Version, budget: Duration) -> BTreeSet { *gate.write().ok().unwrap() = false; for key in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = source + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index 89ce179de17..2af8d92534d 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -513,7 +513,10 @@ async fn a_shed_late_group_lets_a_newer_group_through() { // Group 1 waits for credit it cannot make room for, and group 0 ranks below it. for key in [1, 0] { - let mut late = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut late = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); late.write_frame(late.at_start(), b"late".as_slice()).unwrap(); late.finish().unwrap(); } diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index e2cd7369a97..efda2d9d4f1 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -33,7 +33,10 @@ fn timed() -> Info { } fn write_group(track: &moq_net::track::Producer, key: u64) { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); @@ -282,7 +285,10 @@ async fn range_fixture_history(version: &str, relay: bool, history: u64) -> Rang let track = broadcast.broadcast().create_track("quiet", timed()).unwrap(); broadcast.announce().unwrap(); for key in 0..history { - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), b"x".as_slice()) .unwrap(); @@ -417,7 +423,11 @@ async fn draft22_updates_both_bounds_across_cached_groups() { .await .expect("the narrowed range never reached the publisher"); reader.update(initial.with_ranges([support::keys(0..)])).unwrap(); - let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); + let mut group = fixture + .track + .create_group(moq_net::group::Info { start: 6 }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(6).unwrap(), b"later".as_slice()) .unwrap(); @@ -488,7 +498,11 @@ async fn draft22_carries_time_ends_as_group_ids() { async fn draft22_can_widen_while_the_current_group_is_quiet() { for relay in [false, true] { let fixture = range_fixture(relay).await; - let mut quiet = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); + let mut quiet = fixture + .track + .create_group(moq_net::group::Info { start: 6 }) + .unwrap() + .unwrap(); quiet .write_frame(Timestamp::from_millis(6).unwrap(), b"head".as_slice()) .unwrap(); @@ -576,7 +590,11 @@ async fn draft18_updates_narrow_then_widen() { .await .unwrap_or_else(|_| panic!("{version} relay={relay}: narrowing did not reach the publisher")); for key in 6..8 { - let mut group = fixture.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = fixture + .track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), key.to_be_bytes().as_slice()) .unwrap(); @@ -628,7 +646,11 @@ async fn empty_ranges_retire_the_wire_and_can_widen_again() { reader.poll_recv_group(&kio::Waiter::noop()), std::task::Poll::Ready(Ok(None)) )); - let mut group = fixture.track.create_group(moq_net::group::Info { start: 6 }).unwrap().unwrap(); + let mut group = fixture + .track + .create_group(moq_net::group::Info { start: 6 }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(6).unwrap(), b"sibling".as_slice()) .unwrap(); @@ -657,7 +679,11 @@ async fn empty_ranges_retire_the_wire_and_can_widen_again() { ) .await .unwrap_or_else(|_| panic!("{version} relay={relay}: empty demand retained a wire subscription")); - let mut group = fixture.track.create_group(moq_net::group::Info { start: 7 }).unwrap().unwrap(); + let mut group = fixture + .track + .create_group(moq_net::group::Info { start: 7 }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(7).unwrap(), b"resumed".as_slice()) .unwrap(); @@ -706,7 +732,11 @@ async fn draft22_cold_widening_finishes_the_largest_group() { .await .unwrap_or_else(|_| panic!("relay={relay}: narrowing to {future} stalled")); for key in start..future { - let mut group = fixture.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = fixture + .track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), key.to_be_bytes().as_slice()) .unwrap(); @@ -842,7 +872,11 @@ async fn holes_through_a_relay(version: &str, budget: Option) { let name = format!("{version} {order:?} budget={budget:?}"); let fixture = range_fixture_history(version, true, 0).await; for key in (0..=9).filter(|key| *key != ABSENT) { - let mut group = fixture.track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = fixture + .track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); if key == DROPPED { group.abort(moq_net::Error::App(1)).unwrap(); continue; @@ -887,7 +921,8 @@ async fn holes_through_a_relay(version: &str, budget: Option) { let mut group = fixture .track .create_group(moq_net::group::Info { start: LIVE_MILLIS }) - .unwrap().unwrap(); + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(LIVE_MILLIS).unwrap(), b"x".as_slice()) .unwrap(); diff --git a/rs/moq-net/tests/integration/warm_backfill.rs b/rs/moq-net/tests/integration/warm_backfill.rs index 6f338261d33..1243b8099dd 100644 --- a/rs/moq-net/tests/integration/warm_backfill.rs +++ b/rs/moq-net/tests/integration/warm_backfill.rs @@ -82,7 +82,10 @@ async fn a_newcomer_on_a_warm_relay_gets_the_backfill() { ) .unwrap(); for key in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = source + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/wide_key.rs b/rs/moq-net/tests/integration/wide_key.rs index 72b1dbabc58..9118e73ef9c 100644 --- a/rs/moq-net/tests/integration/wide_key.rs +++ b/rs/moq-net/tests/integration/wide_key.rs @@ -59,7 +59,10 @@ async fn largest_quic_key_reaches_the_subscriber() { true => Timestamp::unscaled(key), false => Timestamp::from_micros(key.min((1 << 61) - 1)).unwrap(), }; - let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group.write_frame(timestamp, b"ladder".as_ref()).unwrap(); group.finish().unwrap(); let mut got = kio::clock::timeout(Duration::from_secs(5), sub.recv_group()) @@ -115,7 +118,10 @@ async fn wide_key_fails_only_its_subscription() { let wide = broadcast.broadcast().create_track("wide", timed()).unwrap(); let narrow = broadcast.broadcast().create_track("narrow", timed()).unwrap(); broadcast.announce().unwrap(); - let mut group = wide.create_group(moq_net::group::Info { start: WIDE }).unwrap().unwrap(); + let mut group = wide + .create_group(moq_net::group::Info { start: WIDE }) + .unwrap() + .unwrap(); group.write_frame(latest(), b"wide".as_ref()).unwrap(); let mut group = narrow.append_next().unwrap(); group.write_frame(Timestamp::ZERO, b"narrow".as_ref()).unwrap(); @@ -212,7 +218,10 @@ async fn a_later_wide_group_fails_only_that_subscription() { assert_eq!(group.start, 0); assert_eq!(group.read_frame().await.unwrap().unwrap().payload, b"first".as_ref()); - let mut group = wide.create_group(moq_net::group::Info { start: WIDE }).unwrap().unwrap(); + let mut group = wide + .create_group(moq_net::group::Info { start: WIDE }) + .unwrap() + .unwrap(); group.write_frame(latest(), b"wide".as_ref()).unwrap(); let result = kio::clock::timeout(Duration::from_secs(5), sub.recv_group()) diff --git a/rs/moq-net/tests/integration/widened_max_age.rs b/rs/moq-net/tests/integration/widened_max_age.rs index b065eaf6366..2fffea38e39 100644 --- a/rs/moq-net/tests/integration/widened_max_age.rs +++ b/rs/moq-net/tests/integration/widened_max_age.rs @@ -94,7 +94,11 @@ impl Chain { fn populate(&self) { for key in 0..GROUPS { - let mut group = self.source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = self + .source + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); @@ -314,7 +318,10 @@ async fn wider_newcomers_after_the_first_pull_nothing_upstream() { .unwrap(); let source = broadcast.broadcast().create_track("video", timed()).unwrap(); for key in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = source + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); @@ -375,7 +382,10 @@ async fn a_legacy_viewer_beating_a_relay_copy_joins_at_the_live_edge() { let source = route.broadcast().create_track("video", timed()).unwrap(); route.announce().unwrap(); for key in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = source + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); diff --git a/rs/moq-relay/tests/integration/connection.rs b/rs/moq-relay/tests/integration/connection.rs index 0b5c441a3f6..c98438da553 100644 --- a/rs/moq-relay/tests/integration/connection.rs +++ b/rs/moq-relay/tests/integration/connection.rs @@ -64,7 +64,10 @@ async fn largest_quic_sequence_reaches_the_subscriber() { true => moq_net::Timestamp::unscaled(sequence), false => moq_net::Timestamp::from_micros(sequence.min((1 << 61) - 1)).unwrap(), }; - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); group.write_frame(timestamp, b"ladder".as_ref()).unwrap(); group.finish().unwrap(); let mut got = kio::clock::timeout(TIMEOUT, sub.recv_group()) diff --git a/rs/moq-relay/tests/integration/quic_sim.rs b/rs/moq-relay/tests/integration/quic_sim.rs index ce82a012cc5..50fe48897e5 100644 --- a/rs/moq-relay/tests/integration/quic_sim.rs +++ b/rs/moq-relay/tests/integration/quic_sim.rs @@ -147,7 +147,10 @@ async fn deliver(network: &Network, publish: &Relay, subscribe: &Relay) -> Vec Arrivals { let mut source = source.clone(); while source.subscription_changed().await.unwrap().is_none() {} for sequence in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = source + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let timestamp = Timestamp::from_millis(sequence * INTERVAL.as_millis() as u64).unwrap(); group.write_frame(timestamp, vec![sequence as u8; FRAME]).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-tokio/tests/integration/sim_client.rs b/rs/moq-tokio/tests/integration/sim_client.rs index 9e7fb6a2e75..b7eaf6d7066 100644 --- a/rs/moq-tokio/tests/integration/sim_client.rs +++ b/rs/moq-tokio/tests/integration/sim_client.rs @@ -272,7 +272,10 @@ impl Publisher { let mut source = self.track.clone(); while source.subscription_changed().await.unwrap().is_none() {} for sequence in 0..GROUPS { - let mut group = source.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = source + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let timestamp = Timestamp::from_millis(sequence * INTERVAL.as_millis() as u64).unwrap(); group.write_frame(timestamp, vec![sequence as u8; FRAME]).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-transcode/src/rung.rs b/rs/moq-transcode/src/rung.rs index b21189e8d75..65dd043c3a5 100644 --- a/rs/moq-transcode/src/rung.rs +++ b/rs/moq-transcode/src/rung.rs @@ -1362,7 +1362,8 @@ mod tests { track.start_at(HOUR).unwrap(); track .create_group(moq_net::group::Info { start: HOUR }) - .unwrap().unwrap() + .unwrap() + .unwrap() .finish() .unwrap(); let waiter = kio::Waiter::noop(); diff --git a/rs/moq-video/src/decode/consumer.rs b/rs/moq-video/src/decode/consumer.rs index 9ada9021dda..36616c4dbdc 100644 --- a/rs/moq-video/src/decode/consumer.rs +++ b/rs/moq-video/src/decode/consumer.rs @@ -827,7 +827,10 @@ mod tests { .unwrap(); let wire = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Video); let write = |sequence, stamps: &[u64]| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let frames: Vec<_> = stamps .iter() .enumerate() @@ -1243,7 +1246,10 @@ mod tests { .unwrap(); let wire = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Video); let write = |sequence, stamps: &[u64]| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let frames: Vec<_> = stamps .iter() .enumerate() @@ -1530,7 +1536,8 @@ mod tests { landed.push(Instant::now()); let mut group = track .create_group(moq_net::group::Info { start: sequence as u64 }) - .unwrap().unwrap(); + .unwrap() + .unwrap(); wire.write( &mut group, &[moq_mux::container::Frame { From 80a492fbd10bd43794679925967c2429192f02f9 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 21:46:25 -0800 Subject: [PATCH 4/8] fix: interop and audio-quality createGroup callers, and the Go pause-marker test after Opus durations Co-Authored-By: Claude Opus 5.5 --- go/wrapper/moq_test.go | 10 +++++----- test/audio-quality/clients/js/src/capture.test.ts | 2 ++ test/interop/clients/js-native/replace.ts | 1 + test/interop/clients/js-native/tail.ts | 1 + test/interop/clients/js/open-gop/main.ts | 1 + test/interop/track-status.ts | 1 + 6 files changed, 11 insertions(+), 5 deletions(-) diff --git a/go/wrapper/moq_test.go b/go/wrapper/moq_test.go index 5303a18f2f0..60e42b9ff59 100644 --- a/go/wrapper/moq_test.go +++ b/go/wrapper/moq_test.go @@ -1375,9 +1375,9 @@ func TestDynamicTrackRequestCanPublishAudio(t *testing.T) { if string(frame.Payload) != string(payload) || durationOf(t, frame.Timestamp) != 20*time.Millisecond { t.Fatalf("frame = %+v, want payload=%q ts=20000", frame, payload) } - // The explicit pause marker is an encoder end even while the track stays open. The marker - // is a group of its own, and group starts strictly increase, so it ends one microsecond past - // the frame's group: the producer doesn't parse how long the packet runs. + // The explicit pause marker is an encoder end even while the track stays open. The importer + // reads the packet's duration from its TOC byte ('d' is a 10ms hybrid frame), and the marker + // sits one microsecond before that frame's end, so what resumes there starts after it. if err := media.Discontinuity(); err != nil { t.Fatal(err) } @@ -1388,8 +1388,8 @@ func TestDynamicTrackRequestCanPublishAudio(t *testing.T) { if err != nil { t.Fatal(err) } - if value, ok := end.(moqmedia.ReadEnd); !ok || durationOf(t, value.End) != 20*time.Millisecond+time.Microsecond { - t.Fatalf("expected encoder end at 20001us, got %T %+v", end, end) + if value, ok := end.(moqmedia.ReadEnd); !ok || durationOf(t, value.End) != 30*time.Millisecond-time.Microsecond { + t.Fatalf("expected encoder end at 29999us, got %T %+v", end, end) } if next, err := mediaConsumer.Next(ctx); next != nil || err != nil { t.Fatalf("after finish: %v %v", next, err) diff --git a/test/audio-quality/clients/js/src/capture.test.ts b/test/audio-quality/clients/js/src/capture.test.ts index 422cfe27c38..cacdb74da40 100644 --- a/test/audio-quality/clients/js/src/capture.test.ts +++ b/test/audio-quality/clients/js/src/capture.test.ts @@ -180,10 +180,12 @@ test("the observer reads the publisher's largest group as its subscription began try { while (!track.subscription.peek()) await track.subscription.changed(); const first = track.createGroup(7n); + if (!first) throw new Error("group 7 already exists"); frame(first, 0); while (capture.largest() === undefined) await yieldNow(); // Live groups landing after the answer raise the track's largest, not the join's. const later = track.createGroup(12n); + if (!later) throw new Error("group 12 already exists"); frame(later, 20_000); const seen: Arrival[] = []; while (seen.length < 2) { diff --git a/test/interop/clients/js-native/replace.ts b/test/interop/clients/js-native/replace.ts index 6f0952838d2..6cb739e7f92 100644 --- a/test/interop/clients/js-native/replace.ts +++ b/test/interop/clients/js-native/replace.ts @@ -38,6 +38,7 @@ function replacement(): Moq.Track.Producer { function write(sequence: bigint): void { const group = track.createGroup(sequence); + if (!group) throw new Error(`group ${sequence} already exists`); group.writeFrame({ payload: new TextEncoder().encode(String(sequence)), timestamp: Moq.Time.Timestamp.unscaled(sequence), diff --git a/test/interop/clients/js-native/tail.ts b/test/interop/clients/js-native/tail.ts index 5b399aebedc..a399931969e 100644 --- a/test/interop/clients/js-native/tail.ts +++ b/test/interop/clients/js-native/tail.ts @@ -90,6 +90,7 @@ function write(track: Moq.Track.Producer) { function serveHistory(track: Moq.Track.Producer) { track.finishAt({ group: BigInt(GROUPS), frame: 0 }); const live = track.createGroup(BigInt(GROUPS - 1)); + if (!live) throw new Error("the live group already exists"); for (const payload of frames(GROUPS - 1)) live.writeFrame({ payload, timestamp: Moq.Time.Timestamp.unscaled(live.start) }); live.finish(); diff --git a/test/interop/clients/js/open-gop/main.ts b/test/interop/clients/js/open-gop/main.ts index 38164fd17a1..25024d5f4e5 100644 --- a/test/interop/clients/js/open-gop/main.ts +++ b/test/interop/clients/js/open-gop/main.ts @@ -69,6 +69,7 @@ window.runRecovery = async (packets) => { if (group?.start !== BigInt(packet.group)) { group?.finish(); group = track.createGroup(BigInt(packet.group)); + if (!group) throw new Error(`group ${packet.group} already exists`); } const timestamp = Duration.micros(packet.timestamp); const payload = Uint8Array.from(atob(packet.data), (c) => c.charCodeAt(0)); diff --git a/test/interop/track-status.ts b/test/interop/track-status.ts index 059ca0757c6..9b67e50ad79 100644 --- a/test/interop/track-status.ts +++ b/test/interop/track-status.ts @@ -28,6 +28,7 @@ const track = broadcast.createTrack("video", { }); if (!track) throw new Error("the track already exists"); const group = track.createGroup(4n); +if (!group) throw new Error("group 4 already exists"); group.writeFrame({ payload: new Uint8Array([1]), timestamp: Timestamp.fromMillis(0) }); group.writeFrame({ payload: new Uint8Array([2]), timestamp: Timestamp.fromMillis(1) }); From 0521468d5bff3b488481b8a85fd43c2c2f456354 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 20 Nov 2026 03:48:45 -0800 Subject: [PATCH 5/8] style: rustfmt the merged create_group call sites Co-Authored-By: Claude Opus 5.5 --- rs/moq-audio/src/decode/consumer.rs | 5 +++- rs/moq-hls/src/export/mod.rs | 23 +++++++++++--- rs/moq-mux/src/container/consumer.rs | 30 +++++++++++++++---- rs/moq-net/tests/integration/range_anchors.rs | 10 +++++-- 4 files changed, 56 insertions(+), 12 deletions(-) diff --git a/rs/moq-audio/src/decode/consumer.rs b/rs/moq-audio/src/decode/consumer.rs index 30781692f7c..153fffb12e9 100644 --- a/rs/moq-audio/src/decode/consumer.rs +++ b/rs/moq-audio/src/decode/consumer.rs @@ -3084,7 +3084,10 @@ mod tests { let container = moq_mux::catalog::hang::Container::Legacy(moq_mux::container::Kind::Audio); let payload: Bytes = vec![0u8; 160 * size_of::()].into(); let write = |sequence: u64| { - let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: sequence }) + .unwrap() + .unwrap(); let frame = moq_mux::container::Frame { timestamp: Timestamp::from_micros(sequence * 20_000).unwrap(), duration: None, diff --git a/rs/moq-hls/src/export/mod.rs b/rs/moq-hls/src/export/mod.rs index d07c8a17100..8114e476f68 100644 --- a/rs/moq-hls/src/export/mod.rs +++ b/rs/moq-hls/src/export/mod.rs @@ -3653,7 +3653,11 @@ mod tests { /// Write the group starting at `pts_ms` with a keyframe there and, when `frames` is more /// than one, that many frames a tenth of the interval apart. fn group(&mut self, pts_ms: u64, frames: u64) { - let mut group = self.track.create_group(moq_net::group::Info { start: pts_ms }).unwrap().unwrap(); + let mut group = self + .track + .create_group(moq_net::group::Info { start: pts_ms }) + .unwrap() + .unwrap(); for index in 0..frames.max(1) { let micros = (pts_ms + index * INTERVAL.as_millis() as u64 / 10) * 1_000; let frame = vp8_frame(micros, index == 0); @@ -3692,7 +3696,11 @@ mod tests { /// Write the group at `pts_ms` with a single keyframe declaring a `width`x`height` /// picture in band. fn sized(&mut self, pts_ms: u64, (width, height): (u16, u16)) { - let mut group = self.track.create_group(moq_net::group::Info { start: pts_ms }).unwrap().unwrap(); + let mut group = self + .track + .create_group(moq_net::group::Info { start: pts_ms }) + .unwrap() + .unwrap(); let mut payload = KEYFRAME.to_vec(); payload[6..8].copy_from_slice(&width.to_le_bytes()); payload[8..10].copy_from_slice(&height.to_le_bytes()); @@ -3712,7 +3720,11 @@ mod tests { /// Start the group at `pts_ms` with a keyframe, leaving it open for more frames. fn open(&mut self, pts_ms: u64) -> moq_net::group::Producer { - let mut group = self.track.create_group(moq_net::group::Info { start: pts_ms }).unwrap().unwrap(); + let mut group = self + .track + .create_group(moq_net::group::Info { start: pts_ms }) + .unwrap() + .unwrap(); let frame = vp8_frame(pts_ms * 1_000, true); hang::container::Frame { timestamp: frame.timestamp, @@ -4099,7 +4111,10 @@ mod tests { .step_by(100) .map(|ms| vp8_frame(ms * 1_000, ms == pts_ms)) .collect(); - let mut group = track.create_group(moq_net::group::Info { start: pts_ms }).unwrap().unwrap(); + let mut group = track + .create_group(moq_net::group::Info { start: pts_ms }) + .unwrap() + .unwrap(); let bytes = muxer.fragment(sequence as u32, &frames, None).unwrap(); group.write_frame(frames[0].timestamp, bytes).unwrap(); group.finish().unwrap(); diff --git a/rs/moq-mux/src/container/consumer.rs b/rs/moq-mux/src/container/consumer.rs index 9eae151c73e..4d73a9869fe 100644 --- a/rs/moq-mux/src/container/consumer.rs +++ b/rs/moq-mux/src/container/consumer.rs @@ -1999,7 +1999,11 @@ mod tests { let mut reader = copy.reader(Delay::default().with_min(None).with_max(budget)).await; write_group(&mut copy.track, 0, &[ts(10_000)]); assert!(matches!(reader.read().await.unwrap(), Some(Read::Frame { .. }))); - let mut marker = copy.track.create_group(moq_net::group::Info { start: 2 }).unwrap().unwrap(); + let mut marker = copy + .track + .create_group(moq_net::group::Info { start: 2 }) + .unwrap() + .unwrap(); marker.write_frame(ts(20_000), Bytes::new()).unwrap(); marker.finish().unwrap(); carried().await; @@ -2064,7 +2068,11 @@ mod tests { reader.read().await.unwrap(), Some(Read::Frame { group: 2, .. }) )); - let mut marker = copy.track.create_group(moq_net::group::Info { start: 4 }).unwrap().unwrap(); + let mut marker = copy + .track + .create_group(moq_net::group::Info { start: 4 }) + .unwrap() + .unwrap(); marker.write_frame(ts(30_000), Bytes::new()).unwrap(); marker.finish().unwrap(); carried().await; @@ -2533,7 +2541,11 @@ mod tests { }; // A stalled group 500 ms behind the newest content is still within the max delay. - let mut stalled = copy.track.create_group(moq_net::group::Info { start: 0 }).unwrap().unwrap(); + let mut stalled = copy + .track + .create_group(moq_net::group::Info { start: 0 }) + .unwrap() + .unwrap(); let frame = Frame { timestamp: ts(0), payload: Bytes::from_static(&[0xDE, 0xAD]), @@ -3496,7 +3508,11 @@ mod tests { write_group(&mut copy.track, 0, &[ts(0)]); carried().await; // The end, then the stopped encoder's final packet, as `moq_audio`'s producer writes them. - let mut group = copy.track.create_group(moq_net::group::Info { start: 1 }).unwrap().unwrap(); + let mut group = copy + .track + .create_group(moq_net::group::Info { start: 1 }) + .unwrap() + .unwrap(); let frame = |timestamp, payload| Frame { timestamp, payload, @@ -5441,7 +5457,11 @@ mod tests { for sequence in 0..5 { write_group(&mut copy.track, sequence, &[ts(sequence * 100_000)]); } - let mut newest = copy.track.create_group(moq_net::group::Info { start: 5 }).unwrap().unwrap(); + let mut newest = copy + .track + .create_group(moq_net::group::Info { start: 5 }) + .unwrap() + .unwrap(); let subscriber = copy .subscribe_with( moq_net::track::Subscription::default() diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index 1c188b31f9b..d8813f32963 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -85,7 +85,10 @@ async fn read_as(version: Option<&str>, range: Range, how: Read) -> Result track.append_group(millis(key)).unwrap(), - false => track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(), + false => track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(), }; group.write_frame(millis(key), &b"x"[..]).unwrap(); group.finish().unwrap(); @@ -145,7 +148,10 @@ async fn read_as(version: Option<&str>, range: Range, how: Read) -> Result Date: Fri, 20 Nov 2026 17:54:07 -0800 Subject: [PATCH 6/8] test(js/net): a createGroup that must throw asserts the call, not defined() Co-Authored-By: Claude Opus 5.5 --- js/net/src/group-id.test.ts | 4 ++-- js/net/src/track.test.ts | 20 ++++++++++---------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/js/net/src/group-id.test.ts b/js/net/src/group-id.test.ts index 1a60ec12908..6a00edc3cf3 100644 --- a/js/net/src/group-id.test.ts +++ b/js/net/src/group-id.test.ts @@ -157,8 +157,8 @@ for (const wire of WIRES) { test("a group sequence that is not a non-negative bigint is refused where a caller passes one", async () => { const track = defined(new BroadcastProducer().createTrack("video")); // A plain JS caller can still pass a number, which would otherwise mix with bigints later. - expect(() => defined(track.createGroup(1 as unknown as bigint))).toThrow(TypeError); - expect(() => defined(track.createGroup(-1n))).toThrow(RangeError); + expect(() => track.createGroup(1 as unknown as bigint)).toThrow(TypeError); + expect(() => track.createGroup(-1n)).toThrow(RangeError); expect(defined(track.createGroup(MAX_QUIC)).start).toBe(MAX_QUIC); const consumer = new BroadcastProducer().consume().track("video"); await expect(consumer.fetchGroup(1 as unknown as bigint)).rejects.toThrow(TypeError); diff --git a/js/net/src/track.test.ts b/js/net/src/track.test.ts index 9f13058b104..45b9304bc50 100644 --- a/js/net/src/track.test.ts +++ b/js/net/src/track.test.ts @@ -3832,7 +3832,7 @@ test("a scale-less single-frame write lands at its key", () => { producer.writeFrame({ payload: enc.encode("c"), timestamp: Timestamp.unscaled(5n) }); expect(drain(subscriber)).toEqual([3n, 5n]); // The keys below each write are skipped, so creating one is refused. - expect(() => defined(producer.createGroup(4n))).toThrow(Skipped); + expect(() => producer.createGroup(4n)).toThrow(Skipped); }); // An explicit start is a floor, not a request: the budget still skips what it finds stale @@ -4515,7 +4515,7 @@ test.each([true, false])("a mid-group end caps later writes (declared first: %s) group.writeFrame({ payload: new Uint8Array([2]), timestamp: Timestamp.unscaled(group.start) }), ).toThrow("past the track's end"); expect(group.consume().frameCount).toBe(2); - expect(() => defined(producer.createGroup(6n))).toThrow(); + expect(() => producer.createGroup(6n)).toThrow("at or past the track's end"); producer.finish(); producer.close(); }); @@ -5380,7 +5380,7 @@ test("fail ends at the live edge and leaves an end already given", async () => { latest.writeFrame(textFrame("c", Timestamp.fromMillis(2))); latest.finish(); producer.fail(failed); - expect(() => defined(producer.createGroup(3n))).toThrow(); + expect(() => producer.createGroup(3n)).toThrow("at or past the track's end"); const late = defined(producer.createGroup(1n)); late.writeFrame(textFrame("b", Timestamp.fromMillis(1))); late.finish(); @@ -5492,17 +5492,17 @@ test("creating a skipped sequence throws Skipped", () => { defined(producer.createGroup(0n)).finish(); defined(producer.createGroup(3n)).finish(); hooks.appendNext(producer).finish(); - expect(() => defined(producer.createGroup(1n))).toThrow(Skipped); + expect(() => producer.createGroup(1n)).toThrow(Skipped); producer.skipGroups(5n, 7n); - expect(() => defined(producer.createGroup(6n))).toThrow(Skipped); + expect(() => producer.createGroup(6n)).toThrow(Skipped); // No skip below group 0. expect(() => producer.skipGroups(-1n, 1n)).toThrow(RangeError); // The next sequence, 5, was skipped too. expect(() => hooks.appendNext(producer)).toThrow(Skipped); // A later drop leaves a skipped sequence skipped. expect(hooks.dropTrackGroups(producer, 1n, 2n, { error: DROPPED })).toEqual([]); - expect(() => defined(producer.createGroup(1n))).toThrow(Skipped); + expect(() => producer.createGroup(1n)).toThrow(Skipped); // A dropped sequence may be created again. hooks.dropTrackGroups(producer, 9n, 10n, { error: DROPPED }); defined(producer.createGroup(9n)).finish(); @@ -5557,7 +5557,7 @@ test("a skip is reported over a reported drop", () => { expect(hooks.dropTrackGroups(producer, 2n, 3n, { error: DROPPED })).toEqual([]); expect(drain()).toEqual([]); - expect(() => defined(producer.createGroup(2n))).toThrow(Skipped); + expect(() => producer.createGroup(2n)).toThrow(Skipped); reader.close(); producer.close(); }); @@ -5597,8 +5597,8 @@ test("a huge skip costs one run", () => { test("the reserved sequence is refused", () => { const reserved = (1n << 64n) - 1n; const producer = new TrackProducer("test").accept({}); - expect(() => defined(producer.createGroup(1n << 64n))).toThrow(RangeError); - expect(() => defined(producer.createGroup(reserved))).toThrow(RangeError); + expect(() => producer.createGroup(1n << 64n)).toThrow(RangeError); + expect(() => producer.createGroup(reserved)).toThrow(RangeError); expect(() => hooks.receiveGroup(producer, { start: reserved, offset: 0 })).toThrow(RangeError); defined(producer.createGroup(reserved - 1n)).finish(); expect(() => hooks.appendNext(producer)).toThrow(RangeError); @@ -5616,7 +5616,7 @@ test("finishing returns handles that write nothing new but fill a late group", a const finished = producer.finish(); // @ts-expect-error a finished track appends no group expect(() => finished.appendGroup(Timestamp.unscaled(2n))).toThrow("at or past the track's end"); - expect(() => defined(finished.createGroup(2n))).toThrow("at or past the track's end"); + expect(() => finished.createGroup(2n)).toThrow("at or past the track's end"); const late = defined(finished.createGroup(0n)); late.writeFrame(textFrame("late", Timestamp.fromMillis(Number(late.start)))); From 71db8a2040429d8676aaa4a01665f9edfafa40d2 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 20 Nov 2026 18:02:00 -0800 Subject: [PATCH 7/8] style: fmt the merge's unwraps Co-Authored-By: Claude Opus 5.5 --- rs/libmoq/src/test.rs | 5 ++++- rs/moq-net/tests/integration/time_start_fill.rs | 8 +++++++- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/rs/libmoq/src/test.rs b/rs/libmoq/src/test.rs index 8356e4a6dbe..912c048c6b2 100644 --- a/rs/libmoq/src/test.rs +++ b/rs/libmoq/src/test.rs @@ -5499,7 +5499,10 @@ fn a_freed_time_start_reads_on_and_an_aborted_one_fails() { let producer = state.publish.track_producer(Id::try_from(track).unwrap()).unwrap(); producer.start_at(held[0]).unwrap(); for &key in held { - let mut group = producer.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(); + let mut group = producer + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(); group .write_frame(moq_net::Timestamp::from_millis(key).unwrap(), &b"live"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/time_start_fill.rs b/rs/moq-net/tests/integration/time_start_fill.rs index a2970f3b8a3..5c46a65d5c1 100644 --- a/rs/moq-net/tests/integration/time_start_fill.rs +++ b/rs/moq-net/tests/integration/time_start_fill.rs @@ -88,7 +88,13 @@ async fn read(range: Range, by_time: bool) -> (BTreeSet, Vec<(u64, u64)>) { broadcast.announce().unwrap(); track.start_at(4000).unwrap(); for key in [4000, 5000] { - write(track.create_group(moq_net::group::Info { start: key }).unwrap().unwrap(), key); + write( + track + .create_group(moq_net::group::Info { start: key }) + .unwrap() + .unwrap(), + key, + ); } let subscriber = produce_origin(2); From 9967d580f70124c30f1655e7fe0bdd8ad0330fdf Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 20 Nov 2026 18:47:31 -0800 Subject: [PATCH 8/8] quest: the outcome-enums epic finishes with its last child Co-Authored-By: Claude Opus 5.5 --- quest/m2/outcome-enums/README.md | 36 ------------------------------- quest/m4/outcome-enums-private.md | 3 ++- 2 files changed, 2 insertions(+), 37 deletions(-) delete mode 100644 quest/m2/outcome-enums/README.md diff --git a/quest/m2/outcome-enums/README.md b/quest/m2/outcome-enums/README.md deleted file mode 100644 index 340a8b6757d..00000000000 --- a/quest/m2/outcome-enums/README.md +++ /dev/null @@ -1,36 +0,0 @@ -# Public functions return what their callers use - -## Goal - -No public function in Rust, JS, or the bindings returns an outcome enum whose -callers collapse it the same way, one that is a `bool`, `Option`, `Poll`, or -`Result` in disguise, or an error variant that means a normal outcome. Each -child reshapes one surface in every language that mirrors it. Enums whose -variants callers really handle differently stay: sans-IO events, stream items -such as `Read { Frame, Gap, End }`, and state transitions. - -## Plan - -Planned 2026-11-18 (maintainer, /quest-plan of an audit of about 200 -functions that return an enum, across Rust, JS, and the bindings). The -audit found about 60 that should change shape, most of them private; the -public ones are this epic's children, and the private ones are -[the private sweep](/quest/m4/outcome-enums-private.md). - -Decided: - -- ✅ Fix public and private shapes, with REVIEW.md's "Return what callers - use" rule (added by this plan's PR) so new ones get flagged (rejected: - public API only; the rule alone; also reshaping vendored code). Vendored - code is out of scope: moq-rtmp's `rml` and moq-congestion's libwebrtc port. -- ✅ An error variant that means a normal outcome follows the - [moq-dev/moq#9041](https://github.com/moq-dev/moq/pull/9041) ruling: first - ask whether the caller needs to tell the case apart at all, and abort on any - error when it does not. -- ✅ moq-quic's API changes freely: compatibility with quinn is not a goal - (2026-11-18, maintainer). - -The test the audit applied: when two callers collapse an enum the same way, -the API should return the collapsed form. - -Public API: every child is breaking; each lists its migration. Wire: none. diff --git a/quest/m4/outcome-enums-private.md b/quest/m4/outcome-enums-private.md index cf784253177..e1a91c5debe 100644 --- a/quest/m4/outcome-enums-private.md +++ b/quest/m4/outcome-enums-private.md @@ -10,7 +10,8 @@ callers collapse the same way. No public API changes. ## Plan From the 2026-11-18 enum-return audit (maintainer, /quest-plan); the public -half is the [outcome-enums epic](/quest/m2/outcome-enums/README.md). m4, +half was the m2 outcome-enums epic, finished by +[moq-dev/moq#9223](https://github.com/moq-dev/moq/pull/9223). m4, since nothing waits on it and it changes no API. Judge each against REVIEW.md's "Return what callers use"; keep one whose named variants read better than the bare type at its one call site, and say so in the PR.