diff --git a/doc/lib/rs/moq-net.md b/doc/lib/rs/moq-net.md index c01fa09c7fa..59ed9d11f9b 100644 --- a/doc/lib/rs/moq-net.md +++ b/doc/lib/rs/moq-net.md @@ -25,7 +25,7 @@ What you use it for, beyond what the concept page already describes: - **Dial and accept sockets.** `socket::Endpoint::new(&origin, prefix, id)` is a server, a client, or both: its first dial announces a hidden client endpoint at `/.client/`, and its first accept a hidden server endpoint at `/.server/`, both used only to route sessions, so grants decide which roles it may take. A session speaks one of two protocols, each with its own dial and accept. `accept_tcp()` and `accept_track()` yield an `Incoming` dial to `accept` or `reject` (dropping it rejects). `dial_tcp(server)` and an accepted `tcp` dial yield a `socket::TcpStream`, a `group::Producer` and `group::Consumer` pair carrying one reliable, ordered byte pipe each way (finish is FIN, abort is RST, and `ready` paces the writer to the reader); `dial_track(server, info)` and an accepted `track` dial yield a `socket::TrackStream`, this side's `track::Producer` and a `track::Subscriber` of the peer's half, subscribed reliably and in order until the application updates it, one message per group. A dial resolves once the peer accepts, and an accept checks that the claimed dialer really dialed this endpoint, waiting for its endpoint while the dial stays open. Every hop needs moq-lite-07 or moq-transport: while the origin has an older moq-lite client session whose publish half doesn't opt into hidden broadcasts (`with_hidden(true)`), dials and accepts fail with `Unsupported`. A dial to a peer behind such a hop waits, as for a peer not online yet. Session tracks are never announced or listed. See [Sockets](/concept/socket). - **One track per name.** Concurrent subscriptions share one request and producer. The application owns sequence numbers: the broadcast keeps nothing of an ended track, so a producer that replaces it starts at 0. A name always means the same content, so the replacement continues past its predecessor's groups with `create_group` at an explicit sequence. Readers of an aborted track resume onto the replacement when they read through an origin request, whose route always names an instance; otherwise their subscription ends with the error. - **Authored tracks default to a zero `max_age`.** `track::Info::default()` sets `max_age` to `Some(Duration::ZERO)`, the live edge only; a publisher that wants readers to reach history sets a longer bound, or `with_max_age(None)` for no publisher limit. Media tracks from `hang::container::track_info` declare `hang::container::MAX_AGE` (30 seconds). `max_age` is how long a superseded group stays fresh, never the newest group; it frees no bytes, which the cache pool's expiry reclaims. Received metadata keeps absence as no limit, and an origin's `cache_duration` can only cap it lower. -- **End content by finishing tracks.** A broadcast has no finished state. When the input ends, finish each track; the broadcast stays announced and keeps serving them until you close it or drop its route. How long to keep it up for late readers is yours to decide: `moq_mux::Linger` holds a hang broadcast for a fixed window. +- **End content by finishing tracks.** A broadcast has no finished state. When the input ends, finish each track: `finish(self)` consumes the producer and returns a `track::Finished`, which can still take an older group below the end, be read, or be aborted, but not append. Hold it, and the broadcast stays announced and keeps serving the track until you close it or drop its route; dropping the last handle releases the track, so new readers no longer find it. How long to keep it up for late readers is yours to decide: `moq_mux::Linger` holds a hang broadcast for a fixed window. A finished group returns a `group::Finished`, which can be read or aborted to release its cache. - **Demand says whether anyone is watching.** `demand()` on a track, group, or broadcast says whether a subscriber is attached. First-party capture does not wait for it: video encodes while enabled and audio keeps raw PCM to encode when someone listens, so a late subscription's `delay.max` or a FETCH finds the recent past. Demand gates bandwidth reservations, transcode rungs, and on-demand video where a publisher opts in, which saves the encode but leaves nothing from before the first subscriber. Holding a broadcast or track consumer is not demand: a track consumer requests nothing until it queries, subscribes, or fetches, and those count until dropped. A shared fetch stays up until its last reader leaves. Demand rolls up: a frame being read keeps its group wanted, a group a subscription or fetch handed out keeps its track wanted until read to its end, and any wanted track keeps its broadcast wanted. - **Use the model without a runtime.** By default `moq-net` is its `poll_*` APIs and origin driver with caller-supplied time. The `async` feature adds their async wrappers, `time::run`, and both wire sessions. - **You drive the session, or `moq-tokio` does.** `connect` and `accept` return a session plus a driver that never reads the clock itself. `moq_net::time::run` polls it on tokio. `moq-tokio` hides that. A custom transport implements `moq_net::transport::poll`, and `moq_net::transport::memory::pair` links two sessions in one process with no sockets, for tests or in-process links. `Server` bounds each accept with one deadline (10 s by default, `with_timeout`) across SETUP, your admission decision (`Handshake::expired`), and moq-lite 01/02's SETUP reply, and opens a receive window the transport held back once you admit (`with_receive_window`). diff --git a/js/net/api/index.api.md b/js/net/api/index.api.md index 89a479f6323..b757c80cddf 100644 --- a/js/net/api/index.api.md +++ b/js/net/api/index.api.md @@ -404,6 +404,11 @@ export namespace Group { sequence: number; } & Group.Frame | undefined; } + export interface Finished { + readonly closed: Signals.GetPromise; + consume(): Group.Consumer; + readonly sequence: bigint; + } export interface Frame { arrived?: Instant; payload: Uint8Array; @@ -418,7 +423,7 @@ export namespace Group { get closed(): Signals.GetPromise; consume(): Group.Consumer; createFrame(info: Frame.Info): Frame.Producer; - finish(): void; + finish(): Group.Finished; get isClosed(): boolean; readonly sequence: bigint; writeFrame(frame: Group.Frame): void; @@ -731,6 +736,16 @@ export namespace Track { wanted(): bigint | undefined; wantedChanged(): Promise; } + export interface Finished { + abort(error: Error): void; + close(): void; + readonly closed: Signals.GetPromise; + createGroup(sequence: bigint): Group.Producer; + info(): Promise; + readonly name: string; + requests(): Track.Requests; + subscribe(options?: Track.Subscription): Track.Subscriber; + } export interface Groups { end?: Track.Bound; start?: Track.Bound; @@ -781,7 +796,7 @@ export namespace Track { get closed(): Signals.GetPromise; createGroup(sequence: bigint): Group.Producer; demand(): Track.Demand; - finish(): void; + finish(): Track.Finished; finishAt(end: Track.Position, error?: Error): void; info(): Promise; largest(): Track.Position | undefined; diff --git a/js/net/bench/frames.ts b/js/net/bench/frames.ts index 7c9664694aa..9f6a6d0407a 100644 --- a/js/net/bench/frames.ts +++ b/js/net/bench/frames.ts @@ -54,7 +54,9 @@ const lite: Protocol = { const producer = new Producer(0n); const done = readFrames(new Reader(stream, undefined, LiteVersion.DRAFT_06), producer, { scale: 1_000_000, - }).then(() => producer.finish()); + }).then(() => { + producer.finish(); + }); return { group: Promise.resolve(producer.consume()), done }; }; return { open, close: () => {} }; diff --git a/js/net/src/group.ts b/js/net/src/group.ts index 993b5769270..85bacec82b5 100644 --- a/js/net/src/group.ts +++ b/js/net/src/group.ts @@ -210,6 +210,22 @@ export class Demand { } } +/** + * A group its producer finished: every frame is written, and it can still be read, but not + * written to. {@link Producer.finish} returns it, mirroring the Rust `group::Finished`; the + * producer itself still refuses a write after the finish. + * + * @public + */ +export interface Finished { + /** Sequence number of this group within its track. */ + readonly sequence: bigint; + /** Settles once the group closes: `null` on a clean close, or the abort {@link Error}. */ + readonly closed: GetPromise; + /** A read handle for this group. */ + consume(): Consumer; +} + /** * The write side of an ordered stream of frames within a track. * @@ -644,9 +660,13 @@ export class Producer { return this.#state.closed.peek() !== undefined; } - /** Marks the group complete: no more frames will be written. Idempotent. */ - finish() { + /** + * Marks the group complete, returning it as {@link Finished}: no more frames will be written. + * Idempotent. + */ + finish(): Finished { this.#end(null); + return this; } /** diff --git a/js/net/src/ietf/publisher.ts b/js/net/src/ietf/publisher.ts index 4131a963d74..d544aff56a2 100644 --- a/js/net/src/ietf/publisher.ts +++ b/js/net/src/ietf/publisher.ts @@ -899,7 +899,9 @@ export class Publisher { timescale, priority: datagramPriority, }).then( - () => datagramTrack?.finish(), + () => { + datagramTrack?.finish(); + }, (err: unknown) => { if (datagramTrack) datagramTrack.abort(error(err)); else console.debug(`stopping datagrams on this subscription: ${reason(err)}`); diff --git a/js/net/src/track.test.ts b/js/net/src/track.test.ts index 3b67446552a..c4ce08e5758 100644 --- a/js/net/src/track.test.ts +++ b/js/net/src/track.test.ts @@ -4722,3 +4722,31 @@ test("group sequences stop at 2^64-1, as a u64 does", () => { producer.skipGroups(1n << 63n, 1n << 64n); expect(() => producer.skipGroups(0n, (1n << 64n) + 1n)).toThrow(RangeError); }); + +// Mirrors the Rust `track::Finished` doctests: the handle `finish` returns takes no new +// writes, at compile time and at run time, yet still fills a late group below the end. +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: { absolute: 0n } }] }); + producer.createGroup(1n).finish(); + const finished = producer.finish(); + // @ts-expect-error a finished track appends no group + expect(() => finished.appendGroup()).toThrow("at or past the track's end"); + expect(() => finished.createGroup(2n)).toThrow("at or past the track's end"); + + const late = finished.createGroup(0n); + late.writeFrame(textFrame("late")); + const group = late.finish(); + // @ts-expect-error a finished group takes no frame + expect(() => group.writeFrame(textFrame("later"))).toThrow(); + const reader = group.consume(); + expect(dec.decode((await reader.readFrame())?.payload)).toBe("late"); + expect(await reader.readFrame()).toBeUndefined(); + expect(await group.closed).toBeNull(); + + const got: bigint[] = []; + for (let next = subscriber.tryRecvGroup(); next; next = subscriber.tryRecvGroup()) got.push(next.sequence); + expect(got.sort()).toEqual([0n, 1n]); + expect(hooks.tryRecvGroup(subscriber, false)).toEqual({ kind: "done" }); + finished.close(); +}); diff --git a/js/net/src/track.ts b/js/net/src/track.ts index dcd15b6245e..53bd22673e8 100644 --- a/js/net/src/track.ts +++ b/js/net/src/track.ts @@ -2116,15 +2116,18 @@ export class Producer { } /** - * Declare the track's end after the highest sequence written. A no-op once an end is declared or the track closed, - * so a cleanup path can finish whatever the track's state. + * Declare the track's end after the highest sequence written, returning it as {@link Finished}. + * A no-op once an end is declared or the track closed, so a cleanup path can finish whatever + * the track's state. A track that closed first keeps its outcome and declares no end, so its + * readers' `finished()` rejects. * * Not terminal: groups below the end may still be written. Readers end once the live edge * reaches it. */ - finish(): void { - if (this.#state.end.peek() !== undefined || this.#state.closed.peek() !== undefined) return; - this.finishAt({ group: this.#received, frame: 0 }); + finish(): Finished { + if (this.#state.end.peek() === undefined && this.#state.closed.peek() === undefined) + this.finishAt({ group: this.#received, frame: 0 }); + return this; } /** @@ -2235,6 +2238,33 @@ type Superseded = { successor?: Successor }; // the oldest held. type Successor = { sequence: bigint; arrived: Instant; fate: () => Error | undefined }; +/** + * A track its producer finished: its end is declared unless it closed first, and it can still + * take an older group below that end, be read, or be aborted or closed, but not append. {@link Producer.finish} returns it, + * mirroring the Rust `track::Finished`; the producer itself still refuses a group at or past the + * end. + * + * @public + */ +export interface Finished { + /** The track name. */ + readonly name: string; + /** Settles once the track's outcome is final; see {@link Producer.closed}. */ + readonly closed: GetPromise; + /** The track's info, once accepted. */ + info(): Promise; + /** Create an older group below the end, which arrived late; see {@link Producer.createGroup}. */ + createGroup(sequence: bigint): GroupProducer; + /** Serve the groups readers miss below the end; see {@link Producer.requests}. */ + requests(): Requests; + /** Subscribe to this in-process track; see {@link Producer.subscribe}. */ + subscribe(options?: Subscription): Subscriber; + /** Abort the track; see {@link Producer.abort}. */ + abort(error: Error): void; + /** Release the track, like dropping the last Rust handle; see {@link Producer.close}. */ + close(): void; +} + /** * The read side of a live track subscription, mirroring the Rust `Subscriber`. * diff --git a/quest/m2/README.md b/quest/m2/README.md index bab828aee47..84e5b486aea 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -201,7 +201,7 @@ quests that require them. - [Connection state carries each phase's data](/quest/m2/connection-state-phases.md) - moq-tokio's `Observation`, moq-ffi's `MoqConnectionState`, and moq-c's `moq_connection_state` each hold one phase per value, so no field is readable in a phase where it means nothing - [JS time values are types, not numbers](/quest/m2/js-time-types.md) - every public JS duration and instant is a `Clock.Duration` or `Clock.Instant` object, so a unit mistake fails to compile - [Small API fixes before the cut](/quest/m2/api-shape/README.md) - one path and one spelling per item, names by role, and no dead or wrong-role public surface across net, transport, media, native, apps, JS, and bindings -- [Finishing a producer returns a Finished handle](/quest/m2/finished-handle.md) - `finish(self)` consumes moq-net's and the media crates' producers, so appending after finish doesn't compile +- [Finishing a media producer returns a Finished handle](/quest/m2/finished-handle.md) - `finish(self)` consumes the media crates' producers, as it does moq-net's, so appending after finish doesn't compile - [Cut readiness](/quest/m2/cut-gate/README.md) - the checks the cut needs that break nothing: main no slower than release, vendored fixes ported, and moq-c at parity - [Probe](/quest/m2/probe/README.md) - a session probes up to the bitrate it wants to send or receive, so a stopped simulcast rendition resumes and a viewer up-switches; browser padding is parked in m3 (held in m2 by open claims; moves to m3) - [Finish the milestone re-cut](/quest/m2/recut-held.md) - claim-held epics move to the milestone their kind and priority give them once their claims merge diff --git a/quest/m2/finished-handle.md b/quest/m2/finished-handle.md index c8bac8fa546..71cde4738b0 100644 --- a/quest/m2/finished-handle.md +++ b/quest/m2/finished-handle.md @@ -1,24 +1,24 @@ -# [L] Finishing a producer returns a Finished handle +# [M] Finishing a media producer returns a Finished handle ## Goal -`finish(self)` consumes a producer and returns a `Finished` handle, so -appending through the handle that finished is a compile error instead of a -runtime one. The -handle keeps what finishing still allows: aborting, which reports a later -failure and releases the cache, and, where the type supports it today, -inserting below the end, such as a late group under a finished track's end. -It has no append. One shape covers moq-net's `track::Producer` and -`group::Producer` and the media producers and importers, with JS mirrors. -moq-rtmp and moq-srt already consume on finish. +The media producers and importers take `finish(self)` and return a +`Finished` handle, as moq-net's `track::Producer` and `group::Producer` +already do, so appending through the handle that finished is a compile error +instead of a runtime one. The handle keeps what finishing still allows: +aborting, which reports a later failure and releases the cache, and, where +the type supports it today, inserting below the end. It has no append. The +types are #8210's: moq-mux's container producer and the MKV, fMP4, FLV, and +TS importers, moq-audio's producer, and moq-json's `snapshot`, `stream`, and +`window` producers, with their `js/json` and `js/hang` mirrors. moq-rtmp and +moq-srt already consume on finish. The compile-time guarantee covers only the consumed handle, and only in Rust. A `Clone` producer that shares its state (such as moq-json's -`snapshot`, `stream`, and `window` producers and moq-mux's -`catalog::Producer`) leaves other clones that can still append, so those -clones keep a shared runtime refusal after any clone finishes. The JS -mirrors, moq-ffi, and moq-c can't consume a handle, so they keep a runtime -guard that refuses an append after finish. +producers and moq-mux's `catalog::Producer`) leaves other clones that can +still append, so those clones keep a shared runtime refusal after any clone +finishes. The JS mirrors, moq-ffi, and moq-c can't consume a handle, so they +keep a runtime guard that refuses an append after finish. ## Plan @@ -27,41 +27,48 @@ Decided 2026-11-07 (maintainer, /quest-complete), a follow-up of failed finish final with explicit state and recommended against `finish(self)`. The maintainer chose the typestate: -- ✅ **Scope: moq-net and media.** moq-net's `track::Producer` and - `group::Producer`, plus #8210's producers and importers (the container - producer, the MKV, fMP4, FLV, and TS importers, the audio and JSON - producers), and their `js/net` and `js/hang` mirrors. Not chosen: moq-net - only; media only. +- ✅ **Scope: moq-net and media.** Not chosen: moq-net only; media only. - ✅ **Name: `Finished`**, as `track::Finished`, `group::Finished`, and so on. - ✅ **Settle it in m2 before the cut** (maintainer, /quest-plan from the API sweep, 2026-11-07; rejected: shipping `finish(&mut self)` plus a - refusal, then breaking after the cut). This quest absorbed the sweep's - separate `finish(self)` plan. + refusal, then breaking after the cut). -Today each producer borrows on finish and enforces the rest at runtime. -`track::Producer::finish(&self)` (`rs/moq-net/src/model/track.rs`) sets the -end after `max_sequence`, so appending at or above it fails, while older -groups below it can still arrive. `group::Producer::finish(&mut self)` -(`rs/moq-net/src/model/group.rs`) borrows so that `abort` can still report -a later failure and its cache stays readable. `Finished` makes exactly that -contract the type. Holding a finished importer or producer, which #8210 -documents as a use, becomes holding its `Finished`. Decide per type what -`Finished` exposes beyond abort, such as read access to the cache or insert -below the end, without adding anything the producer can't do today. +[moq-dev/moq#8276](https://github.com/moq-dev/moq/pull/8276) landed the +moq-net layer and its `js/net` mirror. Follow its shape: -A `finish` that can fail returns the producer in its error when the caller -can retry, and the PR says which do. +- A `Finished` wraps the producer (or its shared handle) privately and + exposes only what finishing still allows. `track::Finished` keeps + `create_group` below the end, `abort`, `poll_closed`, `consume`, and + `subscribe`; `group::Finished` keeps `abort`, `frame_count`, and + `consume`. +- Where dropping the last handle releases something readers still need, + as dropping the last `track::Finished` unlists the track, mark the + `Finished` `#[must_use]` and say so in its docs. +- A shared holder that must keep its producer (a session, a cloned output) + finishes a clone, or a crate-private `finish_shared(&self)`, and keeps + its own clone, whose appends the end refuses. +- A `compile_fail,E0599` doctest pins each missing append. +- JS: `finish()` returns `this` typed as a narrowing `Finished` interface; + the runtime guard stays on the producer. + +Decide per type what `Finished` exposes beyond abort, such as read access to +the cache or insert below the end, without adding anything the producer +can't do today. A `finish` that can fail returns the producer in its error +when the caller can retry, and the PR says which do. None in moq-net could: +a failed finish there is final. This breaks every caller that finishes and then keeps using the producer. List them in the PR, with every changed signature and the migration for each package in its Impact section, including the runtime guards kept in moq-ffi, moq-c, and the JS mirrors. -Public API: breaking in moq-net, moq-mux, moq-audio, moq-json, and their JS -packages; moq-ffi and moq-c keep their signatures and runtime checks. Wire: none. +Public API: breaking in moq-mux, moq-audio, moq-json, `@moq/json`, and +`@moq/hang`; moq-ffi and moq-c keep their signatures and runtime checks. +Wire: none. ## Related -- [Track and group end-of-life](https://github.com/moq-dev/moq/pull/8243) - the outcome enums `Finished` would wrap (`Outcome` in `track.rs` and `group.rs`) +- [moq-audio codecs flush](https://github.com/moq-dev/moq/pull/8270) - rewrites `moq-audio`'s `encode/producer.rs`, whose `finish` this changes +- [Mux lifecycles hold one phase each](https://github.com/moq-dev/moq/pull/8211) - rewrites moq-mux's `catalog::Producer` lifecycle - [A failed finish is final](https://github.com/moq-dev/moq/pull/8210) - the explicit state this builds on diff --git a/rs/moq-archive/benches/producer.rs b/rs/moq-archive/benches/producer.rs index 7b7758c6a1d..e16c6cb6051 100644 --- a/rs/moq-archive/benches/producer.rs +++ b/rs/moq-archive/benches/producer.rs @@ -54,7 +54,7 @@ async fn record(source: broadcast::Producer, tracks: Vec) -> Du while track.subscription().is_none() { tokio::task::yield_now().await; } - track.finish().unwrap(); + drop(track.clone().finish().unwrap()); } source.close(); run.await.unwrap().unwrap(); diff --git a/rs/moq-archive/src/consumer/tests.rs b/rs/moq-archive/src/consumer/tests.rs index 0861ab26479..46d97ec159e 100644 --- a/rs/moq-archive/src/consumer/tests.rs +++ b/rs/moq-archive/src/consumer/tests.rs @@ -203,8 +203,8 @@ async fn a_recording_round_trips() { group.write_frame(None, "a").unwrap(); group.finish().unwrap(); sleep(Duration::from_millis(10)).await; - video.finish().unwrap(); - log.finish().unwrap(); + let _video = video.finish().unwrap(); + let _log = log.finish().unwrap(); sleep(Duration::from_millis(10)).await; source.close(); recording.await.unwrap().unwrap(); @@ -612,7 +612,7 @@ async fn a_re_added_track_replays_both_runs() { group.write_frame(pts, format!("run{run}/{sequence}")).unwrap(); group.finish().unwrap(); } - track.finish().unwrap(); + let track = track.finish().unwrap(); sleep(Duration::from_secs(2)).await; drop(track); sleep(Duration::from_millis(10)).await; diff --git a/rs/moq-archive/src/consumer/track.rs b/rs/moq-archive/src/consumer/track.rs index d1d818119c7..3af6bebbae5 100644 --- a/rs/moq-archive/src/consumer/track.rs +++ b/rs/moq-archive/src/consumer/track.rs @@ -104,7 +104,7 @@ impl Live { } fn close(&mut self) -> Result<()> { - if let Some(mut open) = self.open.take() { + if let Some(open) = self.open.take() { open.group.finish()?; } Ok(()) diff --git a/rs/moq-archive/src/producer/backends.rs b/rs/moq-archive/src/producer/backends.rs index 305bc0bfe03..e90e0105694 100644 --- a/rs/moq-archive/src/producer/backends.rs +++ b/rs/moq-archive/src/producer/backends.rs @@ -65,7 +65,7 @@ fn path(store: &Store, track: &str, name: &str) -> Path { async fn finish(tracks: &mut [track::Producer]) { for track in tracks { while track.subscription_changed().await.unwrap().is_none() {} - track.finish().unwrap(); + drop(track.clone().finish().unwrap()); } } diff --git a/rs/moq-archive/src/producer/ordered.rs b/rs/moq-archive/src/producer/ordered.rs index efc880a55a8..e65c8823429 100644 --- a/rs/moq-archive/src/producer/ordered.rs +++ b/rs/moq-archive/src/producer/ordered.rs @@ -216,7 +216,7 @@ mod tests { // Too late for its turn. group(&track, 3); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert!(matches!(ordered.poll_next(&kio::Waiter::noop()), Poll::Ready(None))); } diff --git a/rs/moq-archive/src/producer/tests.rs b/rs/moq-archive/src/producer/tests.rs index 55c75a6b85e..f9c1ddac07e 100644 --- a/rs/moq-archive/src/producer/tests.rs +++ b/rs/moq-archive/src/producer/tests.rs @@ -169,7 +169,7 @@ async fn timed_objects_cut_at_group_boundaries_by_duration() { let task = spawn(&store, &broadcast, config()); subscribed(&video).await; settle().await; - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); finished(task).await; @@ -225,7 +225,7 @@ async fn a_lost_group_is_a_gap_that_never_stalls_later_groups() { // The lost group arriving too late stays a gap. group(&video, 1, &[(1000, "b")]); - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); finished(task).await; let stored = objects(&store, "video", true).await; @@ -261,7 +261,7 @@ async fn a_fresh_track_waits_for_a_group_below_its_first_arrival() { // Group 0 arriving after that is too late. group(&video, 0, &[(0, "a")]); - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); finished(task).await; assert_eq!(objects(&store, "video", true).await.len(), 1); @@ -286,7 +286,7 @@ async fn an_oversized_timed_group_splits_into_ordered_unique_keys() { let task = spawn(&store, &broadcast, config()); subscribed(&video).await; settle().await; - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); finished(task).await; @@ -334,7 +334,7 @@ async fn an_open_untimed_group_is_cut_at_each_flush() { ); open.finish().unwrap(); - data.finish().unwrap(); + let _data = data.finish().unwrap(); broadcast.close(); finished(task).await; assert_eq!(end(&store, "data").await, Some(End::Finish(At { group: 1, frame: 0 }))); @@ -365,7 +365,7 @@ async fn an_untimed_group_splits_by_wall_clock() { next.write_frame(None, "f").unwrap(); next.finish().unwrap(); settle().await; - data.finish().unwrap(); + let _data = data.finish().unwrap(); broadcast.close(); finished(task).await; @@ -408,7 +408,7 @@ async fn an_idle_track_is_flushed_within_the_bound() { open.write_frame(ms(100), "b").unwrap(); open.finish().unwrap(); settle().await; - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); finished(task).await; assert_eq!( @@ -449,8 +449,8 @@ async fn a_restart_mid_group_loses_and_duplicates_nothing() { timed_group.finish().unwrap(); untimed_group.finish().unwrap(); settle().await; - video.finish().unwrap(); - data.finish().unwrap(); + let _video = video.finish().unwrap(); + let _data = data.finish().unwrap(); broadcast.close(); finished(task).await; @@ -506,7 +506,7 @@ async fn a_partial_group_resumes_after_its_last_stored_frame() { partial.write_frame(ms(600), "d").unwrap(); partial.finish().unwrap(); settle().await; - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); finished(task).await; @@ -532,7 +532,7 @@ async fn changed_properties_fail_the_resume() { group(&video, 0, &[(0, "a")]); let task = spawn(&store, &broadcast, config()); subscribed(&video).await; - video.finish().unwrap(); + let video = video.finish().unwrap(); drop(video); broadcast.close(); finished(task).await; @@ -606,7 +606,7 @@ async fn track_names_stay_one_segment_through_a_resume() { let task = spawn(&store, &broadcast, config()); for track in &tracks { subscribed(track).await; - track.finish().unwrap(); + drop(track.clone().finish().unwrap()); } broadcast.close(); finished(task).await; @@ -643,7 +643,7 @@ async fn a_dvr_prunes_superseded_objects_after_its_window_and_grace() { // The newest stored object is always kept. assert_eq!(names(objects(&store, "video", true).await), [2]); - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); finished(task).await; assert_eq!(names(objects(&store, "video", true).await), [2, 3]); @@ -664,8 +664,8 @@ async fn a_track_added_mid_recording_is_recorded() { subscribed(&audio).await; group(&audio, 0, &[(0, "a")]); settle().await; - video.finish().unwrap(); - audio.finish().unwrap(); + let _video = video.finish().unwrap(); + let _audio = audio.finish().unwrap(); broadcast.close(); finished(task).await; @@ -693,7 +693,7 @@ async fn a_datagram_track_is_not_recorded() { group(&video, 0, &[(0, "a")]); settle().await; datagrams.finish(); - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); finished(task).await; @@ -772,7 +772,7 @@ async fn a_re_added_track_continues_and_its_marker_records_the_last_run() { subscribed(&first).await; group(&first, 0, &[(0, "a")]); group(&first, 1, &[(1000, "b")]); - first.finish().unwrap(); + let first = first.finish().unwrap(); settle().await; drop(first); settle().await; @@ -816,7 +816,7 @@ async fn a_re_added_track_is_stored_under_its_own_properties() { settle().await; assert!(objects(&store, "video", true).await.is_empty()); - second.finish().unwrap(); + let _second = second.finish().unwrap(); broadcast.close(); let err = kio::clock::timeout(Duration::from_secs(1000), task) .await @@ -848,7 +848,7 @@ async fn a_stopped_producer_writes_no_marker() { sleep(SECOND).await; task.abort(); let _ = task.await; - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); assert_eq!(objects(&store, "video", true).await.len(), 1); @@ -888,11 +888,11 @@ async fn a_track_that_ended_unseen_leaves_the_broadcast_open() { let _ = task.await; // Audio ends while nothing records, so the resume never sees how. - audio.finish().unwrap(); + let audio = audio.finish().unwrap(); drop(audio); let task = spawn(&store, &broadcast, config()); subscribed(&video).await; - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); finished(task).await; assert!(end(&store, "video").await.is_some()); @@ -967,8 +967,8 @@ async fn a_stalled_put_holds_only_its_track() { assert!(objects(&store, "video", true).await.is_empty()); store.inner().release(); - video.finish().unwrap(); - audio.finish().unwrap(); + let _video = video.finish().unwrap(); + let _audio = audio.finish().unwrap(); broadcast.close(); finished(task).await; assert_eq!(objects(&store, "video", true).await.len(), 1); diff --git a/rs/moq-bench/src/connection.rs b/rs/moq-bench/src/connection.rs index 1d1144c66ab..9095bafc38d 100644 --- a/rs/moq-bench/src/connection.rs +++ b/rs/moq-bench/src/connection.rs @@ -725,7 +725,7 @@ mod tests { complete.finish().unwrap(); wait_for(&stats.subscriptions_established, 1).await; assert!(stats.ready()); - track.finish().unwrap(); + let _track = track.finish().unwrap(); task.await.unwrap().unwrap(); assert_eq!(stats.subscriptions_established.load(Ordering::Relaxed), 0); assert!(stats.ready()); @@ -1016,7 +1016,7 @@ mod tests { .write_frame(moq_net::Timestamp::now(), Bytes::from_static(b"{}")) .unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let announced = discover(&origin, "bench/current"); subscribe(announced, own, 1, Duration::ZERO, Duration::ZERO, stats.clone()) @@ -1056,7 +1056,7 @@ mod tests { .write_frame(moq_net::Timestamp::now(), serde_json::to_vec(&header).unwrap()) .unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); task.await.unwrap().unwrap(); assert_eq!(stats.groups_recv.load(Ordering::Relaxed), 1); @@ -1110,7 +1110,7 @@ mod tests { wait_for(&stats.groups_recv, 2).await; write_group(&mut track); wait_for(&stats.groups_recv, 3).await; - track.finish().unwrap(); + let _track = track.finish().unwrap(); broadcast.close(); task.await @@ -1158,7 +1158,7 @@ mod tests { // A last group moves the live frontier past group 2, so 1 and 2 are accounted. write_group(&mut track, &[2_000]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); broadcast.close(); task.await.unwrap().unwrap(); diff --git a/rs/moq-boy/src/input.rs b/rs/moq-boy/src/input.rs index d5960ae6877..c18b71f4aae 100644 --- a/rs/moq-boy/src/input.rs +++ b/rs/moq-boy/src/input.rs @@ -327,7 +327,7 @@ mod tests { let frame = group.read_frame().await.unwrap().expect("a frame"); assert_eq!(&frame.payload[..], br#"{"latency":[{"label":"input","ms":42}]}"#); - session.producer.finish().unwrap(); + let _producer = session.producer.finish().unwrap(); let Command::Left { viewer: left } = recv(&mut rx).await else { panic!("the finished session did not leave"); }; diff --git a/rs/moq-c/src/consume.rs b/rs/moq-c/src/consume.rs index 2d410ce0c2e..10cebaac5dc 100644 --- a/rs/moq-c/src/consume.rs +++ b/rs/moq-c/src/consume.rs @@ -1515,7 +1515,7 @@ mod read_tests { .await; assert_eq!(ids.len(), 1); write(2, 20_000, bytes::Bytes::new()); - track.finish().unwrap(); + let _track = track.finish().unwrap(); run.await.unwrap(); assert_eq!(ids.len(), 3); let micros = |value| moq_timestamp { @@ -1713,7 +1713,7 @@ mod tests { let warming = warmup.is_some_and(|warmup| !warmup.is_zero()); assert_eq!(first.is_err(), warming, "video={video}, warmup={warmup:?}"); consumer.write(3, 4_400_000); - consumer.track.finish().unwrap(); + drop(consumer.track.clone().finish().unwrap()); let mut stamps: Vec<_> = first.ok().flatten().into_iter().collect(); while let Some(stamp) = consumer.frame().await { stamps.push(stamp); diff --git a/rs/moq-c/src/publish.rs b/rs/moq-c/src/publish.rs index 1eedd9350a2..9b4e07cdd9d 100644 --- a/rs/moq-c/src/publish.rs +++ b/rs/moq-c/src/publish.rs @@ -1249,8 +1249,9 @@ impl Publish { pub fn track_finish(&mut self, track: Id) -> Result<(), Error> { let id = track; let Kept { inner: track, children } = self.tracks.remove(id).ok_or(Error::TrackNotFound)?; + // The kept handle stays a producer, whose appends the end refuses. if track.finished().is_none() { - track.finish()?; + drop(track.clone().finish()?); } Kept { inner: track, children }.keep(Child::Track(id)); Ok(()) @@ -1538,7 +1539,7 @@ impl Publish { /// Finish a raw group. No more frames can be written. pub fn group_finish(&mut self, group: Id) -> Result<(), Error> { - let mut group = self + let group = self .groups .remove(group) .and_then(|group| group.inner.take()) diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index b90e01e91ae..249e352215f 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -5061,7 +5061,7 @@ fn a_rejected_group_request_binds_only_its_readers() { .write_frame(moq_net::Timestamp::from_millis(10).unwrap(), &b"live"[..]) .unwrap(); group.finish().unwrap(); - producer.finish().unwrap(); + drop(producer.clone().finish().unwrap()); } let subscribe = || { let subscription = moq_net::track::Subscription::default() diff --git a/rs/moq-cli/src/archive.rs b/rs/moq-cli/src/archive.rs index bf59acf8043..3f5699d786a 100644 --- a/rs/moq-cli/src/archive.rs +++ b/rs/moq-cli/src/archive.rs @@ -419,7 +419,7 @@ mod tests { .await .expect("the export subscribes") .unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); broadcast.broadcast().close(); } let complete = [ @@ -498,7 +498,7 @@ mod tests { group.write_frame(pts, format!("frame {sequence}")).unwrap(); group.finish().unwrap(); } - video.finish().unwrap(); + let _video = video.finish().unwrap(); let recording = tokio::spawn(moq_archive::Producer::new(open(&url).unwrap(), source.consume(), Default::default()).run()); // Its objects, then the markers once the broadcast ends. diff --git a/rs/moq-cli/src/play/video.rs b/rs/moq-cli/src/play/video.rs index 4d990ea3c40..86d4de6901f 100644 --- a/rs/moq-cli/src/play/video.rs +++ b/rs/moq-cli/src/play/video.rs @@ -1034,7 +1034,7 @@ mod tests { "continuous media reached the codec before the later delivery hole" ); write(13, vec![400, 380, 390, 410]); - published.finish().unwrap(); + let _published = published.finish().unwrap(); for _ in 0..1300 { tokio::task::yield_now().await; media.output.present(&media); @@ -1453,14 +1453,14 @@ mod tests { /// Finish every group before `sequence` still open. fn seal(&mut self, sequence: u64) { let open = self.groups.split_off(&sequence); - for (_, mut group) in std::mem::replace(&mut self.groups, open) { + for (_, group) in std::mem::replace(&mut self.groups, open) { group.finish().unwrap(); } } fn finish(&mut self) { self.seal(u64::MAX); - self.track.finish().unwrap(); + drop(self.track.clone().finish().unwrap()); } } diff --git a/rs/moq-crypto/src/e2ee/track.rs b/rs/moq-crypto/src/e2ee/track.rs index 63d0cc4d369..b4abbd586a5 100644 --- a/rs/moq-crypto/src/e2ee/track.rs +++ b/rs/moq-crypto/src/e2ee/track.rs @@ -67,7 +67,7 @@ impl Producer { /// /// A net error if the track is already closed. pub fn finish(self) -> Result<()> { - self.inner.finish()?; + drop(self.inner.finish()?); Ok(()) } diff --git a/rs/moq-crypto/src/sign/group.rs b/rs/moq-crypto/src/sign/group.rs index 07e3d4ac6c2..1efa88bf854 100644 --- a/rs/moq-crypto/src/sign/group.rs +++ b/rs/moq-crypto/src/sign/group.rs @@ -70,7 +70,7 @@ impl Producer { /// # Errors /// /// A net error if the group is already closed. - pub fn finish(mut self) -> Result<()> { + pub fn finish(self) -> Result<()> { self.inner.finish()?; Ok(()) } diff --git a/rs/moq-crypto/src/sign/track.rs b/rs/moq-crypto/src/sign/track.rs index 77a41d869cc..5a4a21e85e7 100644 --- a/rs/moq-crypto/src/sign/track.rs +++ b/rs/moq-crypto/src/sign/track.rs @@ -90,7 +90,7 @@ impl Producer { /// /// A net error if the track is already closed. pub fn finish(self) -> Result<()> { - self.inner.finish()?; + drop(self.inner.finish()?); Ok(()) } diff --git a/rs/moq-ffi/src/media.rs b/rs/moq-ffi/src/media.rs index c6a73db4215..f3f15b004d0 100644 --- a/rs/moq-ffi/src/media.rs +++ b/rs/moq-ffi/src/media.rs @@ -1648,7 +1648,7 @@ mod read_tests { write(5, 5_000_000); write(4, 4_700_000); write(3, 4_400_000); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let mut micros = Vec::new(); while let Some(read) = media.read().await.unwrap() { if let moq_mux::container::Read::Frame { frame, .. } = read { @@ -1753,7 +1753,7 @@ mod read_tests { panic!("end is not EOF") }; assert_eq!(frame.payload, b"resumed"); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert!(reader.next().await.unwrap().is_none()); reader.cancel(); assert!(matches!(reader.next().await, Err(MoqError::Cancelled))); diff --git a/rs/moq-ffi/src/producer.rs b/rs/moq-ffi/src/producer.rs index 8137b8637c0..54554765a74 100644 --- a/rs/moq-ffi/src/producer.rs +++ b/rs/moq-ffi/src/producer.rs @@ -875,8 +875,9 @@ impl MoqTrackProducer { let _guard = crate::ffi::enter(); let mut guard = self.inner.lock().unwrap(); let raw = guard.as_mut().ok_or(MoqError::Closed)?; + // The kept handle stays a producer, whose appends the end refuses. if raw.finished().is_none() { - raw.finish()?; + drop(raw.clone().finish()?); } if let Some(children) = self.keep.lock().unwrap().take() { children.keep(raw.clone()); @@ -905,13 +906,22 @@ pub struct MoqGroupProducer { /// The group keeps one writer waker, so every [`ready`](Self::ready) call polls it with the /// bridge's, which wakes them all. Every other call locks it through the bridge too, so a /// wake it causes reaches a foreign continuation only after the lock is released. - inner: kio::Bridge>, + inner: kio::Bridge, +} + +/// How far a group binding got: writing, finished but still abortable, or closed. +#[derive(Default)] +enum GroupPhase { + Writing(moq_net::group::Producer), + Finished(moq_net::group::Finished), + #[default] + Closed, } impl Drop for MoqGroupProducer { fn drop(&mut self) { let _guard = crate::ffi::enter(); - if let Some(group) = self.inner.get_mut().take() + if let GroupPhase::Writing(group) = std::mem::take(self.inner.get_mut()) && group.poll_closed(&kio::Waiter::noop()).is_pending() { let _ = group.abort(moq_net::Error::Unroutable); @@ -924,7 +934,7 @@ impl MoqGroupProducer { pub(crate) fn from_inner(group: moq_net::group::Producer) -> Self { Self { sequence: group.sequence, - inner: kio::Bridge::new(Some(group)), + inner: kio::Bridge::new(GroupPhase::Writing(group)), } } } @@ -939,9 +949,12 @@ impl MoqGroupProducer { /// Create a consumer that reads frames from this group. pub fn consume(&self) -> Result, MoqError> { let _guard = crate::ffi::enter(); - let guard = self.inner.lock(); - let group = guard.as_ref().ok_or(MoqError::Closed)?; - Ok(Arc::new(MoqGroupConsumer::new(group.consume(), Background::default()))) + let consumer = match &*self.inner.lock() { + GroupPhase::Writing(group) => group.consume(), + GroupPhase::Finished(group) => group.consume(), + GroupPhase::Closed => return Err(MoqError::Closed), + }; + Ok(Arc::new(MoqGroupConsumer::new(consumer, Background::default()))) } /// Write `frame` into this group. @@ -953,7 +966,9 @@ impl MoqGroupProducer { let _guard = crate::ffi::enter(); let timestamp = frame.timestamp.map(TryInto::try_into).transpose()?; let mut guard = self.inner.lock(); - let group = guard.as_mut().ok_or(MoqError::Closed)?; + let GroupPhase::Writing(group) = &mut *guard else { + return Err(MoqError::Closed); + }; group.write_frame(timestamp, frame.payload)?; Ok(()) } @@ -972,8 +987,10 @@ impl MoqGroupProducer { let mut park = kio::Park::default(); crate::ffi::run(kio::wait(|waiter| { self.inner.poll(waiter, |group, cx| match group { - Some(group) => group.poll_ready(park.hold(cx), &frame).map(Ok), - None => Poll::Ready(Err(MoqError::Closed)), + GroupPhase::Writing(group) => group.poll_ready(park.hold(cx), &frame).map(Ok), + // The next write reports why. + GroupPhase::Finished(_) => Poll::Ready(Ok(())), + GroupPhase::Closed => Poll::Ready(Err(MoqError::Closed)), }) })) .await @@ -985,16 +1002,23 @@ impl MoqGroupProducer { pub fn finish(&self) -> Result<(), MoqError> { let _guard = crate::ffi::enter(); let mut guard = self.inner.lock(); - let group = guard.as_mut().ok_or(MoqError::Closed)?; - group.finish()?; + match std::mem::take(&mut *guard) { + GroupPhase::Writing(group) => *guard = GroupPhase::Finished(group.finish()?), + GroupPhase::Finished(group) => *guard = GroupPhase::Finished(group), + GroupPhase::Closed => return Err(MoqError::Closed), + } Ok(()) } /// Abort this group with an application error code. pub fn abort(&self, error_code: u16) -> Result<(), MoqError> { let _guard = crate::ffi::enter(); - let group = self.inner.lock().take().ok_or(MoqError::Closed)?; - group.abort(moq_net::Error::App(error_code))?; + let err = moq_net::Error::App(error_code); + match std::mem::take(&mut *self.inner.lock()) { + GroupPhase::Writing(group) => group.abort(err)?, + GroupPhase::Finished(group) => group.abort(err)?, + GroupPhase::Closed => return Err(MoqError::Closed), + } Ok(()) } } @@ -1003,7 +1027,10 @@ impl MoqGroupProducer { impl MoqGroupProducer { /// Wait until a consumer wants this group. pub(crate) async fn wanted(&self) -> Result<(), MoqError> { - let mut demand = self.inner.lock().as_ref().ok_or(MoqError::Closed)?.demand(); + let mut demand = match &*self.inner.lock() { + GroupPhase::Writing(group) => group.demand(), + _ => return Err(MoqError::Closed), + }; while !demand.wanted_changed().await? {} Ok(()) } diff --git a/rs/moq-gst/src/sink/imp.rs b/rs/moq-gst/src/sink/imp.rs index ea0ea5979c5..c9fa5c67aa5 100644 --- a/rs/moq-gst/src/sink/imp.rs +++ b/rs/moq-gst/src/sink/imp.rs @@ -2464,7 +2464,7 @@ mod tests { let consumer = broadcast.consume(); let track = broadcast.create_track("video", None).unwrap(); track.append_group().unwrap().finish().unwrap(); - track.finish().unwrap(); + let track = track.finish().unwrap(); assert!(session.finish()); while bus.pop().is_some() {} diff --git a/rs/moq-gst/src/sink/pad.rs b/rs/moq-gst/src/sink/pad.rs index cf30a4a9997..952b7c4c807 100644 --- a/rs/moq-gst/src/sink/pad.rs +++ b/rs/moq-gst/src/sink/pad.rs @@ -983,7 +983,8 @@ impl Pad { let result = match &mut track { Sink::Media(media) => media.track.finish().map_err(anyhow::Error::from), Sink::Text(text) => text.producer.finish().map_err(anyhow::Error::from), - Sink::Opaque(producer) => producer.clone().finish().map_err(anyhow::Error::from), + // `closed` retains its own clone, whose appends the end refuses. + Sink::Opaque(producer) => producer.clone().finish().map(drop).map_err(anyhow::Error::from), }; if named { self.names.end(track.name()); diff --git a/rs/moq-gst/src/source/imp.rs b/rs/moq-gst/src/source/imp.rs index 6f780bd3f15..d526db7169a 100644 --- a/rs/moq-gst/src/source/imp.rs +++ b/rs/moq-gst/src/source/imp.rs @@ -3264,7 +3264,7 @@ mod session_tests { // End the served rendition and the broadcast, which answers for the reserved one. catalog.finish().unwrap(); - video.finish().unwrap(); + let _video = video.finish().unwrap(); broadcast.close(); // No shutdown is sent: the run has to end on the media draining alone. @@ -3533,7 +3533,7 @@ mod session_tests { // Everything ends while listed, so the run ends on its own with the pads held. producer.finish().unwrap(); - audio.finish().unwrap(); + let _audio = audio.finish().unwrap(); catalog.finish().unwrap(); super::RUNTIME .block_on(async { kio::clock::timeout(Duration::from_secs(10), session).await }) @@ -3663,7 +3663,7 @@ mod session_tests { ); // The run ends only once every reader drains, a replaying one included. - audio.finish().unwrap(); + let _audio = audio.finish().unwrap(); catalog.finish().unwrap(); super::RUNTIME.block_on(session).unwrap().unwrap(); @@ -3759,7 +3759,7 @@ mod session_tests { // The run ends only once every reader drains, a replaying one included. again.finish().unwrap(); - audio.finish().unwrap(); + let _audio = audio.finish().unwrap(); catalog.finish().unwrap(); super::RUNTIME.block_on(session).unwrap().unwrap(); diff --git a/rs/moq-hls/src/export/archive_tests.rs b/rs/moq-hls/src/export/archive_tests.rs index 48520e07b64..6eb77fa6cc5 100644 --- a/rs/moq-hls/src/export/archive_tests.rs +++ b/rs/moq-hls/src/export/archive_tests.rs @@ -173,7 +173,7 @@ impl Recording { async fn finish(mut self) -> Store { self.catalog.finish().unwrap(); for source in self.sources.values_mut() { - source.media.finish().unwrap(); + drop(source.media.clone().finish().unwrap()); } self.stored().await; self.broadcast.close(); diff --git a/rs/moq-hls/src/export/mod.rs b/rs/moq-hls/src/export/mod.rs index 7f5ffc0c10e..1cd058f7cab 100644 --- a/rs/moq-hls/src/export/mod.rs +++ b/rs/moq-hls/src/export/mod.rs @@ -1607,7 +1607,7 @@ mod tests { #[tokio::test(start_paused = true)] async fn a_stuck_init_leaves_the_manifest_to_its_siblings() { let (origin, broadcast, _catalog, _video0) = inline_sibling().await; - let (_media, mut open) = open_tail(broadcast.broadcast(), "video1", 3); + let (_media, open) = open_tail(broadcast.broadcast(), "video1", 3); let broadcaster = Broadcaster::spawned(crate::resolved(&origin, "live").await, Config::default()); broadcaster.advertised().await; @@ -1654,7 +1654,7 @@ mod tests { video0.gop(sequence); } // video1's only cached group is still open, so its init build parks on it. - let (video1, mut open) = open_tail(broadcast.broadcast(), "video1", 3); + let (video1, open) = open_tail(broadcast.broadcast(), "video1", 3); let broadcaster = Broadcaster::spawned(crate::resolved(&origin, "live").await, Config::default()); broadcaster.advertised().await; @@ -1751,14 +1751,14 @@ mod tests { #[tokio::test(start_paused = true)] async fn an_ended_manifest_stays_dynamic_while_an_init_builds() { let (origin, broadcast, mut catalog, mut video0) = inline_sibling().await; - let (media, mut open) = open_tail(broadcast.broadcast(), "video1", 3); + let (media, open) = open_tail(broadcast.broadcast(), "video1", 3); let broadcaster = Broadcaster::spawned(crate::resolved(&origin, "live").await, Config::default()); broadcaster.advertised().await; let rendition = broadcaster.rendition(Kind::Video, "video0").unwrap(); until_listed(&rendition, 3).await; video0.finish(); - media.finish().unwrap(); + let _media = media.finish().unwrap(); catalog.finish().unwrap(); kio::clock::timeout(Duration::from_secs(5), async { while !rendition.snapshot().finished { @@ -1785,7 +1785,7 @@ mod tests { // it lists nothing. let (origin, broadcast, mut catalog, _video1) = inline_pair("video0").await; // Its earlier groups already left the cache, so the open one is the only candidate. - let (_media, mut open) = open_tail(broadcast.broadcast(), "video0", 1); + let (_media, open) = open_tail(broadcast.broadcast(), "video0", 1); let broadcaster = Broadcaster::spawned(crate::resolved(&origin, "live").await, Config::default()); let _ = kio::clock::timeout(Duration::from_secs(5), broadcaster.ready()).await; @@ -3647,7 +3647,7 @@ mod tests { /// The track ends cleanly, staying retained while the handle lives. fn finish(&mut self) { - self.track.finish().unwrap(); + drop(self.track.clone().finish().unwrap()); } } diff --git a/rs/moq-hls/src/server/include_tests.rs b/rs/moq-hls/src/server/include_tests.rs index 43e1b9399c3..f3b9ff55049 100644 --- a/rs/moq-hls/src/server/include_tests.rs +++ b/rs/moq-hls/src/server/include_tests.rs @@ -295,7 +295,7 @@ async fn idle_release_keeps_an_ended_playlists_inherited_segments() { .update(moq_net::Timed::from(&value).at(Timestamp::ZERO)) .unwrap(); master(&server, "RESOLUTION=640x240", true).await; - include.video.finish().unwrap(); + let _video = include.video.finish().unwrap(); let held = server .router() .oneshot(Request::builder().uri(&uri).body(Body::empty()).unwrap()) @@ -303,7 +303,7 @@ async fn idle_release_keeps_an_ended_playlists_inherited_segments() { .unwrap(); assert_eq!(held.status(), StatusCode::OK); frames(&next, 3); - next.finish().unwrap(); + let _next = next.finish().unwrap(); drop(held); let deadline = kio::clock::now() + Duration::from_secs(10); let ended = loop { diff --git a/rs/moq-json/src/snapshot/mod.rs b/rs/moq-json/src/snapshot/mod.rs index 306f13fb5fc..e25c6c2e0ad 100644 --- a/rs/moq-json/src/snapshot/mod.rs +++ b/rs/moq-json/src/snapshot/mod.rs @@ -296,7 +296,7 @@ mod test { assert!(matches!(consumer.poll_latest(&waiter), Poll::Ready(Ok(Some(v))) if v.value == json!({ "a": 1 }))); group.abort(moq_net::Error::Old).unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert!(matches!(consumer.poll_latest(&waiter), Poll::Ready(Ok(None)))); } @@ -1128,7 +1128,7 @@ mod test { .unwrap(); let mut group = track.append_group().unwrap(); let mut consumer = Consumer::::new(track.consume(), consumer::Config::default()); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let waiter = kio::Waiter::noop(); // Track is finished but the open group is empty: pending, not end-of-stream. diff --git a/rs/moq-json/src/snapshot/producer.rs b/rs/moq-json/src/snapshot/producer.rs index 84fdb1a1b05..c1326a9991f 100644 --- a/rs/moq-json/src/snapshot/producer.rs +++ b/rs/moq-json/src/snapshot/producer.rs @@ -429,7 +429,7 @@ struct Track { impl Track { /// Finish the open group without opening a replacement. fn cut(&mut self) -> Result<()> { - if let Some(mut group) = self.group.take() { + if let Some(group) = self.group.take() { group.finish()?; } Ok(()) @@ -465,7 +465,7 @@ impl Track { /// Close the open group and write a snapshot as the first frame of a new one. fn write_snapshot(&mut self, timestamp: Option, payload: bytes::Bytes) -> Result<()> { // The previous group is complete; no more frames will be appended to it. - if let Some(mut group) = self.group.take() { + if let Some(group) = self.group.take() { group.finish()?; } @@ -483,7 +483,7 @@ impl Track { // Keep the group open so future deltas can be appended to it. true => self.group = Some(group), // One frame per group, identical to a plain JSON track. - false => group.finish()?, + false => drop(group.finish()?), } Ok(()) @@ -499,12 +499,13 @@ impl Track { } fn finish(&mut self) -> Result<()> { - if let Some(mut group) = self.group.take() { + if let Some(group) = self.group.take() { group.finish()?; } - // Another handle may have declared the end already, which stands. + // Another handle may have declared the end already, which stands. This shared state + // keeps its own clone, whose appends the end refuses. if self.inner.finished().is_none() { - self.inner.finish()?; + drop(self.inner.clone().finish()?); } Ok(()) } diff --git a/rs/moq-json/src/stream/producer.rs b/rs/moq-json/src/stream/producer.rs index a5c481f263e..9e2e1cea049 100644 --- a/rs/moq-json/src/stream/producer.rs +++ b/rs/moq-json/src/stream/producer.rs @@ -232,10 +232,11 @@ impl Track { // would leave the track open with `group` already taken, so a later append would open a // second group. That is exactly the split log ending the track exists to prevent. let group = match self.group.take() { - Some(mut group) => group.finish(), + Some(group) => group.finish().map(drop), None => Ok(()), }; - let track = self.inner.finish(); + // This shared state keeps its own clone, whose appends the end refuses. + let track = self.inner.clone().finish().map(drop); group?; track?; diff --git a/rs/moq-json/src/window/mod.rs b/rs/moq-json/src/window/mod.rs index a58e16de5c4..7c80de6d50c 100644 --- a/rs/moq-json/src/window/mod.rs +++ b/rs/moq-json/src/window/mod.rs @@ -677,7 +677,7 @@ mod test { let mut checkpoint = track.append_group().unwrap(); checkpoint.write_frame(moq_net::Timestamp::ZERO, payload).unwrap(); checkpoint.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!( drain(&mut consumer), @@ -902,7 +902,7 @@ mod test { let mut subscriber = track.subscribe(None).ordered(); let mut producer = Producer::::new(track.clone(), ProducerConfig::default()); producer.push(&rec(1)).unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); producer.finish().unwrap(); let waiter = kio::Waiter::noop(); diff --git a/rs/moq-json/src/window/producer.rs b/rs/moq-json/src/window/producer.rs index c75db7b7694..37d84b9854e 100644 --- a/rs/moq-json/src/window/producer.rs +++ b/rs/moq-json/src/window/producer.rs @@ -184,7 +184,7 @@ impl Inner { } fn cut(&mut self) -> Result<()> { - let Some(mut group) = self.track.group.take() else { + let Some(group) = self.track.group.take() else { return Ok(()); }; // The group closes either way, so reset first: a `finish` error must not leave the encoder @@ -298,7 +298,7 @@ impl Track { /// Close the open group and write the header as the first frame of a new one. fn write_header(&mut self, timestamp: Option, payload: bytes::Bytes) -> Result<()> { // The previous group is complete; no more frames will be appended to it. - if let Some(mut group) = self.group.take() { + if let Some(group) = self.group.take() { group.finish()?; } @@ -326,12 +326,13 @@ impl Track { } fn finish(&mut self) -> Result<()> { - if let Some(mut group) = self.group.take() { + if let Some(group) = self.group.take() { group.finish()?; } - // Another handle may have declared the end already, which stands. + // Another handle may have declared the end already, which stands. This shared state + // keeps its own clone, whose appends the end refuses. if self.inner.finished().is_none() { - self.inner.finish()?; + drop(self.inner.clone().finish()?); } Ok(()) } diff --git a/rs/moq-mux/src/catalog/consumer.rs b/rs/moq-mux/src/catalog/consumer.rs index 94bc8578a42..d158ef854dd 100644 --- a/rs/moq-mux/src/catalog/consumer.rs +++ b/rs/moq-mux/src/catalog/consumer.rs @@ -146,7 +146,7 @@ mod tests { .unwrap(); let mut consumer = Consumer::<()>::new(&broadcast.consume(), format).await.unwrap(); assert!(track.subscription().is_some(), "{format:?}: subscribed"); - track.finish().unwrap(); + drop(track.clone().finish().unwrap()); assert!(consumer.next().await.unwrap().is_none()); assert!( track.subscription().is_none(), diff --git a/rs/moq-mux/src/catalog/hang/consumer.rs b/rs/moq-mux/src/catalog/hang/consumer.rs index 4fe96145f57..ff443bd9646 100644 --- a/rs/moq-mux/src/catalog/hang/consumer.rs +++ b/rs/moq-mux/src/catalog/hang/consumer.rs @@ -383,7 +383,7 @@ mod test { let mut consumer = Consumer::new(track.consume()); let mut group = track.append_group().expect("catalog group should append"); - track.finish().expect("catalog track should finish"); + let _track = track.finish().expect("catalog track should finish"); let waiter = kio::Waiter::noop(); assert!(matches!(consumer.poll_next(&waiter), Poll::Pending)); @@ -417,7 +417,7 @@ mod test { .write_frame(moq_net::Timestamp::ZERO, latest_payload) .expect("latest catalog frame should write"); latest_group.finish().expect("latest catalog group should finish"); - track.finish().expect("catalog track should finish"); + let _track = track.finish().expect("catalog track should finish"); assert_eq!(expect_catalog(consumer.poll_next(&waiter)), latest); assert!(matches!(consumer.poll_next(&waiter), Poll::Ready(Ok(None)))); @@ -468,7 +468,7 @@ mod test { .write_frame(moq_net::Timestamp::ZERO, latest_payload) .expect("latest catalog frame should write"); latest_group.finish().expect("latest catalog group should finish"); - track.finish().expect("catalog track should finish"); + let _track = track.finish().expect("catalog track should finish"); assert_eq!(expect_catalog(consumer.poll_next(&waiter)), latest); @@ -500,7 +500,7 @@ mod test { let mut consumer: Consumer = Consumer::new(track.consume()); let waiter = kio::Waiter::noop(); - track.finish().expect("catalog track should finish"); + let _track = track.finish().expect("catalog track should finish"); assert!(matches!(consumer.poll_next(&waiter), Poll::Ready(Ok(None)))); } diff --git a/rs/moq-mux/src/catalog/producer.rs b/rs/moq-mux/src/catalog/producer.rs index 96ebe6615c7..a40ab4fd911 100644 --- a/rs/moq-mux/src/catalog/producer.rs +++ b/rs/moq-mux/src/catalog/producer.rs @@ -1088,12 +1088,11 @@ impl Producer { if let Some(err) = &state.closed { return Err(err.clone()); } - let result = self - .outputs - .hang - .finish() - .map_err(crate::Error::from) - .and_then(|_| self.outputs.msf_track.finish().map_err(crate::Error::from)); + let result = self.outputs.hang.finish().map_err(crate::Error::from).and_then(|_| { + // The shared outputs keep their own clone, whose appends the end refuses. + let msf = self.outputs.msf_track.clone().finish(); + msf.map(drop).map_err(crate::Error::from) + }); match result { Ok(()) => { state.closed = Some(moq_net::Error::Closed.into()); diff --git a/rs/moq-mux/src/codec/h264/export.rs b/rs/moq-mux/src/codec/h264/export.rs index 55dfe4e2cc1..1f854c6508f 100644 --- a/rs/moq-mux/src/codec/h264/export.rs +++ b/rs/moq-mux/src/codec/h264/export.rs @@ -228,7 +228,7 @@ mod tests { let mut g1 = track.create_group(moq_net::group::Info { sequence: 1 }).unwrap(); write_length_prefixed(&mut g1, 33_000, &[p_slice]); g1.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); // Consumer side: run the exporter. let consumer = broadcast.consume(); @@ -336,7 +336,7 @@ mod tests { let nals: &[&[u8]] = &[&[0x67, 0x42, 0, 0x1f], &[0x68, 0xce], &[0x65, 0x88]]; write_length_prefixed(&mut group, 0, nals); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let consumer = broadcast.consume(); let mut exporter = Export::new(crate::source::announced(&consumer).await, Once(Some(catalog))); let result = exporter.next().await; diff --git a/rs/moq-mux/src/codec/h265/export.rs b/rs/moq-mux/src/codec/h265/export.rs index 5ed1b40cd34..84ba32f4920 100644 --- a/rs/moq-mux/src/codec/h265/export.rs +++ b/rs/moq-mux/src/codec/h265/export.rs @@ -215,7 +215,7 @@ mod tests { let mut g1 = track.create_group(moq_net::group::Info { sequence: 1 }).unwrap(); write_length_prefixed(&mut g1, 33_000, &[trail]); g1.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let consumer = broadcast.consume(); // The whole track is written before the exporter runs, so it needs a budget @@ -332,7 +332,7 @@ mod tests { 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(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let consumer = broadcast.consume(); let mut exporter = Export::new(crate::source::announced(&consumer).await, Once(Some(catalog))); let result = exporter.next().await; diff --git a/rs/moq-mux/src/container/consumer.rs b/rs/moq-mux/src/container/consumer.rs index 89665bfa6d7..87bbb1e2eb4 100644 --- a/rs/moq-mux/src/container/consumer.rs +++ b/rs/moq-mux/src/container/consumer.rs @@ -1710,7 +1710,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); write_group(&mut track, 0, &[ts(0)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 1); @@ -1819,7 +1819,7 @@ mod tests { let mut group = track.create_group(moq_net::group::Info { sequence: 2 }).unwrap(); group.write_frame(ts(0), Bytes::new()).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut reader).await, ["0", "10000", "gap 10000+0", "end 10000"]); } @@ -1861,7 +1861,7 @@ mod tests { assert!( matches!(reader.poll_read(&kio::Waiter::noop()), Poll::Ready(Ok(Some(Read::End { group: 2, end }))) if end == ts(10_000)) ); - track.finish().unwrap(); + let _track = track.finish().unwrap(); } } @@ -1901,7 +1901,7 @@ mod tests { Poll::Ready(Ok(Some(Read::Gap { .. }))) )); assert!(matches!(reader.read().await.unwrap(), Some(Read::End { group: 4, .. }))); - track.finish().unwrap(); + let _track = track.finish().unwrap(); } /// The holes a source left behind when it stopped expire together, a budget after the groups @@ -2055,7 +2055,7 @@ mod tests { } } group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let error = loop { match reader.read().await { @@ -2103,7 +2103,7 @@ mod tests { write_group(&mut track, 2, &[ts(1_000_000), ts(1_010_000)]); write_marker_group(&mut track, 3, ts(1_020_000)); write_group(&mut track, 4, &[ts(2_000_000), ts(2_010_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!( items(&mut reader).await, [ @@ -2144,7 +2144,7 @@ mod tests { .unwrap(); assert!(matches!(reader.read().await.unwrap(), Some(Read::Frame { .. }))); write_group(&mut track, 3, &[ts(1_000_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut reader).await, ["gap 0+1000000", "1000000"]); } @@ -2175,7 +2175,7 @@ mod tests { .unwrap(); group.finish().unwrap(); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut reader).await, ["0", "33000"]); } @@ -2202,7 +2202,7 @@ mod tests { ) .unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut reader).await, ["0", "20000", "end 50000", "40000"]); } @@ -2217,7 +2217,7 @@ mod tests { write_group(&mut track, 0, &[ts(0)]); write_marker_group(&mut track, 1, ts(0)); write_group(&mut track, 2, &[ts(1_000_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut consumer).await, ["0", "end 0", "1000000"]); } @@ -2236,7 +2236,7 @@ mod tests { write_group(&mut track, 2, &[ts(1_000_000)]); write_marker_group(&mut track, 3, ts(1_000_000)); write_group(&mut track, 4, &[ts(2_000_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!( items(&mut consumer).await, @@ -2259,7 +2259,7 @@ mod tests { .finish() .unwrap(); write_group(&mut track, 2, &[ts(1_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut consumer).await, ["0", "1000"]); } @@ -2284,7 +2284,7 @@ mod tests { let mut consumer = Consumer::new(subscriber, Container::Legacy(crate::container::Kind::Audio)); write_group(&mut track, 2, &[ts(1_000_000), ts(1_600_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut consumer).await, ["1000000", "1600000"]); } @@ -2314,7 +2314,7 @@ mod tests { .unwrap(); assert!(matches!(consumer.read().await.unwrap(), Some(Read::Frame { .. }))); write_group(&mut track, 3, &[ts(1_000_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut consumer).await, ["gap 0+1000000", "1000000"]); } @@ -2328,7 +2328,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); write_group(&mut track, 0, &[ts(0), ts(33_000), ts(66_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 3); @@ -2351,7 +2351,7 @@ mod tests { for i in 0..5u64 { write_group(&mut track, i, &[ts(i * 20_000)]); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 5); @@ -2389,7 +2389,7 @@ mod tests { let timestamps: Vec<_> = (0..5).map(|f| ts(g * 15_000 + f * 2_000)).collect(); write_group(&mut track, g, ×tamps); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); // Finish group 0 after consumer has had time to accumulate pending groups let finisher = tokio::spawn(async move { @@ -2434,7 +2434,7 @@ mod tests { let timestamps: Vec<_> = (0..3).map(|f| ts(g * 50_000 + f * 5_000)).collect(); write_group(&mut track, g, ×tamps); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(50)).await; @@ -2475,7 +2475,7 @@ mod tests { for g in 1..10u64 { write_group(&mut track, g, &[ts(g * 30_000)]); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(50)).await; @@ -2651,7 +2651,7 @@ mod tests { write_group(&mut track, 0, &[ts(100_000)]); assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(100_000)); write_group(&mut track, 1, &[ts(100_000), ts(0)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let err = loop { match consumer.read().await { Ok(Some(_)) => continue, @@ -2675,7 +2675,7 @@ mod tests { let mut track = track_producer("test", hang::container::track_info(hang::catalog::PRIORITY.video)); let mut consumer = Consumer::new(track.subscribe(None), Container::Legacy(crate::container::Kind::Data)); write_group(&mut track, 0, &[ts(0), ts(66_000), ts(33_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = continuous_frames(&mut consumer).await; assert_eq!( frames.iter().map(|f| f.timestamp).collect::>(), @@ -2690,7 +2690,7 @@ mod tests { write_group(&mut track, 0, &[ts(100_000)]); assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(100_000)); write_group(&mut track, 1, &[ts(100_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(100_000)); } @@ -2707,7 +2707,7 @@ mod tests { assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(expected)); } write_group(&mut track, 1, &[ts(50_000), ts(83_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!( frames.iter().map(|f| f.timestamp.as_micros()).collect::>(), @@ -2726,7 +2726,7 @@ mod tests { assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(expected)); } write_group(&mut track, 1, &[ts(66_000), ts(50_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = continuous_frames(&mut consumer).await; assert_eq!( frames.iter().map(|f| f.timestamp.as_micros()).collect::>(), @@ -2746,7 +2746,7 @@ mod tests { write_group(&mut track, 0, &[ts(0)]); write_marker_group(&mut track, 1, ts(0)); write_group(&mut track, 2, &[ts(1_000_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut consumer).await, ["0", "end 0", "1000000"]); } @@ -2791,7 +2791,7 @@ mod tests { tokio::time::advance(Duration::from_millis(299)).await; assert!(consumer.poll_read(&kio::Waiter::noop()).is_pending()); write_group(&mut track, 2, &[ts(60_000_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut consumer).await, ["60000000", "60060000"]); } @@ -2804,7 +2804,7 @@ mod tests { assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(0)); write_marker_group(&mut track, 1, ts(0)); write_group(&mut track, 2, &[ts(1_000_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert!(matches!(consumer.read().await.unwrap(), Some(Read::Gap { .. }))); assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(1_000_000)); } @@ -2844,7 +2844,7 @@ mod tests { write_group(&mut track, 0, &[ts(100_000)]); assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(100_000)); write_group(&mut track, 1, &[ts(200_000), ts(50_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(200_000)); let err = consumer.read().await.unwrap_err(); assert!(matches!( @@ -2901,7 +2901,7 @@ mod tests { .unwrap(); write_marker(&mut group, ts(50_000)); // the group's end group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 2, "markers are not surfaced as media"); @@ -2931,7 +2931,7 @@ mod tests { ) .unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frame = consumer.read_frame().await.unwrap().unwrap(); assert!(frame.keyframe, "the marker does not consume the first-media slot"); @@ -2966,7 +2966,7 @@ mod tests { } group.finish().unwrap(); write_group(&mut track, 1, &[ts(100_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); let micros: Vec = frames.iter().map(|f| f.timestamp.as_micros()).collect(); @@ -3004,7 +3004,7 @@ mod tests { ) .unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 1, "the empty LOC payload is not submitted"); @@ -3037,7 +3037,7 @@ mod tests { write_group(&mut track, 2, &[ts(60_000)]); write_group(&mut track, 1, &[ts(30_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(10)).await; @@ -3062,7 +3062,7 @@ mod tests { write_group(&mut track, 0, &[ts(0)]); write_group(&mut track, 1, &[ts(30_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 2); @@ -3081,7 +3081,7 @@ mod tests { ); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let result = kio::clock::timeout(Duration::from_millis(200), consumer.read()).await; match result { @@ -3137,7 +3137,7 @@ mod tests { write_group(&mut track, 4, &[ts(160_000), ts(180_000)]); write_group(&mut track, 5, &[ts(200_000), ts(220_000)]); write_group(&mut track, 6, &[ts(240_000), ts(260_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert!(frames.len() >= 4, "Expected >= 4 frames, got {}", frames.len()); @@ -3155,7 +3155,7 @@ mod tests { write_group(&mut track, 7, &[ts(80_000), ts(100_000)]); write_group(&mut track, 8, &[ts(120_000), ts(140_000)]); write_group(&mut track, 9, &[ts(160_000), ts(180_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert!(frames.len() >= 4, "Expected >= 4 frames, got {}", frames.len()); @@ -3371,7 +3371,7 @@ mod tests { // Group 1's stream opens moments later, well within the 500ms budget. write_group(&mut track, 1, &[ts(100_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); let micros: Vec = frames.iter().map(|f| f.timestamp.as_micros()).collect(); @@ -3403,7 +3403,7 @@ mod tests { // Group 0 arrives moments later, well within the 500ms budget. write_group(&mut track, 0, &[ts(0)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); let micros: Vec = frames.iter().map(|f| f.timestamp.as_micros()).collect(); @@ -3445,7 +3445,7 @@ mod tests { ) .unwrap(); group0.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); let micros: Vec = frames.iter().map(|f| f.timestamp.as_micros()).collect(); @@ -3493,7 +3493,7 @@ mod tests { ); write_group(&mut track, 4, &[ts(4_800_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); let micros: Vec = frames.iter().map(|f| f.timestamp.as_micros()).collect(); @@ -3521,7 +3521,7 @@ mod tests { assert_eq!(frame.timestamp, ts(5_000_000)); write_group(&mut track, 4, &[ts(4_000_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert!( read_all(&mut consumer).await.unwrap().is_empty(), "the earlier group is old" @@ -3550,7 +3550,7 @@ mod tests { write_group(&mut track, 4, &[ts(4_700_000)]); let first = kio::clock::timeout(Duration::from_millis(50), consumer.read_frame()).await; write_group(&mut track, 3, &[ts(4_400_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = first.ok().map(|frame| frame.unwrap().unwrap()); let frames = frames.into_iter().chain(read_all(&mut consumer).await.unwrap()); @@ -3624,7 +3624,7 @@ mod tests { write(&mut covering, 4_950_000); covering.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let micros: Vec = read_all(&mut consumer) .await .unwrap() @@ -3884,7 +3884,7 @@ mod tests { "an earlier group within the min delay must be waited for" ); write_group(&mut track, 4, &[ts(4_500_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); let micros: Vec = frames.iter().map(|f| f.timestamp.as_micros()).collect(); assert_eq!(micros, vec![4_500_000, 5_000_000]); @@ -3959,7 +3959,7 @@ mod tests { .write_frame(moq_net::Timestamp::ZERO, Bytes::from_static(b"FAIL")) .unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); // The first frame decodes; the malformed second frame must surface as an error. let first = consumer.read_frame().await; @@ -4010,7 +4010,7 @@ mod tests { write_failing(&mut group, None); write_failing(&mut group, Some(0)); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let read = read_past_frames(&mut consumer).await; assert!(matches!(read, Err(crate::Error::UnknownFormat(_))), "{read:?}"); @@ -4030,7 +4030,7 @@ mod tests { write_failing(&mut group, None); write_failing(&mut group, Some(0)); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let event = kio::wait(|waiter| consumer.poll_event(waiter)).await; assert!(matches!(event, Err(crate::Error::UnknownFormat(_)))); @@ -4050,14 +4050,15 @@ mod tests { let mut malformed = track.create_group(moq_net::group::Info { sequence: 0 }).unwrap(); write_failing(&mut malformed, None); - malformed.finish().unwrap(); + let malformed_demand = malformed.demand(); + let _malformed = malformed.finish().unwrap(); let mut later = track.create_group(moq_net::group::Info { sequence: 1 }).unwrap(); write_failing(&mut later, Some(10_000)); let read = read_past_frames(&mut consumer).await; assert!(matches!(read, Err(crate::Error::UnknownFormat(_))), "{read:?}"); assert!(track.demand().wanted().is_none(), "the ended reader still subscribes"); - assert!(!malformed.demand().wanted(), "the ended reader still holds its group"); + assert!(!malformed_demand.wanted(), "the ended reader still holds its group"); assert!(!later.demand().wanted(), "the ended reader still holds a later group"); } @@ -4161,7 +4162,7 @@ mod tests { ); current.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let read = read_past_frames(&mut consumer).await; assert!(matches!(read, Err(crate::Error::UnknownFormat(_))), "{read:?}"); } @@ -4182,7 +4183,7 @@ mod tests { let mut newest = track.create_group(moq_net::group::Info { sequence: 1 }).unwrap(); write_failing(&mut newest, Some(10_000)); newest.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let read = read_past_frames(&mut consumer).await; assert!(matches!(read, Err(crate::Error::UnknownFormat(_))), "{read:?}"); @@ -4218,7 +4219,7 @@ mod tests { assert_eq!(frame.timestamp, ts(10_000)); current.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let read = read_past_frames(&mut consumer).await; assert!(matches!(read, Err(crate::Error::UnknownFormat(_))), "{read:?}"); } @@ -4240,7 +4241,7 @@ mod tests { assert_eq!(first.timestamp, ts(0)); group.abort(moq_net::Error::Cancel).unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let read = kio::clock::timeout(Duration::from_millis(50), consumer.read()).await; assert!(matches!(read, Ok(Err(crate::Error::UnknownFormat(_)))), "{read:?}"); } @@ -4255,7 +4256,7 @@ mod tests { write_failing(&mut group, Some(0)); write_failing(&mut group, None); write_failing(&mut group, Some(10_000)); - group.finish().unwrap(); + let group = group.finish().unwrap(); // Finding the start buffers one frame; the read behind it already holds the rest. let mut buffer = GroupBuffer::::new(group.consume(), Memory::new(DEFAULT_MAX_BUFFER)); @@ -4298,7 +4299,7 @@ mod tests { ) .unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 1); @@ -4344,7 +4345,7 @@ mod tests { write_group(&mut track, 2, &[ts(200_000)]); kio::clock::sleep(Duration::from_millis(20)).await; group0.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); }); let frames = kio::clock::timeout(Duration::from_secs(2), async { @@ -4373,7 +4374,7 @@ mod tests { let one_hour = 3_600_000_000u64; write_group(&mut track, 0, &[ts(one_hour)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 1); @@ -4390,7 +4391,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); write_group(&mut track, 0, &[ts(0)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frame = consumer.read_frame().await.unwrap().unwrap(); assert_eq!(frame.timestamp, ts(0)); @@ -4430,7 +4431,7 @@ mod tests { } write_group(&mut track, 1, &[ts(100_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(50)).await; @@ -4496,7 +4497,7 @@ mod tests { ) .unwrap(); group7.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); }); let _frames = kio::clock::timeout(Duration::from_secs(2), async { @@ -4539,7 +4540,7 @@ mod tests { // present (bounded by group 7's start), expiring it. Exactly a budget, so group 7's // first frame is not past it and the start stays there. write_group(&mut track, 9, &[ts(710_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); let micros: Vec = frames.iter().map(|f| f.timestamp.as_micros()).collect(); @@ -4560,7 +4561,7 @@ mod tests { // Sequence 0 never arrives; sequence 1's stream opens but never carries a frame. let group1 = track.create_group(moq_net::group::Info { sequence: 1 }).unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); // While group 1 is open its frames may still come, so the consumer waits. assert!( @@ -4594,7 +4595,7 @@ mod tests { // arrives before them. let mut group0 = track.create_group(moq_net::group::Info { sequence: 0 }).unwrap(); write_group(&mut track, 1, &[ts(100_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert!( kio::clock::timeout(Duration::from_millis(50), consumer.read()) @@ -4672,7 +4673,7 @@ mod tests { let consumer_track = track.subscribe(subscription); assert_eq!(consumer_track.floor(), Some(7)); let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); let micros: Vec = frames.iter().map(|f| f.timestamp.as_micros()).collect(); @@ -4704,7 +4705,7 @@ mod tests { for sequence in [7, 8, 9] { write_group(&mut track, sequence, &[ts(sequence * 100_000)]); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut consumer).await, ["800000", "900000", "1000000"]); } @@ -4732,7 +4733,7 @@ mod tests { write_group(&mut track, 4, &[ts(400_000)]); write_group(&mut track, 5, &[ts(500_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert_eq!(items(&mut consumer).await, ["500000"]); } @@ -4780,7 +4781,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); write_group(&mut track, 100, &[ts(3_000_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 1); @@ -4836,7 +4837,7 @@ mod tests { write_group(&mut track, 1, &[ts(100_000)]); write_group(&mut track, 2, &[ts(200_000)]); write_group(&mut track, 3, &[ts(300_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(20)).await; @@ -4872,7 +4873,7 @@ mod tests { .unwrap(); write_group(&mut track, 1, &[ts(100_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(20)).await; @@ -4914,7 +4915,7 @@ mod tests { // Group 1: finished, 200ms ahead (well beyond the 100ms max delay) write_group(&mut track, 1, &[ts(200_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(50)).await; @@ -4941,7 +4942,7 @@ mod tests { assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(0)); // Group 2: finished (group 1 is missing - sequence gap) write_group(&mut track, 2, &[ts(200_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 2, "Expected group 0's second frame + group 2 (1 frame)"); @@ -4959,7 +4960,7 @@ mod tests { group0.abort(moq_net::Error::Cancel).unwrap(); write_group(&mut track, 1, &[ts(30_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 1); @@ -4989,9 +4990,9 @@ mod tests { .write(&mut group0, &[frame]) .unwrap(); } - group0.finish().unwrap(); + let group0 = group0.finish().unwrap(); write_group(&mut track, 1, &[ts(30_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); // Take the first frame only, leaving the second unread. let first = consumer.read_frame().await.unwrap().unwrap(); @@ -5029,7 +5030,7 @@ mod tests { group0.abort(moq_net::Error::GroupTooLarge).unwrap(); write_group(&mut track, 1, &[ts(30_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 1, "expected group 1 only, got {} frames", frames.len()); @@ -5051,7 +5052,7 @@ mod tests { kio::clock::sleep(Duration::from_millis(20)).await; write_group(&mut track, 1, &[ts(30_000)]); kio::clock::sleep(Duration::from_millis(20)).await; - track.finish().unwrap(); + let _track = track.finish().unwrap(); }); let frames = kio::clock::timeout(Duration::from_secs(2), async { @@ -5076,11 +5077,11 @@ 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 { sequence: 0 }).unwrap(); + let group0 = track.create_group(moq_net::group::Info { sequence: 0 }).unwrap(); group0.finish().unwrap(); write_group(&mut track, 1, &[ts(30_000)]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); assert_eq!(frames.len(), 1); @@ -5112,7 +5113,7 @@ mod tests { .unwrap(); } group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let mut frames = Vec::new(); while let Some(frame) = consumer.read_frame().await.unwrap() { @@ -5154,7 +5155,7 @@ mod tests { write_duration_frame(&mut group1, ts(33_000), ts(33_000)); group1.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = kio::clock::timeout(Duration::from_secs(2), async { continuous_frames(&mut consumer).await }) .await @@ -5187,7 +5188,7 @@ mod tests { .unwrap(); write_duration_frame(&mut group1, ts(33_000), ts(33_000)); group1.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let frames = continuous_frames(&mut consumer).await; assert_eq!(frames.len(), 2); } @@ -5213,7 +5214,7 @@ mod tests { let mut group1 = track.create_group(moq_net::group::Info { sequence: 1 }).unwrap(); write_duration_frame(&mut group1, ts(33_000), ts(33_000)); group1.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); // A second frame lands on group 0 and finishes it after the consumer has // had a chance to (incorrectly) skip. @@ -5335,7 +5336,7 @@ mod tests { let _stalled = open_group(&mut track, 0, ts(0)); write_group(&mut track, 1, &vec![ts(10_000); 2_000]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let reads = read_bounded(&mut consumer, MAX_BUFFER).await; let timestamps = timestamps(&reads); @@ -5364,7 +5365,7 @@ mod tests { for g in 1..=500u64 { write_group(&mut track, g, &[ts(g * 1_000)]); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); let reads = read_bounded(&mut consumer, MAX_BUFFER).await; let timestamps = timestamps(&reads); @@ -5736,7 +5737,7 @@ mod tests { }], ) .unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert!(consumer.poll_received(&kio::Waiter::noop()).is_pending()); assert!( consumer.pending.iter().all(|group| group.is_empty()), diff --git a/rs/moq-mux/src/container/fmp4/export_test.rs b/rs/moq-mux/src/container/fmp4/export_test.rs index e364d72ff97..bf6798936de 100644 --- a/rs/moq-mux/src/container/fmp4/export_test.rs +++ b/rs/moq-mux/src/container/fmp4/export_test.rs @@ -2213,7 +2213,7 @@ async fn cmaf_source_exports_at_the_frame_timestamp() { .write_frame(moq_net::Timestamp::from_secs(10).unwrap(), fragment) .unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let catalog_stream = crate::catalog::Consumer::<()>::new(&consumer, crate::catalog::CatalogFormat::Hang) .await diff --git a/rs/moq-mux/src/container/fmp4/import.rs b/rs/moq-mux/src/container/fmp4/import.rs index ab117e2828e..96df5021dda 100644 --- a/rs/moq-mux/src/container/fmp4/import.rs +++ b/rs/moq-mux/src/container/fmp4/import.rs @@ -196,7 +196,7 @@ impl Passthrough { fn close(&mut self) -> crate::Result<()> { self.estimator.cut(None); self.publish_estimate()?; - if let Some(mut group) = self.group.take() { + if let Some(group) = self.group.take() { group.finish()?; } Ok(()) @@ -204,7 +204,8 @@ impl Passthrough { /// Close the open group and finish the track, or abort both with the cause when that fails. fn finish(&mut self) -> crate::Result<()> { - if let Err(err) = self.close().and_then(|()| Ok(self.track.finish()?)) { + // The importer keeps its own clone, whose appends the end refuses. + if let Err(err) = self.close().and_then(|()| Ok(self.track.clone().finish().map(drop)?)) { if let Some(group) = self.group.take() { let _ = group.abort(err.reason()); } @@ -1602,7 +1603,7 @@ impl Passthrough { return Err(crate::container::TimestampRewind { timestamp, floor }.into()); } let group = if start_group { - if let Some(mut prev) = self.group.take() { + if let Some(prev) = self.group.take() { prev.finish()?; } match self.pending_sequence.take() { diff --git a/rs/moq-mux/src/container/producer.rs b/rs/moq-mux/src/container/producer.rs index 70030b23350..9380948fa9b 100644 --- a/rs/moq-mux/src/container/producer.rs +++ b/rs/moq-mux/src/container/producer.rs @@ -742,7 +742,7 @@ where if let Some(group) = self.group.as_mut() { self.container.finish_group(group, tail_end)?; } - if let Some(mut group) = self.group.take() { + if let Some(group) = self.group.take() { group.finish()?; // Only a closed group reaches anything; a cut with none open names a point nothing reached. if let Some(end) = reached { @@ -952,7 +952,8 @@ where return Err(cause); } match err { - None => self.inner.finish()?, + // The producer keeps its own clone, whose appends the end refuses. + None => drop(self.inner.clone().finish()?), Some(err) => { let next = self .inner diff --git a/rs/moq-mux/src/container/source.rs b/rs/moq-mux/src/container/source.rs index 5e463b801b9..0655082fed6 100644 --- a/rs/moq-mux/src/container/source.rs +++ b/rs/moq-mux/src/container/source.rs @@ -1232,7 +1232,7 @@ mod tests { for sequence in 4..8 { write(sequence); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); while let Some(Some(timestamp)) = read().await { timestamps.push(timestamp); } @@ -1328,7 +1328,7 @@ mod tests { while let Some(Some(timestamp)) = read().await { timestamps.push(timestamp); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); while let Some(Some(timestamp)) = read().await { timestamps.push(timestamp); } @@ -1438,7 +1438,7 @@ mod tests { group(2, 40_000).finish().unwrap(); let cut = group(3, 60_000); group(4, 80_000).finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let waiter = kio::Waiter::noop(); let read = |export: &mut ExportSource| { @@ -1466,7 +1466,7 @@ mod tests { wire.write(&mut group, &[raw_frame(timestamp, payload, true)]).unwrap(); group.finish().unwrap(); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); let waiter = kio::Waiter::noop(); assert!(matches!( export.poll_event(&waiter), @@ -1517,7 +1517,7 @@ mod tests { wire.write(&mut group, &frames).unwrap(); group.finish().unwrap(); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); let waiter = kio::Waiter::noop(); for (timestamp, generation) in [(0, 0), (40_000, 0), (100_000, 1)] { let Poll::Ready(Ok(Some(frame))) = export.poll_read(&waiter) else { diff --git a/rs/moq-mux/src/container/ts/export_test.rs b/rs/moq-mux/src/container/ts/export_test.rs index a24afbdbb6b..a1a637f9631 100644 --- a/rs/moq-mux/src/container/ts/export_test.rs +++ b/rs/moq-mux/src/container/ts/export_test.rs @@ -248,7 +248,7 @@ async fn a_follower_keeps_msf_after_catalog_eof() { (broadcast, track) }; let (broadcast, mut track) = publish(); - track.finish().unwrap(); + drop(track.clone().finish().unwrap()); let source = crate::source::resolved(&origin, "live").await; let stream = source.catalog::<()>(CatalogFormat::Msf).await.unwrap(); let mut export = Export::new(source, stream, std::time::Duration::ZERO); @@ -284,7 +284,7 @@ async fn a_follower_keeps_msf_after_catalog_eof() { .await .expect("MSF catalog resubscribed"); assert_eq!(follower.export().catalog_format(), CatalogFormat::Msf); - track.finish().unwrap(); + let track = track.finish().unwrap(); drop((follower, broadcast, track)); } @@ -1016,7 +1016,7 @@ async fn export_trims_leading_pictures_after_each_delivery_break() { format.write(&mut group, &frames).unwrap(); group.finish().unwrap(); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); let mut export = open_export(crate::source::announced(&consumer).await, RECORDING_MAX_AGE) .await .unwrap() @@ -1323,7 +1323,7 @@ async fn export_declared(reorder: u8, groups: &[&[u64]]) -> (Export self.stalled.push(group), - false => group.finish().unwrap(), + false => { + group.finish().unwrap(); + } } } if keyframe { @@ -355,11 +357,11 @@ impl Live { /// End the media tracks while the catalog can still announce more. fn finish_media(&mut self) { - if let Some(mut group) = self.group.take() { + if let Some(group) = self.group.take() { group.finish().unwrap(); } self.stalled.clear(); - self.video.finish().unwrap(); + drop(self.video.clone().finish().unwrap()); self.audio.finish().unwrap(); } diff --git a/rs/moq-mux/src/container/ts/recovery_test.rs b/rs/moq-mux/src/container/ts/recovery_test.rs index e03c3f05d21..a77becf2e72 100644 --- a/rs/moq-mux/src/container/ts/recovery_test.rs +++ b/rs/moq-mux/src/container/ts/recovery_test.rs @@ -932,9 +932,11 @@ async fn run(recording: &Recording, arm: &Arm) -> Run { }; let (sequence, frames) = &groups[t][g]; let Some(f) = step else { - let mut group = open[t].take().unwrap(); + let group = open[t].take().unwrap(); match kept[t] == frames.len() { - true => group.finish().unwrap(), + true => { + group.finish().unwrap(); + } false => group.abort(moq_net::Error::Old).unwrap(), } continue; @@ -952,7 +954,7 @@ async fn run(recording: &Recording, arm: &Arm) -> Run { } assert!(open.iter().all(Option::is_none), "every group ends"); for producer in &producers { - producer.finish().unwrap(); + drop(producer.clone().finish().unwrap()); } let _keep = catalog; std::future::pending::<()>().await; diff --git a/rs/moq-mux/src/container/ts/release_test.rs b/rs/moq-mux/src/container/ts/release_test.rs index 3adab037e39..dd8df163874 100644 --- a/rs/moq-mux/src/container/ts/release_test.rs +++ b/rs/moq-mux/src/container/ts/release_test.rs @@ -139,17 +139,19 @@ fn republish_cut( if let Some((sequence, group)) = group { end(sequence, group, &cut); } - track.finish().unwrap(); + let _track = track.finish().unwrap(); std::future::pending::<()>().await; }); Republished { consumer, task } } /// Finish `group`, or abort it as evicted if it is one of the `cut`. -fn end(sequence: u64, mut group: moq_net::group::Producer, cut: &[u64]) { +fn end(sequence: u64, group: moq_net::group::Producer, cut: &[u64]) { match cut.contains(&sequence) { true => group.abort(moq_net::Error::Old).unwrap(), - false => group.finish().unwrap(), + false => { + group.finish().unwrap(); + } } } diff --git a/rs/moq-mux/src/container/ts/si.rs b/rs/moq-mux/src/container/ts/si.rs index 73a653856ba..064d8911c0b 100644 --- a/rs/moq-mux/src/container/ts/si.rs +++ b/rs/moq-mux/src/container/ts/si.rs @@ -694,8 +694,9 @@ impl Capture { /// Flush everything and finish every track. pub fn finish(&mut self, pts: Timestamp) -> anyhow::Result<()> { self.flush(pts, true)?; - for track in self.entries.values_mut().filter_map(|entry| entry.track.as_mut()) { - track.finish()?; + // Each entry keeps its own clone, whose appends the end refuses. + for track in self.entries.values().filter_map(|entry| entry.track.as_ref()) { + drop(track.clone().finish()?); } Ok(()) } diff --git a/rs/moq-mux/src/linger.rs b/rs/moq-mux/src/linger.rs index 6242c5d20d3..a73df4eb9af 100644 --- a/rs/moq-mux/src/linger.rs +++ b/rs/moq-mux/src/linger.rs @@ -92,7 +92,7 @@ mod tests { origin: &moq_net::origin::Producer, ) -> ( moq_net::broadcast::Producer, - (moq_net::origin::Route, moq_net::track::Producer), + (moq_net::origin::Route, moq_net::track::Finished), ) { let route = origin.route(PATH, moq_net::origin::RouteOptions::default()).unwrap(); let info = moq_net::track::Info::default().with_max_age(hang::container::MAX_AGE); @@ -102,7 +102,7 @@ mod tests { group.write_frame(None, bytes::Bytes::from_static(b"frame")).unwrap(); group.finish().unwrap(); } - track.finish().unwrap(); + let track = track.finish().unwrap(); (route.broadcast().clone(), (route, track)) } diff --git a/rs/moq-mux/src/source.rs b/rs/moq-mux/src/source.rs index c7c3bd050e9..0bc618413d0 100644 --- a/rs/moq-mux/src/source.rs +++ b/rs/moq-mux/src/source.rs @@ -652,7 +652,7 @@ mod tests { source.priority(0).unwrap(); assert_eq!(first.subscription(), preferences); assert_eq!(late.subscription(), preferences); - track.finish().unwrap(); + drop(track.clone().finish().unwrap()); source.priority(-1).unwrap(); // A closed track has no priority left to change. drop((held, late_held)); assert!(source.priority.lock().unwrap().controls.is_empty()); diff --git a/rs/moq-net-tests/tests/integration/ietf_conformance.rs b/rs/moq-net-tests/tests/integration/ietf_conformance.rs index ba247f91e97..082601de4d5 100644 --- a/rs/moq-net-tests/tests/integration/ietf_conformance.rs +++ b/rs/moq-net-tests/tests/integration/ietf_conformance.rs @@ -74,7 +74,7 @@ async fn routing(version: &str, cluster: bool) { let mut group = track.append_group().unwrap(); group.write_frame(None, &b"conformance"[..]).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let track = track.finish().unwrap(); let mut received = subscription.recv_group().await.unwrap().unwrap(); assert_eq!(received.sequence, 0); assert_eq!( diff --git a/rs/moq-net/benches/backing.rs b/rs/moq-net/benches/backing.rs index 0a065339395..f27e93ff7c5 100644 --- a/rs/moq-net/benches/backing.rs +++ b/rs/moq-net/benches/backing.rs @@ -270,7 +270,7 @@ struct Cache { _broadcast: broadcast::Producer, tracks: Vec, /// Each track's finished groups, oldest first, with their payload bytes. - groups: Vec>, + groups: Vec>, } impl Cache { diff --git a/rs/moq-net/benches/group.rs b/rs/moq-net/benches/group.rs index f58f998fab3..75292684cc0 100644 --- a/rs/moq-net/benches/group.rs +++ b/rs/moq-net/benches/group.rs @@ -90,10 +90,10 @@ const LIVE_BATCH: usize = 128; /// Keeps the broadcast/track producers alive alongside the group so the group /// isn't torn down mid-benchmark. Only `group` is written to. -struct Ctx { +struct Ctx { _broadcast: broadcast::Producer, _track: track::Producer, - group: group::Producer, + group: G, } /// Build a fresh, empty group via the public producer path. @@ -154,14 +154,25 @@ fn bench_write(c: &mut Criterion) { } /// A pre-filled, finished group plus a consumer positioned at its first frame. -fn filled_group(n: usize, payload: &Bytes) -> (Ctx, group::Consumer) { - let mut ctx = fresh_group(); +fn filled_group(n: usize, payload: &Bytes) -> (Ctx, group::Consumer) { + let Ctx { + _broadcast, + _track, + mut group, + } = fresh_group(); for _ in 0..n { - ctx.group.write_frame(Timestamp::ZERO, payload.clone()).unwrap(); + group.write_frame(Timestamp::ZERO, payload.clone()).unwrap(); } - ctx.group.finish().unwrap(); - let consumer = ctx.group.consume(); - (ctx, consumer) + let group = group.finish().unwrap(); + let consumer = group.consume(); + ( + Ctx { + _broadcast, + _track, + group, + }, + consumer, + ) } /// Drain a whole group through a reused `moq_net::fuzz::FrameBatch`. @@ -348,13 +359,13 @@ fn bench_roundtrip(c: &mut Criterion) { for _ in 0..n { ctx.group.write_frame(Timestamp::ZERO, payload.clone()).unwrap(); } - ctx.group.finish().unwrap(); - let mut consumer = ctx.group.consume(); + let group = ctx.group.finish().unwrap(); + let mut consumer = group.consume(); for _ in 0..n { let frame = consumer.read_frame().now_or_never().unwrap().unwrap(); black_box(frame); } - (ctx, consumer) + (ctx._broadcast, ctx._track, group, consumer) }, BatchSize::SmallInput, ); @@ -498,7 +509,7 @@ fn bench_inflate(c: &mut Criterion) { for payload in &payloads { group.write_frame(Timestamp::ZERO, payload.clone()).unwrap(); } - group.finish().unwrap(); + let group = group.finish().unwrap(); (0..readers).map(move |_| group.consume()).collect::>() }) .collect(); @@ -557,10 +568,9 @@ fn bench_compressed_updates(c: &mut Criterion) { group.write_frame(None, payload.clone()).unwrap(); groups.push(group); } - for group in &mut groups { + for group in groups.drain(..) { group.finish().unwrap(); } - groups.clear(); } } (broadcast, producers, groups) @@ -773,7 +783,7 @@ fn contended( if written + burst > ROLL { let rolled = track.append_group().unwrap(); *next.lock().unwrap() = rolled.consume(); - let mut done = std::mem::replace(&mut group, rolled); + let done = std::mem::replace(&mut group, rolled); done.finish().unwrap(); written = 0; } @@ -885,7 +895,7 @@ fn streaming(b: &mut criterion::Bencher, chunk: &Bytes, arrivals: usize, threads frame.write(chunk.clone()).unwrap(); writing = Some(match frame.remaining() { 0 => { - let mut group = frame.finish().unwrap(); + let group = frame.finish().unwrap(); frames += 1; if frames == ROLL { let rolled = track.append_group().unwrap(); diff --git a/rs/moq-net/benches/session/mod.rs b/rs/moq-net/benches/session/mod.rs index d943ef5d156..3ca39161de9 100644 --- a/rs/moq-net/benches/session/mod.rs +++ b/rs/moq-net/benches/session/mod.rs @@ -494,7 +494,7 @@ fn write_group(track: &track::Producer, payload: &Bytes, frames: usize) -> u64 { for _ in 0..frames { group.write_frame(Timestamp::ZERO, payload.clone()).unwrap(); } - group.finish().unwrap(); + let group = group.finish().unwrap(); group.sequence } @@ -1128,8 +1128,7 @@ impl Room { let group = writing.get_or_insert_with(|| self.cluster.tracks[broadcast].append_group().unwrap()); group.write_frame(Timestamp::ZERO, self.payload.clone()).unwrap(); if last { - group.finish().unwrap(); - *writing = None; + writing.take().expect("written above").finish().unwrap(); } } if last { diff --git a/rs/moq-net/benches/track.rs b/rs/moq-net/benches/track.rs index 725b7a5baa2..b918cec4138 100644 --- a/rs/moq-net/benches/track.rs +++ b/rs/moq-net/benches/track.rs @@ -660,7 +660,7 @@ fn bench_fanout_frame(c: &mut Criterion) { let mut elapsed = Duration::ZERO; for _ in 0..iterations { if written == FRAMES_PER_GROUP { - if let Some(mut open) = open.take() { + if let Some(open) = open.take() { open.finish().unwrap(); } open = Some(fanout.track.append_group().unwrap()); diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index 69422535f43..84ec2bbec72 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -34,7 +34,7 @@ use crate::{ pub type Target = fn(&[u8]) -> bool; /// Build a cached group with optional private object fields for model benchmarks. -pub fn object_group(frames: usize, properties: bool) -> (broadcast::Producer, track::Producer, group::Producer) { +pub fn object_group(frames: usize, properties: bool) -> (broadcast::Producer, track::Producer, group::Finished) { let broadcast = broadcast::Producer::new(broadcast::Info::default()); // Object properties come from a moq-transport publisher, whose draft serialized them. let info = track::Info { @@ -78,8 +78,7 @@ pub fn object_group(frames: usize, properties: bool) -> (broadcast::Producer, tr frame.write(payload.clone()).unwrap(); group = frame.finish().unwrap(); } - group.finish().unwrap(); - (broadcast, track, group) + (broadcast, track, group.finish().unwrap()) } /// A private frame batch for the model's batch read and write benchmarks. @@ -1953,7 +1952,7 @@ impl FrameRecv { if let std::task::Poll::Ready(res) = received { res.unwrap(); let stream = slot.take().unwrap(); - let mut group = stream.frame.finish().unwrap(); + let group = stream.frame.finish().unwrap(); group.finish().unwrap(); open -= 1; } @@ -2059,11 +2058,9 @@ impl GroupRecv { Ok(()) } - /// Finish the group, returning its producer, which keeps it cached until dropped or aborted. - pub fn finish(mut self) -> crate::Result { - let mut group = self.group.take().ok_or(crate::Error::Closed)?; - group.finish()?; - Ok(group) + /// Finish the group, which stays cached until dropped or aborted. + pub fn finish(mut self) -> crate::Result { + self.group.take().ok_or(crate::Error::Closed)?.finish() } } diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 343b588eeba..70405347f2b 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -6892,8 +6892,8 @@ impl TrackServe { Poll::Ready(Ok(Some(datagram))) => datagram, Poll::Ready(Ok(None)) => { self.datagrams = None; - if let Some(track) = &mut self.datagram_track { - let _ = track.finish(); + if let Some(track) = &self.datagram_track { + let _ = track.finish_shared(); } return; } @@ -8235,13 +8235,14 @@ mod group_priority_test { None, ); assert!(serve.poll(&kio::Waiter::noop()).is_pending()); + let mut group = Some(group); if finished { - group.finish().unwrap(); + group.take().unwrap().finish().unwrap(); assert!(serve.poll(&kio::Waiter::noop()).is_pending()); assert!(log.trail().iter().any(|(_, event)| matches!(event, Sent::Finish))); } track.finish_at(track::Position { group: 5, frame: 5 }, None).unwrap(); - if !finished { + if let Some(group) = group { group.finish().unwrap(); } kio::wait(|waiter| serve.poll(waiter)).await.unwrap(); @@ -8373,7 +8374,7 @@ mod group_priority_test { group .write_frame(crate::Timestamp::from_millis(0).unwrap(), b"hello".as_slice()) .unwrap(); - group.finish().unwrap(); + let group = group.finish().unwrap(); let msg = ietf::GroupHeader { track_alias: 0, @@ -8645,7 +8646,7 @@ mod group_priority_test { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"hello".as_slice()).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let mut serve = TrackServe::new( crate::driver::Transport::new(session.clone()), @@ -9052,7 +9053,7 @@ mod subscribe_cursor_test { } let subscriber = track.subscribe(None); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let mut serve = TrackServe::new( crate::driver::Transport::new(session.clone()), @@ -9185,7 +9186,7 @@ mod serve_tests { .run_subscription(&mut stream, &mut serving, &mut finished, &mut goaways, &mut updates); let mut run = std::pin::pin!(run); assert!(futures::poll!(run.as_mut()).is_pending()); - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); assert!(matches!(run.await, Some(Served::Track(Ok(())))), "{version}"); } // The same reader now watches cancellation while the final marker waits for credit. @@ -9725,7 +9726,7 @@ mod serve_tests { .await; group.finish().unwrap(); - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); kio::clock::timeout(std::time::Duration::from_secs(10), serve) .await .expect("the track's end ends the subscription") @@ -9793,7 +9794,7 @@ mod serve_tests { // Group 2 arrives later, so a verdict that forgot group 1 would wait for 2's deadline. wait(serve.as_mut(), 10).await; append(); - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); serve_until(serve.as_mut(), "group 2's stream finished", || finished() == 3).await; // Groups 0 and 1 go idle past the cache window long before the deadline. @@ -11197,7 +11198,7 @@ mod serve_tests { ); } - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); served(h, serve).await; h.session.reopen(); } @@ -11998,7 +11999,7 @@ mod serve_tests { let mut later = h.track.create_group(group::Info { sequence: 4 }).unwrap(); later.write_frame(timestamp(), b"wanted".as_slice()).unwrap(); later.finish().unwrap(); - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); serving.await.unwrap(); assert_eq!( occurrences(&h.log, b"after-update"), @@ -12095,7 +12096,7 @@ mod serve_tests { group.write_frame(timestamp(), payload.as_slice()).unwrap(); } group.finish().unwrap(); - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); serving.await.unwrap(); assert_eq!( occurrences(&h.log, b"history"), @@ -12153,7 +12154,7 @@ mod serve_tests { }) .await; // Group 1 stays open: the end falls after it. - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); let update = ietf::SubscribeUpdate { request_id: RequestId(2), subscriber_priority: None, @@ -12244,7 +12245,7 @@ mod serve_tests { }) .await; group.finish().unwrap(); - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); serving.await.unwrap(); assert_eq!(occurrences(&h.log, b"history"), 0, "the historical fill is refused"); assert_eq!(occurrences(&h.log, b"live"), 1, "the live group is not repeated"); @@ -12314,7 +12315,7 @@ mod serve_tests { group.write_frame(timestamp(), payload).unwrap(); group.finish().unwrap(); } - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); serving.await.unwrap(); assert_eq!(occurrences(&h.log, b"history"), 0, "the historical fill is refused"); assert_eq!(occurrences(&h.log, b"excluded"), 0, "the live floor stays at group 4"); @@ -12825,7 +12826,7 @@ mod serve_tests { assert!(futures::poll!(serving.as_mut()).is_pending()); } frame.finish().unwrap().finish().unwrap(); - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); served(&h, serving.as_mut()).await; assert_eq!(occurrences(&h.log, payload), 1, "{version} streamed={streamed}"); assert!(h.log.resets().is_empty(), "{version} streamed={streamed}"); @@ -13220,7 +13221,7 @@ mod serve_tests { /// request ends with it: a finished subscription keeps its join until the subscriber /// closes the request. async fn finish_and_retain(h: &Serve, mut serving: std::pin::Pin<&mut impl Future>>) { - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); for _ in 0..200 { assert!( futures::poll!(serving.as_mut()).is_pending(), @@ -13388,7 +13389,7 @@ mod serve_tests { }; *writable = false; drop(writable); - track.finish().unwrap(); + let _track = track.finish().unwrap(); for _ in 0..50 { assert!(futures::poll!(serving.as_mut()).is_pending(), "{version}"); settle().await; @@ -13453,7 +13454,7 @@ mod serve_tests { registered_as(&h, RequestId(id), serving.as_mut()).await; servings.push(serving); } - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); for _ in 0..50 { for serving in &mut servings { assert!(futures::poll!(serving.as_mut()).is_pending(), "{version}"); @@ -14508,7 +14509,7 @@ mod serve_tests { publish_pairs(h, 5, None); match largest { Largest::Finished => { - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); None } Largest::Live => Some(h.track.create_group(group::Info { sequence: 5 }).unwrap()), @@ -14523,7 +14524,7 @@ mod serve_tests { } Largest::IdleFinished => { h.track.set_idle(); - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); None } Largest::Aborted => { @@ -14591,7 +14592,7 @@ mod serve_tests { let version = Version::Draft22; let mut h = serve(version); publish_pairs(&mut h, 5, None); - let mut empty = h.track.create_group(group::Info { sequence: 5 }).unwrap(); + let empty = h.track.create_group(group::Info { sequence: 5 }).unwrap(); empty.finish().unwrap(); settle().await; @@ -14680,7 +14681,7 @@ mod serve_tests { for version in FETCH_DRAFTS { let mut h = serve(version); publish_pairs(&mut h, 5, None); - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); settle().await; let buf = standalone_fetch( @@ -14709,7 +14710,7 @@ mod serve_tests { for end in [1, 2] { let mut h = serve(version); publish_pairs(&mut h, 5, None); - h.track.finish().unwrap(); + h.track.finish_shared().unwrap(); settle().await; let buf = standalone_fetch( @@ -15581,7 +15582,9 @@ mod serve_tests { group.finish().unwrap(); } // An empty finished track: nothing to serve but the marker. - _ => track.finish().unwrap(), + _ => { + track.finish_shared().unwrap(); + } } (None, Some((broadcast, track))) } @@ -16433,7 +16436,7 @@ mod serve_tests { group.write_frame(crate::Timestamp::ZERO, payload.as_slice()).unwrap(); } group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let range = ServeRange { start: Some(Location { group: 0, object: 0 }), @@ -21514,7 +21517,7 @@ mod compression_tests { group.write_frame(crate::Timestamp::ZERO, payload.clone()).unwrap(); } group.finish().unwrap(); - track.finish().unwrap(); + track.finish_shared().unwrap(); let response = ietf::SubscribeOk { track_alias: 0, largest: None, diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index d3b76f9e9ca..05f82407eaa 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -389,7 +389,7 @@ impl Fill { /// stitched. Finishing rather than aborting, because the head is a valid prefix of the /// group: it starts at the group's first object and has no holes. fn release(&mut self) { - if let Fill::Ready { mut producer, .. } = std::mem::replace(self, Fill::Done) { + if let Fill::Ready { producer, .. } = std::mem::replace(self, Fill::Done) { let _ = producer.finish(); } } @@ -5026,7 +5026,7 @@ impl Established { // A no-op once an END_OF_TRACK declared the end, whose readers // wait for a missing group only as long as the grace. Ok(()) => { - let _ = self.track.finish(); + let _ = self.track.finish_shared(); self.finished = true; } Err(err) => { @@ -15018,7 +15018,7 @@ mod stitch_tests { h.subscriber.state.lock().subscribes.get_mut(&REQUEST).unwrap().producer = Some(track.clone()); let mut stream = h.stream().await.with_version(ingress); h.subscriber.clone().recv_group(&mut stream).await.unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let (served, _sessions) = match hop { true => { let (served, sessions) = crate::lite::ietf::test_hop(&origin, "room", [true, true]).await; diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index 57e795ef8f2..5ba97e00f22 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -6695,7 +6695,7 @@ mod serve_group_test { for i in 0..4u8 { group.write_frame(Timestamp::ZERO, vec![i]).unwrap(); } - group.finish().unwrap(); + let group = group.finish().unwrap(); let ending = |group, frame| { let mut frames = Frames::default(); frames.add(group, 0, Some(frame)); @@ -7932,7 +7932,7 @@ mod serve_group_test { write_group(&mut track, 0, 0); assert!(futures::poll!(run.as_mut()).is_pending()); write_group(&mut track, 2, 2); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert!(futures::poll!(run.as_mut()).is_pending(), "the stream stays open"); // SUBSCRIBE_START with the range starting at 0, a DROP for group 1 with OLD (0x34) @@ -7960,7 +7960,7 @@ mod serve_group_test { assert!(futures::poll!(run.as_mut()).is_pending()); write_group(&mut track, 2, 2); track.skip_groups(1..2); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert!(futures::poll!(run.as_mut()).is_pending(), "the stream stays open"); // SUBSCRIBE_START with the range starting at 0, a SKIP for group 1, and @@ -8027,7 +8027,7 @@ mod serve_group_test { while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} track.skip_groups(1..FAR); write_group(&mut track, FAR, 1); - track.finish().unwrap(); + let _track = track.finish().unwrap(); while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} kio::wait(|waiter| writer.poll_flush(waiter)).await.unwrap(); @@ -8186,7 +8186,7 @@ mod serve_group_test { update: 1, }); write_group(&mut track, 2, 2000); - track.finish().unwrap(); + let _track = track.finish().unwrap(); while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} assert_eq!( run.ctx.outcomes.opened.load(Ordering::Relaxed), @@ -9687,7 +9687,7 @@ mod serve_group_test { crate::track::Info::timed(), ); let subscriber = track.subscribe(None); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let (mut run, mut writer, log) = lite07_run(SinkSession::new(Log::default()), subscriber); assert!( @@ -9717,7 +9717,7 @@ mod serve_group_test { // Group 1 lands a second later, expiring group 0 before it ever opened. kio::clock::sim::advance(Duration::from_secs(1)).await; write_group(&mut track, 1, 1000); - track.finish().unwrap(); + let _track = track.finish().unwrap(); assert!(futures::poll!(run.as_mut()).is_pending(), "group 1 is still opening"); assert_eq!( *log.writes.lock().unwrap(), diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 1dd1be440a9..2b261ec5b32 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -980,7 +980,7 @@ impl SubscriptionCleanup { continue; }; if entry.tail.read().is_ended() { - let _ = producer.finish(); + let _ = producer.finish_shared(); } let _ = producer.abort(err.clone()); } @@ -5417,9 +5417,9 @@ mod tests { update: 0, }) }; - let frame = |group: &mut crate::group::Producer| { + let frame = |mut group: crate::group::Producer| { group.write_frame(crate::Timestamp::from_millis(1).unwrap(), &b"x"[..])?; - group.finish() + group.finish().map(drop) }; let arrive = |serving: &mut ServeLoop, sequence| { let group = serving.serving.create_group(crate::group::Info { sequence }).unwrap(); @@ -5428,15 +5428,15 @@ mod tests { // OLD, then the group, which finishes. serving.apply_response(&serve, old(1)).unwrap(); - let (mut one, reading) = arrive(&mut serving, 1); - frame(&mut one).unwrap(); + let (one, reading) = arrive(&mut serving, 1); + frame(one).unwrap(); drop(reading); // The group first, still arriving when its OLD lands. - let (mut two, _two) = arrive(&mut serving, 2); + let (two, _two) = arrive(&mut serving, 2); serving.apply_response(&serve, old(2)).unwrap(); // OLD, then the group, still arriving at the update. serving.apply_response(&serve, old(3)).unwrap(); - let (mut three, _three) = arrive(&mut serving, 3); + let (three, _three) = arrive(&mut serving, 3); // OLD, and no group. serving.apply_response(&serve, old(4)).unwrap(); @@ -5450,8 +5450,8 @@ mod tests { let covers = |groups: std::ops::Range| tail.read().covers(groups); assert!(covers(1..4), "every group that arrived stays accounted for"); assert!(!covers(4..5), "the group that never arrived is owed again"); - frame(&mut two).expect("the drop leaves a group still arriving"); - frame(&mut three).expect("the update leaves a group still arriving"); + frame(two).expect("the drop leaves a group still arriving"); + frame(three).expect("the update leaves a group still arriving"); } /// A group whose stream finished wins over a lite-07 stale drop that lands after the cache @@ -6635,11 +6635,11 @@ mod tests { Err(_) => panic!("the entry holds the parked streams"), }; assert_eq!(opened, [kept], "the withdrawn group is gone"); - let Ok(Open::Group(Opened { mut group, .. })) = entry.unpark(kept) else { + let Ok(Open::Group(Opened { group, .. })) = entry.unpark(kept) else { panic!("the kept group"); }; group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); // Only the kept group reaches the subscriber: the withdrawn one ended, so nothing // waits on it. let mut sequences = Vec::new(); @@ -7432,10 +7432,10 @@ mod tests { assert!(serving.poll(&serve, &kio::Waiter::noop()).is_pending()); // Held for the whole round: a dropped tail settles at once. let tail = kio::Producer::new(Tail::default()); - let mut group = serving.serving.append_group().unwrap(); + let mut group = Some(serving.serving.append_group().unwrap()); if let Some(finished) = ended { if finished { - group.finish().unwrap(); + group.take().unwrap().finish().unwrap(); } if version.has_track_stream() { serving.serving.finish_at(Position::group(1), None).unwrap(); @@ -12017,7 +12017,7 @@ impl ServeLoop { return Poll::Pending; } if !serve.subscriber.version.has_track_stream() { - let _ = self.serving.finish(); + let _ = self.serving.finish_shared(); } return Poll::Ready(ServeEnd::GiveBack(crate::lite::error::from_transport(err))); } diff --git a/rs/moq-net/src/model/broadcast.rs b/rs/moq-net/src/model/broadcast.rs index 1158c5847a5..0f2530481b5 100644 --- a/rs/moq-net/src/model/broadcast.rs +++ b/rs/moq-net/src/model/broadcast.rs @@ -1969,7 +1969,7 @@ mod test { // Close the producer (simulating publisher disconnect). producer1.append_group().unwrap().finish().unwrap(); - producer1.finish().unwrap(); + let producer1 = producer1.finish().unwrap(); drop(producer1); // The consumer should see the track as closed. @@ -2006,7 +2006,7 @@ mod test { let mut group = first.create_group(crate::group::Info { sequence: 8 }).unwrap(); group.write_frame(at(1000), b"a".as_slice()).unwrap(); group.finish().unwrap(); - first.finish().unwrap(); + let first = first.finish().unwrap(); drop((first, track)); let track = consumer.track("media").unwrap().subscribe(None); @@ -2306,7 +2306,7 @@ mod test { let track = consumer.track("track1").unwrap(); let pending_fetch = track.fetch_group(0, None); let fetch = dynamic.requested_fill_group().await.unwrap(); - let mut group = fetch.accept(crate::track::Info::timed()).unwrap(); + let group = fetch.accept(crate::track::Info::timed()).unwrap(); group.finish().unwrap(); pending_fetch.await.unwrap(); @@ -2385,7 +2385,7 @@ mod test { track.append_group().unwrap().finish().unwrap(); subscriber.assert_group(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); } /// The publisher may still be holding the `track::Request` for a name the broadcast diff --git a/rs/moq-net/src/model/group.rs b/rs/moq-net/src/model/group.rs index bfdb76d219d..f03171766a4 100644 --- a/rs/moq-net/src/model/group.rs +++ b/rs/moq-net/src/model/group.rs @@ -2256,11 +2256,11 @@ impl Producer { let _ = self.handle.close_aborted(err); } - /// Mark the group as complete; no more frames will be written. + /// Mark the group as complete, returning the [`Finished`] group: no more frames can be + /// written, but it can still be read or aborted. /// - /// Borrows rather than consumes, so a later failure can still be reported through - /// [`abort`](Self::abort). The handle also keeps the cached frames readable. - pub fn finish(&mut self) -> Result<()> { + /// Fails with the abort error if the group was already aborted. + pub fn finish(self) -> Result { let mut state = modify(&self.handle.state)?; debug_assert!(state.partial.is_none(), "a frame is already open"); let fin = state.next_index; @@ -2278,7 +2278,9 @@ impl Producer { if original_fin.is_some() { self.handle.cache.finish_largest(self.sequence); } - Ok(()) + Ok(Finished { + handle: self.handle.clone(), + }) } /// Abort the group with the given error. @@ -2286,9 +2288,6 @@ impl Producer { /// Consumes the writer. Drops the cached frames so a stale [`Consumer`] can't pin /// their buffers in memory forever; consumers that haven't drained yet surface the /// abort error instead of the leftover cache. - /// - /// After [`finish`](Self::finish) the outcome is already settled, so this only releases - /// the cache: the group stays finished, and a reader that drained it ends cleanly. pub fn abort(self, err: Error) -> Result<()> { self.handle.close_aborted(err) } @@ -2395,6 +2394,52 @@ impl Producer { } } +/// A group whose writer [finished](Producer::finish) it: every frame is written, and it can +/// still be read or aborted, but not written to. +/// +/// Dropping it leaves the group finished. +/// +/// ```compile_fail,E0599 +/// # fn cannot_write(group: moq_net::group::Finished) { +/// group.write_frame(None, b"late".as_slice()).unwrap(); +/// # } +/// ``` +pub struct Finished { + handle: Handle, +} + +impl std::ops::Deref for Finished { + type Target = Info; + + fn deref(&self) -> &Self::Target { + &self.handle.info + } +} + +impl Finished { + #[cfg(all(test, feature = "async"))] + pub(crate) fn handle(&self) -> Handle { + self.handle.clone() + } + + /// Release the group's cached frames, reporting `err` to readers that have not drained it. + /// + /// The group stays finished: a reader that took every frame still ends cleanly. + pub fn abort(self, err: Error) -> Result<()> { + self.handle.close_aborted(err) + } + + /// The number of frames the group holds, counting any it [started past](Producer::start_at). + pub fn frame_count(&self) -> usize { + self.handle.frame_count() + } + + /// Create a new consumer for the group. + pub fn consume(&self) -> Consumer { + self.handle.consume() + } +} + impl Handle { /// Whether `reader` may ride this copy at its frame: it holds the frame, no further /// than [`ADMIT`] behind the end of the last frame its fastest reader took, so the @@ -4843,7 +4888,7 @@ mod test { for _ in 0..Prefetch::CAP { group.write_frame(None, Bytes::from_static(b"p")).unwrap(); } - group.finish().unwrap(); + let group = group.finish().unwrap(); let expected = |index: u64| (1..=10).contains(&index).then_some(index * 10); let mut objects = group.consume(); @@ -4897,7 +4942,7 @@ mod test { let charged = size_of::() as u64 + fields.heap(); group.set_end_object(fields.clone()).unwrap(); assert!(matches!(group.set_end_object(fields), Err(Error::MalformedTrack))); - group.finish().unwrap(); + let group = group.finish().unwrap(); let consumer = group.consume(); group.abort(Error::Cancel).unwrap(); assert_eq!(consumer.end_object().unwrap().id, 4); @@ -5023,7 +5068,7 @@ mod test { producer .write_frame(Timestamp::ZERO, Bytes::from_static(b"frame1")) .unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); let f0 = consumer.next_frame().now_or_never().unwrap().unwrap().unwrap(); @@ -5040,7 +5085,7 @@ mod test { let mut producer = Info { sequence: 0 }.produce(); let timestamp = Timestamp::from_micros(20_000).unwrap(); producer.write_frame(timestamp, Bytes::from_static(b"hello")).unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); let frame = consumer.read_frame().now_or_never().unwrap().unwrap().unwrap(); @@ -5061,7 +5106,7 @@ mod test { ); producer.write_frame(None, Bytes::from_static(b"hello")).unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); assert!(producer.handle.poll_started(&waiter).is_ready()); assert_eq!(producer.handle.timestamp(), None); @@ -5131,8 +5176,8 @@ mod test { .unwrap(); frame.write(Bytes::from_static(b"hello")).unwrap(); frame.write(Bytes::from_static(b"world")).unwrap(); - let mut producer = frame.finish().unwrap(); - producer.finish().unwrap(); + let producer = frame.finish().unwrap(); + let producer = producer.finish().unwrap(); // Frame data is held in a single per-frame buffer; a whole-frame read returns // the full contents in one slice. @@ -5173,8 +5218,8 @@ mod test { #[test] #[cfg(feature = "async")] fn group_finish_returns_none() { - let mut producer = Info { sequence: 0 }.produce(); - producer.finish().unwrap(); + let producer = Info { sequence: 0 }.produce(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); let end = consumer.next_frame().now_or_never().unwrap().unwrap(); @@ -5195,8 +5240,7 @@ mod test { .map(|sequence| { let mut group = track.create_group(Info { sequence }).unwrap(); group.write_frame(Timestamp::ZERO, b"f".as_ref()).unwrap(); - group.finish().unwrap(); - group + group.finish().unwrap() }) .collect(); subscriber.set_range(..0); @@ -5467,7 +5511,7 @@ mod test { "no gap below the stream" ); tail.write_frame(None, Bytes::from_static(b"c")).unwrap(); - tail.finish().unwrap(); + let tail = tail.finish().unwrap(); let waiter = kio::Waiter::noop(); let mut whole = tail.consume(); @@ -5554,7 +5598,7 @@ mod test { producer .write_frame(Timestamp::ZERO, Bytes::from_static(b"data")) .unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); drop(producer); @@ -5686,7 +5730,7 @@ mod test { for _ in 0..10_000 { producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"x")).unwrap(); } - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let state = producer.handle.state.read(); assert_eq!(state.offset, 0); @@ -5709,7 +5753,7 @@ mod test { assert!(freed >= 3 * 1024, "freed {freed}"); assert_eq!(producer.handle.state.read().held(), 3); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); producer.handle.shed(u64::MAX, u64::MAX); assert!(producer.handle.state.read().is_empty()); assert_eq!(producer.handle.state.read().cache, 0); @@ -5740,13 +5784,13 @@ mod test { } #[cfg(feature = "async")] - fn prefetched_consumer(pool: &cache::Pool, max_age: std::time::Duration) -> (Producer, Consumer) { + fn prefetched_consumer(pool: &cache::Pool, max_age: std::time::Duration) -> (Finished, Consumer) { let cache = cache::Track::new(pool.clone(), Default::default(), kio::Weak::new()); let track = track::Info::timed().with_max_age(max_age); let mut producer = Producer::new(Info { sequence: 0 }, track, cache); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"a")).unwrap(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"b")).unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); consumer.read_frame().now_or_never().unwrap().unwrap().unwrap(); @@ -5838,7 +5882,7 @@ mod test { .write_frame(Timestamp::ZERO, Bytes::from(vec![i as u8; 4])) .unwrap(); } - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); for i in 0..n { @@ -5858,7 +5902,7 @@ mod test { producer .write_frame(Timestamp::ZERO, Bytes::from_static(b"hello")) .unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut drained = producer.consume(); let mut behind = producer.consume(); @@ -5884,7 +5928,7 @@ mod test { let mut producer = Info { sequence: 0 }.produce(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"a")).unwrap(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"b")).unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut drained = producer.consume(); let mut behind = producer.consume(); @@ -5931,7 +5975,7 @@ mod test { for i in 0..5u8 { producer.write_frame(Timestamp::ZERO, Bytes::from(vec![i; 1])).unwrap(); } - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); // The first whole-frame read prefetches all five frames into the batch. @@ -5977,7 +6021,7 @@ mod test { for _ in 0..Prefetch::CAP { producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"x")).unwrap(); } - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); // Take one frame so the batch is filled but only partially drained. @@ -6046,7 +6090,7 @@ mod test { .push(Frame::new(Timestamp::ZERO, Bytes::from_static(b"e"))) .unwrap(); producer.write_frames(&mut batch).unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; let mut consumer = producer.consume(); @@ -6063,13 +6107,13 @@ mod test { #[cfg(feature = "async")] async fn groups_carry_when_they_landed() { let start = kio::clock::now(); - let mut alone = Info { sequence: 0 }.produce(); + let alone = Info { sequence: 0 }.produce(); let track = crate::broadcast::Info::new() .produce() .create_track("test", None) .unwrap(); let mut subscriber = track.subscribe(None); - let mut live = track.create_group(Info { sequence: 0 }).unwrap(); + let live = track.create_group(Info { sequence: 0 }).unwrap(); kio::clock::sleep(std::time::Duration::from_secs(1)).await; assert_eq!(alone.consume().arrived(), start); @@ -6130,7 +6174,7 @@ mod test { let mut producer = Info { sequence: 0 }.produce(); producer.start_at(3).unwrap(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"d")).unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); // The frame landed at index 3, so the group's length counts the missing head. assert_eq!(producer.frame_count(), 4); @@ -6158,7 +6202,7 @@ mod test { let mut producer = Info { sequence: 0 }.produce(); producer.start_at(3).unwrap(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"d")).unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume().with_range(1..); assert_eq!(consumer.index(), 3, "clamped up to the first frame that exists"); @@ -6177,7 +6221,7 @@ mod test { for i in 0..4u8 { producer.write_frame(Timestamp::ZERO, Bytes::from(vec![i])).unwrap(); } - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); consumer = consumer.with_range(..2); @@ -6208,7 +6252,7 @@ mod test { for i in 0..4u8 { producer.write_frame(Timestamp::ZERO, Bytes::from(vec![i])).unwrap(); } - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); consumer = consumer.with_range(1..=1); assert_eq!( @@ -6236,7 +6280,7 @@ mod test { fn end_at_zero_is_empty() { let mut producer = Info { sequence: 0 }.produce(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"x")).unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); consumer = consumer.with_range(..0); @@ -6267,11 +6311,6 @@ mod test { producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"a")).unwrap(); assert!(matches!(producer.start_at(4), Err(Error::Closed))); assert_eq!(producer.frame_count(), 4, "the frame landed at index 3"); - - // Finishing likewise settles the shape. - let mut producer = Info { sequence: 1 }.produce(); - producer.finish().unwrap(); - assert!(matches!(producer.start_at(1), Err(Error::Closed))); } /// The start must leave room for at least one frame index. @@ -6347,7 +6386,7 @@ mod test { assert!(group.poll_closed(&kio::Waiter::noop()).is_pending()); frame.write(Bytes::from_static(b"b")).unwrap(); - let mut producer = frame.finish().unwrap(); + let producer = frame.finish().unwrap(); producer.finish().unwrap(); let mut read = || consumer.read_frame().now_or_never().unwrap().unwrap(); assert_eq!(read().unwrap().payload, Bytes::from_static(b"a")); @@ -6382,8 +6421,8 @@ mod test { assert!(demand.poll_closed(&waiter).is_pending()); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"a")).unwrap(); - producer.finish().unwrap(); - assert!(matches!(producer.poll_closed(&waiter), Poll::Ready(Ok(())))); + let producer = producer.finish().unwrap(); + assert!(matches!(handle.poll_closed(&waiter), Poll::Ready(Ok(())))); assert!(matches!(demand.poll_closed(&waiter), Poll::Ready(Ok(())))); assert!( handle.poll_aborted(&waiter).is_pending(), @@ -6457,7 +6496,7 @@ mod test { second.abort(Error::Cancel).unwrap(); first.write(Bytes::from(vec![0u8; 1023])).unwrap(); - let mut a = first.finish().unwrap(); + let a = first.finish().unwrap(); a.finish().unwrap(); let a = group(2); @@ -6514,7 +6553,7 @@ mod test { } group = frame.finish().unwrap(); } - group.finish().unwrap(); + let group = group.finish().unwrap(); let mut whole = group.consume(); for (i, payload) in payloads.iter().enumerate() { @@ -6638,7 +6677,7 @@ mod test { for _ in 0..8 { group.write_frame(None, frame.clone()).unwrap(); } - group.finish().unwrap(); + let group = group.finish().unwrap(); let mut plain = group.consume(); for _ in 0..8 { assert_eq!(read_plain(&mut plain).unwrap().unwrap(), frame); @@ -6670,8 +6709,7 @@ mod test { for frame in &frames { group.write_frame(None, frame.clone()).unwrap(); } - group.finish().unwrap(); - group.finish().unwrap(); + let group = group.finish().unwrap(); let mut raw = group.consume().compressed(); let mut decoder = flate::Decoder::new(); for (frame, expected) in frames.iter().zip(&slices) { @@ -6709,7 +6747,7 @@ mod test { } group = frame.finish().unwrap(); group.write_frame(None, verbose(2)).unwrap(); - group.finish().unwrap(); + let group = group.finish().unwrap(); let plain: usize = (0..3).map(|index| verbose(index).len()).sum(); let stored = pool.used(); @@ -6722,7 +6760,7 @@ mod test { for index in 0..3 { reference.write_frame(None, verbose(index)).unwrap(); } - reference.finish().unwrap(); + let _reference = reference.finish().unwrap(); assert!( stored - flate::ENCODER_HEAP + (plain as u64) / 2 < uncompressed.used(), "slices are stored: {stored} against {}", @@ -6799,9 +6837,9 @@ mod test { assert_eq!(refused.handle.state.read().offset, 2, "a plain head stays out"); let head = fail(&mut compressed_group(&pool)); - let mut group = successor(); + let group = successor(); group.handle.adopt_head(&head); - group.finish().unwrap(); + let group = group.finish().unwrap(); let mut reader = group.consume(); for index in 0..2 { assert_eq!( @@ -6814,8 +6852,8 @@ mod test { } /// The slices a plain read up to local frame `last` takes under the group's guard. - fn take_slices(group: &Producer, last: usize) -> Inflate { - let state = group.handle.state.read(); + fn take_slices(group: &Handle, last: usize) -> Inflate { + let state = group.state.read(); state.inflate(state.flate.as_ref().unwrap(), last, last).unwrap() } @@ -6843,13 +6881,12 @@ mod test { for index in 0..3 { group.write_frame(None, verbose(index)).unwrap(); } - group.finish().unwrap(); - group + group.finish().unwrap() }; let group = write(); let (stored, used) = (group.handle.cache_size(), pool.used()); - let (first, second) = (take_slices(&group, 2), take_slices(&group, 2)); + let (first, second) = (take_slices(&group.handle, 2), take_slices(&group.handle, 2)); first.run(&meter); // The inflated copy bills each frame's slot beside its bytes. let copy = plain + 3 * size_of::() as u64; @@ -6869,7 +6906,7 @@ mod test { assert_eq!(inflated(), plain, "each inflated byte counts once"); let group = write(); - let late = take_slices(&group, 1); + let late = take_slices(&group.handle, 1); group.handle().abort(Error::Evicted).unwrap(); let used = pool.used(); late.run(&meter); @@ -6885,15 +6922,15 @@ mod test { for index in 0..2 { released.write_frame(None, verbose(index)).unwrap(); } - released.finish().unwrap(); + let released = released.finish().unwrap(); let content = released.handle.activate_content().unwrap().unwrap(); let mut survivor = Producer::new(Info::from(0u64), info, cache); survivor.handle.share_content(content); for index in 0..3 { survivor.write_frame(None, verbose(index)).unwrap(); } - survivor.finish().unwrap(); - let late = take_slices(&released, 1); + let survivor = survivor.finish().unwrap(); + let late = take_slices(&released.handle, 1); released.handle().abort(Error::Evicted).unwrap(); let used = pool.used(); late.run(&stats::Meter::default()); @@ -6941,7 +6978,7 @@ mod test { frame.write(Bytes::copy_from_slice(chunk)).unwrap(); } group = frame.finish().unwrap(); - group.finish().unwrap(); + let group = group.finish().unwrap(); let stored: u64 = (group.handle.state.read().entries(0, usize::MAX)) .map(|entry| entry.frame.payload.len() as u64) @@ -6972,7 +7009,7 @@ mod test { let held = stored + flate::ENCODER_HEAP + flate::DECODER_HEAP + inflated; assert_eq!(group.handle.cache_size(), held, "an open group keeps both"); - group.finish().unwrap(); + let group = group.finish().unwrap(); assert_eq!( group.handle.cache_size(), stored + inflated, @@ -6986,7 +7023,7 @@ mod test { let mut reader = group.consume(); assert_eq!(read_plain(&mut reader).unwrap().unwrap(), verbose(0)); group.write_frame(None, verbose(1)).unwrap(); - group.finish().unwrap(); + let group = group.finish().unwrap(); let stored = group.handle.state.read().charge.size() + Flate::RELEASE_HEAP; assert_eq!(read_plain(&mut reader).unwrap().unwrap(), verbose(1)); assert_eq!(group.handle.cache_size(), stored + inflated); @@ -6995,8 +7032,8 @@ mod test { let mut group = compressed_group(&pool); group.write_frame(None, verbose(0)).unwrap(); group.write_frame(None, verbose(1)).unwrap(); - let job = take_slices(&group, 1); - group.finish().unwrap(); + let job = take_slices(&group.handle, 1); + let group = group.finish().unwrap(); job.run(&stats::Meter::default()); let stored = group.handle.state.read().charge.size() + Flate::RELEASE_HEAP; assert_eq!(group.handle.cache_size(), stored + inflated, "the decoder is dropped"); @@ -7010,7 +7047,7 @@ mod test { let mut group = compressed_group(&pool); group.start_at(1).unwrap(); group.write_frame(None, verbose(1)).unwrap(); - group.finish().unwrap(); + let group = group.finish().unwrap(); let mut consumer = group.consume().with_range(1..); assert!(matches!(read_plain(&mut consumer), Err(Error::Lagged))); @@ -7063,8 +7100,8 @@ mod test { }; let mut frame = group.create_object(header).unwrap(); frame.write(slice).unwrap(); - let mut group = frame.finish().unwrap(); - group.finish().unwrap(); + let group = frame.finish().unwrap(); + let group = group.finish().unwrap(); assert!(matches!(read_plain(&mut group.consume()), Err(Error::WrongSize))); } @@ -7255,7 +7292,7 @@ mod test { producer .write_frame(crate::Timestamp::ZERO, Bytes::from_static(b"a")) .unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let expired = Switch::default(); let mut group = producer.consume().with_expiry(Arc::new(expired.clone())); @@ -7278,8 +7315,8 @@ mod test { let pool = cache::Pool::unbounded(); let mut group = compressed_group(&pool); group.write_frame(None, verbose(0)).unwrap(); - group.finish().unwrap(); - let job = take_slices(&group, 0); + let group = group.finish().unwrap(); + let job = take_slices(&group.handle, 0); let retained = job.release.clone(); group.abort(Error::Evicted).unwrap(); assert_eq!( diff --git a/rs/moq-net/src/model/listing.rs b/rs/moq-net/src/model/listing.rs index 2a2763d5175..668ee4e2149 100644 --- a/rs/moq-net/src/model/listing.rs +++ b/rs/moq-net/src/model/listing.rs @@ -815,10 +815,10 @@ mod tests { let c = broadcast.create_track("c", None).unwrap(); let mut tracks = broadcast.consume().tracks().unwrap(); assert_eq!(drain(&mut tracks), ["+a", "+b", "+c", "synced"]); - a.finish().unwrap(); + let a = a.finish().unwrap(); drop(a); drop(b); - c.finish().unwrap(); + let c = c.finish().unwrap(); c.abort(Error::Cancel).unwrap(); assert_eq!(drain(&mut tracks), ["~a", "-b", "-c"]); } @@ -831,7 +831,7 @@ mod tests { let a = broadcast.create_track("a", None).unwrap(); let mut tracks = broadcast.consume().tracks().unwrap(); assert_eq!(drain(&mut tracks), ["+a", "synced"]); - a.finish().unwrap(); + let a = a.finish().unwrap(); drop(a); let _a = broadcast.create_track("a", None).unwrap(); assert_eq!(pending(&tracks), 1, "the removal and re-add collapse"); @@ -864,11 +864,11 @@ mod tests { let live = broadcast.create_track("live", None).unwrap(); let mut tracks = broadcast.consume().tracks().unwrap(); assert_eq!(drain(&mut tracks), ["+a", "+b", "+live", "synced"]); - a.finish().unwrap(); + let a = a.finish().unwrap(); drop(a); drop(b); let _unseen = broadcast.create_track("unseen", None).unwrap(); - live.finish().unwrap(); + let _live = live.finish().unwrap(); broadcast.close(); assert_eq!(drain(&mut tracks), ["~a", "-b", "~live", "end"]); @@ -880,7 +880,7 @@ mod tests { let a = broadcast.create_track("a", None).unwrap(); let mut tracks = broadcast.consume().tracks().unwrap(); assert_eq!(drain(&mut tracks), ["+a", "synced"]); - a.finish().unwrap(); + let _a = a.finish().unwrap(); broadcast.close(); assert_eq!(drain(&mut tracks), ["~a", "end"]); diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index 9d6f064c724..d8f2f335a23 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -4027,7 +4027,7 @@ impl TrackIo { None => { if let Some(accepted) = self.accepted.take() { let _ = match &result { - Ok(()) => accepted.finish(), + Ok(()) => accepted.finish().map(drop), // A failed track refuses newcomers too, so they ask afresh. Err(err) => accepted.abort(err.clone()), }; @@ -8616,7 +8616,7 @@ mod tests { let mut group = source.create_group(7u64.into()).unwrap(); group.write_frame(crate::Timestamp::ZERO, b"snapshot".as_ref()).unwrap(); group.finish().unwrap(); - source.finish().unwrap(); + let source = source.finish().unwrap(); let routes = crate::model::resume::Producer::new(); routes.serve(source.consume()); @@ -10324,9 +10324,9 @@ mod tests { assert_eq!(listed(&mut tracks).await, event); } - dropped.finish().unwrap(); + let dropped = dropped.finish().unwrap(); drop(dropped); - held.finish().unwrap(); + let _held = held.finish().unwrap(); source.broadcast().close(); for event in ["~dropped", "~held", "end"] { assert_eq!(listed(&mut tracks).await, event); @@ -10687,7 +10687,7 @@ mod tests { let mut group = source.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"late".as_ref()).unwrap(); group.finish().unwrap(); - source.finish().unwrap(); + let source = source.finish().unwrap(); let mut subscription = subscribing.await.expect("subscribe survives the retraction"); assert_eq!(subscription.info(), source.info(), "the source's actual track info"); @@ -10733,7 +10733,7 @@ mod tests { let mut group = source.create_group(0u64.into()).unwrap(); group.write_frame(crate::Timestamp::ZERO, b"snapshot".as_ref()).unwrap(); group.finish().unwrap(); - source.finish().unwrap(); + let source = source.finish().unwrap(); let mut subscription = subscribing.await.unwrap().expect("subscribe"); assert_eq!( next_group(&mut subscription) @@ -11290,7 +11290,7 @@ mod tests { let mut group = source.create_group(1u64.into()).unwrap(); group.write_frame(crate::Timestamp::ZERO, b"late".as_ref()).unwrap(); group.finish().unwrap(); - source.finish().unwrap(); + let _source = source.finish().unwrap(); let mut subscription = subscribing.await.unwrap().expect("subscribe survives the retraction"); let mut payloads = Vec::new(); @@ -14278,7 +14278,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"tail".as_ref()).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let track = track.finish().unwrap(); drop(track); broadcast.broadcast().close(); @@ -14332,7 +14332,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"tail".as_ref()).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let track = track.finish().unwrap(); drop(track); let mut group = next_group(&mut subscription) @@ -14752,7 +14752,7 @@ mod tests { assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"still"); // The incumbent's clean end is the track's, not the newcomer's error. - old.finish().unwrap(); + let _old = old.finish().unwrap(); assert!(matches!(next_group(&mut subscription).await, Ok(None))); } @@ -14792,7 +14792,7 @@ mod tests { assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"still"); // The incumbent's clean end is the track's, not the newcomer's error. - old.finish().unwrap(); + let _old = old.finish().unwrap(); assert!(matches!(next_group(&mut subscription).await, Ok(None))); } @@ -14819,7 +14819,7 @@ mod tests { let mut group = old.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"last".as_ref()).unwrap(); group.finish().unwrap(); - old.finish().unwrap(); + let _old = old.finish().unwrap(); replacement.abort(Error::App(7)).unwrap(); let mut group = next_group(&mut subscription) @@ -14869,7 +14869,7 @@ mod tests { for _ in 0..10 { kio::clock::sim::yield_now().await; } - old.finish().unwrap(); + let _old = old.finish().unwrap(); replacement.abort(Error::App(7)).unwrap(); assert!(matches!(next_group(&mut later).await, Ok(None))); @@ -14947,7 +14947,7 @@ mod tests { for _ in 0..10 { kio::clock::sim::yield_now().await; } - replacement.finish().unwrap(); + let replacement = replacement.finish().unwrap(); assert!(matches!(next_group(&mut subscription).await, Ok(None))); drop(replacement); @@ -15898,7 +15898,7 @@ mod tests { let mut written = track.append_group().unwrap(); written.write_frame(crate::Timestamp::ZERO, b"frame".as_ref()).unwrap(); written.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let mut reader = resolved.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = reader.recv_group().await.unwrap().unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload.as_ref(), b"frame"); diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index fbdb0257af9..be6602d6845 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -3349,7 +3349,7 @@ mod test { }; let mut corrupt = group.create_object(header).unwrap(); corrupt.write(slice).unwrap(); - let mut group = corrupt.finish().unwrap(); + let group = corrupt.finish().unwrap(); group.finish().unwrap(); let mut reading = recv(&mut sub); @@ -4501,7 +4501,7 @@ mod test { for sequence in 0..4 { write(&c, sequence); } - c.finish().unwrap(); + let c = c.finish().unwrap(); nested_routes.serve(c.consume()); assert!(matches!(sub.poll_next_group(&waiter), Poll::Ready(Ok(None)))); } @@ -4554,7 +4554,7 @@ mod test { write(&c, sequence); } assert_eq!(drain(&mut sub, true), [4], "a newly ready copy inherits the floor"); - c.finish().unwrap(); + let _c = c.finish().unwrap(); assert!( matches!(sub.poll_next_group(&kio::Waiter::noop()), Poll::Ready(Ok(None))), "nested end propagates past covered copies" @@ -4652,7 +4652,7 @@ mod test { let mut sub = subscribe(if nested { &outer } else { &inner }, HOUR); let mut one = a.create_group(group::Info { sequence: 1 }).unwrap(); one.write_frame(ts(1), b"x".as_ref()).unwrap(); - one.finish().unwrap(); + let one = one.finish().unwrap(); write(&a, 3); let reserved = peek(&mut sub, ordered); assert_eq!(reserved.sequence(), 1); @@ -4691,7 +4691,7 @@ mod test { drain(&mut sub, ordered); let mut two = a.create_group(group::Info { sequence: 2 }).unwrap(); two.write_frame(ts(2), b"x".as_ref()).unwrap(); - two.finish().unwrap(); + let two = two.finish().unwrap(); let reserved = peek(&mut sub, ordered); assert_eq!(reserved.sequence(), 2, "{case}"); two.abort(Error::Evicted).unwrap(); @@ -4924,7 +4924,7 @@ mod test { // The new route has only the group already handed out, and ends there. let b = copy(); write(&b, 2); - b.finish().unwrap(); + let b = b.finish().unwrap(); routes.serve(b.consume()); let noop = kio::Waiter::noop(); assert!(sub.poll_recv_group(&noop).is_pending(), "group 1 may still land"); @@ -4961,7 +4961,7 @@ mod test { if first_group { assert_eq!(recv(&mut sub).sequence, 3); } - b.finish().unwrap(); + let _b = b.finish().unwrap(); sub.set_range(..1); let wake = Arc::new(Wake::default()); let waiter = kio::Waiter::new(wake.clone().into()); @@ -5005,7 +5005,7 @@ mod test { let b = copy(); write(&b, 2); - b.finish().unwrap(); + let b = b.finish().unwrap(); routes.serve(b.consume()); let wake = Arc::new(Wake::default()); let waiter = kio::Waiter::new(wake.clone().into()); diff --git a/rs/moq-net/src/model/resume_model.rs b/rs/moq-net/src/model/resume_model.rs index 834f87966b9..c2be6b697f3 100644 --- a/rs/moq-net/src/model/resume_model.rs +++ b/rs/moq-net/src/model/resume_model.rs @@ -568,7 +568,7 @@ impl Model { let Some(copy) = &publisher.routes[slot] else { return; }; - if copy.groups.contains_key(&(GROUPS - 1)) && copy.track.finish().is_ok() { + if copy.groups.contains_key(&(GROUPS - 1)) && copy.track.finish_shared().is_ok() { publisher.ended = true; } } diff --git a/rs/moq-net/src/model/socket.rs b/rs/moq-net/src/model/socket.rs index 2c3aa434e5e..54a944136ee 100644 --- a/rs/moq-net/src/model/socket.rs +++ b/rs/moq-net/src/model/socket.rs @@ -1230,7 +1230,7 @@ impl Pump { match outcome { Ok(()) => { if let Some(track) = &self.track { - let _ = track.finish(); + let _ = track.finish_shared(); } } Err(err) => { @@ -1299,7 +1299,7 @@ impl Pump { // Finished without a group: an empty half. if !self.received && self.subscriber.is_none() - && let Some(mut local) = self.local.take() + && let Some(local) = self.local.take() { let _ = local.finish(); } @@ -1322,8 +1322,7 @@ impl Pump { Poll::Pending => return Ok(()), Poll::Ready(Ok(Some(frame))) => self.pending = Some(frame), Poll::Ready(Ok(None)) => { - local.finish()?; - self.local = None; + self.local.take().expect("checked above").finish()?; self.remote = None; return Ok(()); } diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index a7c68da1337..c7efeda59b0 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -3967,16 +3967,35 @@ impl Producer { Ok(()) } - /// Mark the track as finished after the last appended group. + /// End the track after its highest group, returning the [`Finished`] track: no group at + /// or above that end can be created, but an older group below it still can. /// - /// Ends the track at the head of the group after the current max_sequence. - /// No new groups at or above it can be appended. - /// NOTE: Old groups with lower sequence numbers can still arrive. - pub fn finish(&self) -> Result<()> { + /// Other clones of this producer stay open handles, and refuse a group at or past the end + /// with [`Error::Closed`]. Fails with [`Error::Closed`] if the track already declared an + /// end, or with the abort error. A track whose highest group is `u64::MAX` has no end to + /// declare: it is aborted with [`Error::BoundsExceeded`], which the call also returns. + pub fn finish(self) -> Result { + self.finish_shared()?; + Ok(Finished { producer: self }) + } + + /// [`Self::finish`] through a shared handle, which a session keeps to take the lower + /// groups still in flight. + pub(crate) fn finish_shared(&self) -> Result<()> { let mut state = self.modify()?; let final_sequence = match state.max_sequence { - Some(max) => max.checked_add(1).ok_or(coding::BoundsExceeded)?, None => 0, + Some(max) => match max.checked_add(1) { + Some(end) => end, + None => { + // Left open, readers would wait for an end that never comes and then see + // `Dropped`; abort so they get the cause. + drop(state); + let err = Error::from(coding::BoundsExceeded); + let _ = self.clone().abort(err.clone()); + return Err(err); + } + }, }; state.set_end(Position::group(final_sequence), None) } @@ -4667,6 +4686,74 @@ impl Producer { } } +/// A track whose producer [finished](Producer::finish) it: its end is declared, and it can +/// still take or serve an older group below that end, be read, or be aborted, but not append. +/// +/// Dropping it releases this handle like dropping a [`Producer`]: once no clone is left, the +/// track leaves its broadcast's listing as finished, so a new reader can no longer find it. +/// +/// ```compile_fail,E0599 +/// # fn cannot_append(track: moq_net::track::Finished) { +/// let _ = track.append_group(); +/// # } +/// ``` +#[must_use = "dropping the last handle releases the track, which new readers can then no longer find"] +pub struct Finished { + producer: Producer, +} + +impl Finished { + /// The track's name, unique within its broadcast. + pub fn name(&self) -> &str { + self.producer.name() + } + + /// The parent broadcast this track belongs to. + pub fn broadcast(&self) -> &broadcast::Info { + self.producer.broadcast() + } + + /// The properties this track was created with. + pub fn info(&self) -> &Info { + &self.producer.info + } + + /// Serve on-demand fetches of uncached groups below the end; see [`Producer::requests`]. + pub fn requests(&self) -> Requests { + self.producer.requests() + } + + /// Create an older group below the end, which arrived late; see [`Producer::create_group`]. + /// + /// A sequence at or past the end is refused with [`Error::Closed`]. + pub fn create_group(&self, group: group::Info) -> Result { + self.producer.create_group(group) + } + + /// Abort the track with the given error; see [`Producer::abort`]. + /// + /// Once every group below the end finished, readers still get the clean end. + pub fn abort(self, err: Error) -> Result<()> { + self.producer.abort(err) + } + + /// Resolves once the track's outcome is final; see [`Producer::poll_closed`]. + #[cfg_attr(feature = "async", kio::wrapper)] + pub fn poll_closed(&self, waiter: &kio::Waiter) -> Poll> { + self.producer.poll_closed(waiter) + } + + /// Get a consumer handle for this in-process track. + pub fn consume(&self) -> Consumer { + self.producer.consume() + } + + /// Subscribe to this in-process track; see [`Producer::subscribe`]. + pub fn subscribe(&self, subscription: impl Into>) -> Subscriber { + self.producer.subscribe(subscription) + } +} + /// Serves the groups a track's readers miss, the group-level analogue of /// [`broadcast::Requests`]. /// @@ -10583,8 +10670,8 @@ mod test { group.write_frame(None, &b"c"[..]).unwrap(); assert_eq!(subscriber.largest().await, Some(Position { group: 0, frame: 2 })); - group.finish().unwrap(); - producer.finish().unwrap(); + let group = group.finish().unwrap(); + let producer = producer.finish().unwrap(); drop(group); drop(producer); assert_eq!(subscriber.largest().await, None); @@ -10694,7 +10781,7 @@ mod test { let mut first = producer.append_group().unwrap(); first.write_frame(None, &b"a"[..]).unwrap(); first.finish().unwrap(); - let mut empty = producer.append_group().unwrap(); + let empty = producer.append_group().unwrap(); let mut reader = producer.subscribe(replay()); let Poll::Ready(Some(edge)) = reader.poll_largest(&noop) else { @@ -10741,7 +10828,7 @@ mod test { Poll::Ready(Some(Position { group: 0, frame: 0 })) ); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); assert!( subscriber.poll_largest(&noop).is_pending(), "the open group can still grow" @@ -10812,7 +10899,7 @@ mod test { fn an_idle_read_parks_for_the_task_polling_it() { for ordered in [false, true] { let producer = track_producer("test", Info::default()); - let mut first = framed(&producer, 0, 1); + let first = framed(&producer, 0, 1); first.finish().unwrap(); let mut reader = producer.subscribe(replay()); let mut read = |waiter: &kio::Waiter| match ordered { @@ -10827,7 +10914,7 @@ mod test { let (other, moved) = Flag::waiter(); assert!(read(&moved).is_pending()); - let mut next = framed(&producer, 1, 1); + let next = framed(&producer, 1, 1); next.finish().unwrap(); assert!(other.take(), "the next group wakes the task that polled last"); assert!(matches!(read(&moved), Poll::Ready(Ok(Some(_))))); @@ -10872,11 +10959,7 @@ mod test { fn a_range_reads_only_its_groups() { let producer = track_producer("test", None); let _groups: Vec<_> = (3..8) - .map(|sequence| { - let mut group = framed(&producer, sequence, 8); - group.finish().unwrap(); - group - }) + .map(|sequence| framed(&producer, sequence, 8).finish().unwrap()) .collect(); let _wide = producer.subscribe(replay()); let range = Range { @@ -11008,7 +11091,7 @@ mod test { fn largest_stays_ended_when_the_bounds_widen() { let producer = track_producer("test", Info::default()); framed(&producer, 5, 1).finish().unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let noop = kio::Waiter::noop(); let mut reader = producer.subscribe(replay()); @@ -11092,7 +11175,7 @@ mod test { let mut finished = track_producer("test", Info::default()); framed(&finished, 0, 1).finish().unwrap(); finished.set_idle(); - finished.finish().unwrap(); + let finished = finished.finish().unwrap(); let mut reader = finished.subscribe(replay()); assert_eq!(reader.poll_largest(&noop), Poll::Ready(Some(Position::group(0)))); } @@ -11323,7 +11406,7 @@ mod test { let mut reader = producer.subscribe(replay().with_ranges([Range::live()])); assert_eq!(ready_groups(&mut reader), Vec::::new(), "the copy is idle"); - producer.finish().unwrap(); + let _producer = producer.finish().unwrap(); assert_eq!(ready_groups(&mut reader), vec![3]); } @@ -11614,7 +11697,7 @@ mod test { frame.write(bytes::Bytes::from_static(b"x")).unwrap(); producer.create_group(seq.into()).unwrap().finish().unwrap(); } - let mut straggler = frame.finish().unwrap(); + let straggler = frame.finish().unwrap(); straggler.finish().unwrap(); let state = producer.state.read(); @@ -11647,7 +11730,7 @@ mod test { // and `finish` is the only write the charge sees. elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); frame.write_deferred(bytes::Bytes::from_static(b"abc")).unwrap(); - let mut straggler = frame.finish().unwrap(); + let straggler = frame.finish().unwrap(); straggler.finish().unwrap(); // A new group runs the expiry scan. @@ -12207,7 +12290,7 @@ mod test { append_at(&mut producer, 0); // the successor assert!(!held.poll_expired(&waiter), "the successor is recorded"); let state = producer.state.downgrade(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); drop(producer); // The first sweep dates the groups idle, the second expires them. @@ -12239,9 +12322,11 @@ mod test { append_at(&mut producer, 0); let mut open = Vec::new(); for sequence in 1..=RUN { - let mut group = producer.append_group().unwrap(); + let group = producer.append_group().unwrap(); match sequence % 2 { - 0 => group.finish().unwrap(), + 0 => { + group.finish().unwrap(); + } _ => open.push(group), } } @@ -12522,7 +12607,7 @@ mod test { group .write_frame(Timestamp::from_millis(millis).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - group.finish().unwrap(); + let group = group.finish().unwrap(); group.sequence } @@ -13424,7 +13509,7 @@ mod test { let mut edge = producer.append_group().unwrap(); edge.write_frame(Timestamp::from_millis(2000).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - edge.finish().unwrap(); + let edge = edge.finish().unwrap(); let mut held = subscriber .recv_group() @@ -13537,7 +13622,7 @@ mod test { let mut edge = producer.append_group().unwrap(); edge.write_frame(Timestamp::from_millis(2000).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - edge.finish().unwrap(); + let edge = edge.finish().unwrap(); let mut held = subscriber .recv_group() @@ -13679,7 +13764,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), None).unwrap(); - let mut group = producer.create_group(group::Info { sequence: 0 }).unwrap(); + let group = producer.create_group(group::Info { sequence: 0 }).unwrap(); let mut reading = subscriber.assert_group(); assert_eq!(reading.sequence, 0); @@ -13688,7 +13773,9 @@ mod test { assert!(futures::poll!(next.as_mut()).is_pending(), "the group is still open"); match abort { true => group.abort(Error::Cancel).unwrap(), - false => group.finish().unwrap(), + false => { + group.finish().unwrap(); + } } kio::clock::timeout(Duration::from_secs(1), next) .await @@ -14124,7 +14211,7 @@ mod test { fn append_untimed(producer: &mut Producer) -> u64 { let mut group = producer.append_group().unwrap(); group.write_frame(None, bytes::Bytes::from_static(b"x")).unwrap(); - group.finish().unwrap(); + let group = group.finish().unwrap(); group.sequence } @@ -15338,7 +15425,7 @@ mod test { let producer = track_producer("test", Info::timed()); let keep = producer.clone(); let writer = producer.clone(); - let mut group = writer.append_group().unwrap(); + let group = writer.append_group().unwrap(); group.finish().unwrap(); let _consumer = producer.subscribe(None); writer.abort(Error::Cancel).unwrap(); @@ -15365,7 +15452,7 @@ mod test { fn drop_finished_keeps_cached_groups() { let producer = track_producer("test", Info::timed()); producer.append_group().unwrap().finish().unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.subscribe(None); drop(producer); @@ -15445,7 +15532,7 @@ mod test { for sequence in [0, 1, 2, 4, 5] { write_group(&producer, sequence); } - producer.finish().unwrap(); + let _producer = producer.finish().unwrap(); for sequence in 0..3 { let Poll::Ready(Ok(Some(group))) = ordered.poll_next_group(&kio::Waiter::noop()) else { panic!("group {sequence}, given_up={given_up}") @@ -15471,9 +15558,10 @@ mod test { fn append_finish_cannot_be_rewritten() { let producer = track_producer("test", Info::timed()); - // Finishing an empty track is valid (fin = 0, total groups = 0). - assert!(producer.finish().is_ok()); - assert!(producer.finish().is_err()); + // Finishing an empty track is valid (fin = 0, total groups = 0). Another clone can + // neither finish again nor append. + assert!(producer.clone().finish().is_ok()); + assert!(producer.clone().finish().is_err()); assert!(producer.append_group().is_err()); } @@ -15482,11 +15570,67 @@ mod test { let producer = track_producer("test", Info::timed()); let _open = producer.append_group().unwrap(); - assert!(producer.finish().is_ok()); - assert!(producer.finish().is_err()); + assert!(producer.clone().finish().is_ok()); + assert!(producer.clone().finish().is_err()); assert!(producer.append_group().is_err()); } + /// The handle `finish` returns still fills an older group below the end, refuses one at or + /// past it, and ends its readers cleanly once the late group finishes. + #[test] + #[cfg(feature = "async")] + fn finished_track_fills_a_late_group_below_its_end() { + let producer = track_producer("test", Info::timed()); + let mut ordered = producer.subscribe(replay()).ordered(); + producer + .create_group(group::Info { sequence: 1 }) + .unwrap() + .finish() + .unwrap(); + let finished = producer.finish().unwrap(); + assert!(matches!( + finished.create_group(group::Info { sequence: 2 }), + Err(Error::Closed) + )); + + let mut late = finished.create_group(group::Info { sequence: 0 }).unwrap(); + late.write_frame(Timestamp::ZERO, &b"late"[..]).unwrap(); + let late = late.finish().unwrap(); + assert_eq!(late.frame_count(), 1); + let first = ordered.next_group().now_or_never().expect("group 0").unwrap().unwrap(); + assert_eq!(first.sequence, 0); + let second = ordered.next_group().now_or_never().expect("group 1").unwrap().unwrap(); + assert_eq!(second.sequence, 1); + let done = ordered.next_group().now_or_never().expect("end").unwrap(); + assert!(done.is_none(), "the finished track ends after its late group"); + assert!(finished.closed().now_or_never().expect("settled").is_ok()); + } + + /// No end follows group `u64::MAX`, so finishing aborts the track with that cause: the + /// consumed handle leaves the caller nothing to abort it with. + #[test] + #[cfg(feature = "async")] + fn finish_past_the_last_sequence_aborts_with_the_cause() { + let producer = track_producer("test", Info::timed()); + let mut subscriber = producer.subscribe(replay()); + let mut group = producer.create_group(group::Info { sequence: u64::MAX }).unwrap(); + group.write_frame(Timestamp::ZERO, &b"x"[..]).unwrap(); + let mut reader = group.consume(); + assert!(matches!(producer.finish(), Err(Error::BoundsExceeded(_)))); + // The subscriber may hand out the open group before the error. + let ended = loop { + match subscriber.recv_group().now_or_never().expect("settled") { + Ok(Some(_)) => continue, + ended => break ended.map(|group| group.map(|group| group.sequence)), + } + }; + assert!(matches!(ended, Err(Error::BoundsExceeded(_))), "{ended:?}"); + // The open group is cut with the same cause. + let cut = reader.read_frame().now_or_never().expect("settled"); + assert!(matches!(cut, Err(Error::BoundsExceeded(_))), "{cut:?}"); + assert!(matches!(group.finish(), Err(Error::BoundsExceeded(_)))); + } + #[test] fn finish_at_rejects_a_boundary_at_or_below_the_live_edge() { let mut producer = track_producer("test", Info::timed()); @@ -15622,7 +15766,7 @@ mod test { fn end_reports_the_live_edge_after_finish() { let producer = track_producer("test", Info::timed()); let _open = producer.create_group(group::Info { sequence: 5 }).unwrap(); - producer.finish().unwrap(); + producer.finish_shared().unwrap(); assert_eq!(producer.finished(), Some(Position::group(6))); } @@ -16048,7 +16192,7 @@ mod test { let mut arrival = producer.subscribe(None); producer.start_at(0).unwrap(); producer.finish_at(Position::group(2), None).unwrap(); - let mut high = producer.create_group(group::Info { sequence: 1 }).unwrap(); + let high = producer.create_group(group::Info { sequence: 1 }).unwrap(); high.finish().unwrap(); assert_eq!(arrival.assert_group().sequence, 1); assert!(arrival.recv_group().now_or_never().is_none(), "held at the hole"); @@ -16181,7 +16325,7 @@ mod test { let mut producer = track_producer("test", Info::timed()); let mut consumer = producer.subscribe(replay()); - let mut head = producer.create_group(group::Info { sequence: 0 }).unwrap(); + let head = producer.create_group(group::Info { sequence: 0 }).unwrap(); head.finish().unwrap(); let _tail = producer.create_group(group::Info { sequence: 1 }).unwrap(); producer.finish_at(Position::group(2), None).unwrap(); @@ -16250,7 +16394,7 @@ mod test { use std::sync::atomic::{AtomicBool, Ordering}; let mut producer = track_producer("test", Info::timed()); - let mut open = producer.append_group().unwrap(); + let open = producer.append_group().unwrap(); producer.finish_at(Position::group(1), None).unwrap(); let woken = Arc::new(AtomicBool::new(false)); let waiter = kio::Waiter::new(futures::task::waker(Arc::new(FlagWake(woken.clone())))); @@ -16404,7 +16548,7 @@ mod test { let finished = track_producer_pooled("finished", pool.clone()); finished.append_group().unwrap().finish().unwrap(); - finished.finish().unwrap(); + let finished = finished.finish().unwrap(); let stale_finished = finished.consume(); drop(finished); @@ -16435,7 +16579,7 @@ mod test { let mut group = producer.append_group().unwrap(); group.write_frame(Timestamp::ZERO, &b"a"[..]).unwrap(); group.abort(Error::Stream(StreamError::App(5))).unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let stale = producer.consume(); drop(producer); @@ -16465,7 +16609,7 @@ mod test { let mut consumer = producer.subscribe(replay()); for sequence in 0..2 { - let mut group = producer.create_group(group::Info { sequence }).unwrap(); + let group = producer.create_group(group::Info { sequence }).unwrap(); group.finish().unwrap(); } producer.finish_at(Position::group(2), None).unwrap(); @@ -16486,7 +16630,7 @@ mod test { let mut consumer = producer.subscribe(replay()).ordered(); for sequence in 0..2 { - let mut group = producer.create_group(group::Info { sequence }).unwrap(); + let group = producer.create_group(group::Info { sequence }).unwrap(); group.finish().unwrap(); } producer.finish_at(Position::group(2), None).unwrap(); @@ -16565,7 +16709,7 @@ mod test { .unwrap() .finish() .unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.subscribe(None); assert_eq!(consumer.assert_group().sequence, 1); @@ -17349,7 +17493,7 @@ mod test { consumer.set_range(..3); let _open = producer.create_group(group::Info { sequence: 3 }).unwrap(); assert!(consumer.recv_group().now_or_never().is_none(), "capped at 3"); - producer.finish().unwrap(); + let _producer = producer.finish().unwrap(); assert!( matches!(consumer.recv_group().now_or_never(), Some(Ok(None))), "a finished track ends a capped reader" @@ -17498,7 +17642,7 @@ mod test { // The cache evicts the parked group (abort-as-tombstone), then the track ends. straggler.abort(Error::Old).unwrap(); - producer.finish().unwrap(); + let _producer = producer.finish().unwrap(); consumer.set_range(..); assert!( @@ -18780,7 +18924,7 @@ mod test { /// A live group with a fetched head: group 0, fed from frame 1, plus a two-frame head. #[cfg(feature = "async")] - async fn live_group_with_head(producer: &Producer) -> (group::Producer, group::Producer) { + async fn live_group_with_head(producer: &Producer) -> (group::Producer, group::Finished) { let dynamic = producer.requests(); let consumer = producer.consume(); @@ -18796,7 +18940,7 @@ mod test { head.write_frame(Timestamp::ZERO, bytes::Bytes::from_static(payload)) .unwrap(); } - head.finish().unwrap(); + let head = head.finish().unwrap(); assert_eq!(fetch.await.unwrap().index(), 0); (live, head) } @@ -18828,7 +18972,9 @@ mod test { match live { Some(err) => group.abort(err).unwrap(), - None => group.finish().unwrap(), + None => { + group.finish().unwrap(); + } } producer.finish_at(Position::group(1), None).unwrap(); (producer, head) @@ -18844,7 +18990,7 @@ mod test { for live in [Some(Error::Cancel), Some(Error::Evicted), None] { for polled in [false, true] { - let (producer, mut head) = live_group_under_a_writing_head(live.clone()).await; + let (producer, head) = live_group_under_a_writing_head(live.clone()).await; let woken = Arc::new(AtomicBool::new(false)); let waiter = kio::Waiter::new(futures::task::waker(Arc::new(FlagWake(woken.clone())))); if polled { @@ -18956,7 +19102,7 @@ mod test { } live.abort(Error::Cancel).unwrap(); - producer.finish().unwrap(); + let _producer = producer.finish().unwrap(); assert!(reader.poll_largest(&noop).is_pending(), "the head still writes"); head.write_frame(Timestamp::ZERO, bytes::Bytes::from_static(b"more")) @@ -19027,7 +19173,7 @@ mod test { #[cfg(feature = "async")] async fn reading_the_head_keeps_the_slot_from_expiring() { let producer = track_producer("test", Info::timed()); - let (mut live, _head) = live_group_with_head(&producer).await; + let (live, _head) = live_group_with_head(&producer).await; live.finish().unwrap(); let _open = producer.create_group(group::Info { sequence: 1 }).unwrap(); @@ -19052,7 +19198,7 @@ mod test { live.start_at(1).unwrap(); live.write_frame(Timestamp::ZERO, bytes::Bytes::from_static(b"delta")) .unwrap(); - live.finish().unwrap(); + let live = live.finish().unwrap(); let fetch = consumer.fetch_group(0, None); let mut head = dynamic .requested_fill_group() @@ -19297,7 +19443,7 @@ mod test { async fn fetch_past_final_not_found() { let producer = track_producer("test", Info::timed()); let _open = producer.append_group().unwrap(); // seq 0 - producer.finish().unwrap(); // final_sequence = 1 + producer.finish_shared().unwrap(); // final_sequence = 1 // A group at or past the final sequence can never exist, even with a handler, // so it resolves to NotFound. @@ -19328,7 +19474,7 @@ mod test { group .write_frame(Timestamp::ZERO, bytes::Bytes::from(vec![0u8; size])) .unwrap(); - group.finish().unwrap(); + let group = group.finish().unwrap(); group.sequence } @@ -19724,9 +19870,8 @@ mod test { fn finished_track_frees_its_cache() { let (mut producer, pool) = pooled_producer(1 << 40); finished_group(&mut producer, 100); - producer.finish().unwrap(); - let state = producer.state.downgrade(); + let producer = producer.finish().unwrap(); drop(producer); assert!(state.upgrade().is_none(), "the track state is freed"); @@ -19761,9 +19906,8 @@ mod test { let (mut producer, pool) = pooled_producer(1 << 40); let sequence = finished_group(&mut producer, 100); let group = producer.consume().peek_group(sequence).expect("cached"); - producer.finish().unwrap(); - let state = producer.state.downgrade(); + let producer = producer.finish().unwrap(); drop(producer); assert!(state.upgrade().is_none(), "the track state is freed"); assert!(pool.used() > 0, "the retained group keeps its own bytes"); @@ -19925,7 +20069,7 @@ mod test { fn empty_groups_repay_overhead() { let (producer, pool) = pooled_producer(1_000); for _ in 0..100 { - let mut group = producer.append_group().unwrap(); + let group = producer.append_group().unwrap(); group.finish().unwrap(); } @@ -20604,7 +20748,7 @@ mod test { let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { panic!("the fill is ready"); }; - let mut group = fill.accept(3, Info::timed()).unwrap(); + let group = fill.accept(3, Info::timed()).unwrap(); assert!(matches!(fill.accept(3, None), Err(Error::Duplicate))); assert!(matches!(fill.accept(4, None), Err(Error::InvalidRange))); assert!( @@ -21148,7 +21292,7 @@ mod test { write_filled(fill.accept(8, None), 8); assert_eq!(fill.wanted(), Some(9)); // Over, so what the fill refuses is a drop rather than a group still to come. - producer.finish().unwrap(); + producer.finish_shared().unwrap(); fill.drop_groups(0..9); drop(fill); @@ -22081,7 +22225,7 @@ mod test { drained_drops(&mut subscriber).is_empty(), "the feed may still deliver them" ); - producer.finish().unwrap(); + let _producer = producer.finish().unwrap(); assert_eq!(drained_drops(&mut subscriber), [(0, 2)]); assert!(matches!(subscriber.poll_recv_group(&waiter), Poll::Ready(Ok(None)))); } @@ -22536,11 +22680,13 @@ mod test { } // Group 2 sits above the first gap, and its successor never presents a frame. match sequence { - 3 => producer - .create_group(group::Info { sequence }) - .unwrap() - .finish() - .unwrap(), + 3 => { + producer + .create_group(group::Info { sequence }) + .unwrap() + .finish() + .unwrap(); + } _ => write_group(&producer, sequence), } assert_eq!(drain_groups(&mut subscriber), [sequence]); @@ -23915,7 +24061,7 @@ mod test { .unwrap() .finish() .unwrap(); - producer.finish().unwrap(); + let _producer = producer.finish().unwrap(); let mut first = arrival.assert_group(); assert_eq!(first.sequence, 0); @@ -24332,7 +24478,7 @@ mod test { // Ranges it can serve lift the refusal. refused.update(replay()).unwrap(); - let mut group = producer.append_group().unwrap(); + let group = producer.append_group().unwrap(); group.finish().unwrap(); let read = refused.recv_group().now_or_never().expect("the group is cached"); assert_eq!(read.unwrap().map(|group| group.sequence), Some(0)); @@ -24566,7 +24712,7 @@ mod test { for frame in start..end { tail.write_frame(Timestamp::ZERO, vec![frame as u8; size]).unwrap(); } - tail.finish().unwrap(); + let tail = tail.finish().unwrap(); deliveries.push(tail.handle()); held.push(pending.await.unwrap()); } @@ -24643,7 +24789,7 @@ mod test { ) .unwrap(); tail.write_frame(Timestamp::ZERO, vec![start as u8; 4]).unwrap(); - tail.finish().unwrap(); + let tail = tail.finish().unwrap(); held.push(tail.consume().with_range(start..)); tails.push(tail); } @@ -24669,7 +24815,7 @@ mod test { .unwrap(); assert!(Arc::ptr_eq(&owner, &refill.handle().content().unwrap())); refill.write_frame(Timestamp::ZERO, b"zero".as_slice()).unwrap(); - refill.finish().unwrap(); + let refill = refill.finish().unwrap(); refill.abort(Error::Cancel).unwrap(); let mut recreated = producer.create_group(group::Info { sequence: 0 }).unwrap(); recreated.start_at(8).unwrap(); @@ -24743,7 +24889,7 @@ mod test { first.abort(Error::Cancel).unwrap(); assert!(budget.reserve(1).is_none(), "the survivor still holds admission"); second.write(vec![4; 768]).unwrap(); - let mut second = second.finish().unwrap(); + let second = second.finish().unwrap(); second.finish().unwrap(); assert!(matches!(streaming.read_chunk().await, Err(Error::Cancel))); let frame = second_read.read_frame().await.unwrap().unwrap(); @@ -24755,7 +24901,7 @@ mod test { ); } else { second.write(vec![4; 768]).unwrap(); - let mut second = second.finish().unwrap(); + let second = second.finish().unwrap(); second.finish().unwrap(); let later_copy = second_read.read_frame().await.unwrap().unwrap(); assert!( @@ -24766,8 +24912,8 @@ mod test { assert!(streaming.read_chunk().now_or_never().is_none()); kio::clock::sim::advance(Duration::from_millis(10)).await; first.write(vec![4; 512]).unwrap(); - let mut first = first.finish().unwrap(); - first.finish().unwrap(); + let first = first.finish().unwrap(); + let first = first.finish().unwrap(); let original_copy = first.consume().with_range(4..).read_frame().await.unwrap().unwrap(); assert_eq!( original_copy.arrived().duration_since(later_copy.arrived()), @@ -24833,13 +24979,13 @@ mod test { .unwrap(); head.set_wire(wire(90)).unwrap(); let head = write(head, 90, b"b"); - let mut head = write(head, 100, b"a"); + let head = write(head, 100, b"a"); head.set_end_object(super::super::object::Fields { id: 101, properties: Default::default(), }) .unwrap(); - head.finish().unwrap(); + let head = head.finish().unwrap(); let earlier = producer .state .write() @@ -24849,8 +24995,8 @@ mod test { .unwrap(); earlier.set_wire(wire(90)).unwrap(); let earlier = write(earlier, 90, b"b"); - let mut earlier = write(earlier, 95, b"c"); - earlier.finish().unwrap(); + let earlier = write(earlier, 95, b"c"); + let earlier = earlier.finish().unwrap(); assert!(head.consume().end_object().is_some_and(|fields| fields.id == 101)); assert!( earlier.consume().end_object().is_none(), @@ -24935,7 +25081,7 @@ mod test { for payload in &expected { source.write_frame(Timestamp::ZERO, payload.clone()).unwrap(); } - source.finish().unwrap(); + let source = source.finish().unwrap(); let mut stored = arrayvec::ArrayVec::::new(); assert!(matches!( source @@ -24978,7 +25124,7 @@ mod test { assert_eq!(first.read_frame().await.unwrap().unwrap().payload, expected[0]); kio::clock::sim::advance(Duration::from_millis(20)).await; head = ingest(head, &stored[8]); - head.finish().unwrap(); + let head = head.finish().unwrap(); pending.await.unwrap(); let mut raw_head = head.consume().with_range(8..).compressed(); let raw_head = raw_head.read_frame().await.unwrap().unwrap(); @@ -25097,8 +25243,8 @@ mod test { }) .unwrap(); refill.write(vec![4; 1024]).unwrap(); - let mut refill = refill.finish().unwrap(); - refill.finish().unwrap(); + let refill = refill.finish().unwrap(); + let refill = refill.finish().unwrap(); let complete = refill.consume().with_range(4..).read_frame().await.unwrap().unwrap(); assert_eq!( complete.payload.as_ptr() as usize, @@ -25127,7 +25273,7 @@ mod test { .insert_group_request(0, group::Bounds { start: 0, end: Some(1) }, None) .unwrap(); head.write_frame(Timestamp::ZERO, bytes::Bytes::new()).unwrap(); - head.finish().unwrap(); + let head = head.finish().unwrap(); assert_eq!(live.handle().content().unwrap().cost().0, FRAMES + 1); assert_eq!(live.frame_count(), 2 * FRAMES); assert_eq!(head.frame_count(), 1); @@ -25709,7 +25855,7 @@ mod test { let dynamic = producer.requests(); producer.create_group(0u64.into()).unwrap().finish().unwrap(); producer.create_group(2u64.into()).unwrap().finish().unwrap(); - producer.finish().unwrap(); + let producer = producer.finish().unwrap(); let mut reader = producer.subscribe(replay().with_order(Order::Ascending).with_range(1..2)); assert_eq!(read_now(&mut reader, false), None, "the fill is out"); let fill = dynamic diff --git a/rs/moq-net/src/model/track/miss.rs b/rs/moq-net/src/model/track/miss.rs index 5039d1e49e1..7ea1df30178 100644 --- a/rs/moq-net/src/model/track/miss.rs +++ b/rs/moq-net/src/model/track/miss.rs @@ -2419,7 +2419,7 @@ mod tests { .unwrap() .finish() .unwrap(); - track.finish().unwrap(); + let track = track.finish().unwrap(); // Group 0 lies below where the feed starts: only a fill may deliver it. let ranges = [crate::track::Range::groups(0..1), crate::track::Range::groups(8..)]; let mut reader = track.subscribe( diff --git a/rs/moq-net/src/recv.rs b/rs/moq-net/src/recv.rs index 8a130f6e217..aae98fc80cf 100644 --- a/rs/moq-net/src/recv.rs +++ b/rs/moq-net/src/recv.rs @@ -65,8 +65,7 @@ impl Group { /// Finish receiving without running cancellation cleanup. pub fn finish(mut self) -> Result<(), Error> { - self.deref_mut().finish()?; - self.writer.take(); + self.writer.take().expect("group owned until consumed").finish()?; self.armed = false; Ok(()) } diff --git a/rs/moq-net/tests/integration/announce_to_serve.rs b/rs/moq-net/tests/integration/announce_to_serve.rs index bfe2a367c1c..31ed995698b 100644 --- a/rs/moq-net/tests/integration/announce_to_serve.rs +++ b/rs/moq-net/tests/integration/announce_to_serve.rs @@ -181,7 +181,7 @@ async fn lifecycle(observer: Observer) -> Vec { first.is_closed(), )); write_group(&track, "after"); - track.finish().unwrap(); + let _track = track.finish().unwrap(); log.push(format!( "draining: {} then {}", next(&mut reader).await, diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index c34ebf281ba..7b3dfe81fe6 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -287,7 +287,7 @@ async fn ietf_fetch_keeps_the_stored_form() { .unwrap(); } group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); broadcast.announce().unwrap(); let origin = produce_origin(2); let mut options = MockConnectOptions::new(version.parse().unwrap()); diff --git a/rs/moq-net/tests/integration/datagram.rs b/rs/moq-net/tests/integration/datagram.rs index 5c257ce5ca3..6294a3f05b2 100644 --- a/rs/moq-net/tests/integration/datagram.rs +++ b/rs/moq-net/tests/integration/datagram.rs @@ -731,7 +731,7 @@ async fn a_stream_tracks_datagram_sent_between_its_answer_and_end_arrives() { let mut producer = datagrams.accept(timed()); producer.append(millis(1), &b"only"[..]).unwrap(); producer.finish(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let mut subscriber = (&mut subscribing) .await .expect("subscribe panicked") diff --git a/rs/moq-net/tests/integration/fetch_cancel.rs b/rs/moq-net/tests/integration/fetch_cancel.rs index adc81bcd4f7..3e0534283fe 100644 --- a/rs/moq-net/tests/integration/fetch_cancel.rs +++ b/rs/moq-net/tests/integration/fetch_cancel.rs @@ -125,7 +125,7 @@ async fn abandoned_fetch_reaches_the_publisher(version: &str, relays: u64, stage // group is whole, so it must be cached as such rather than cancelled. const LATENCY: Duration = Duration::from_millis(100); _pairs.last().unwrap().client_transport.set_latency(LATENCY); - group.finish().unwrap(); + let group = group.finish().unwrap(); kio::clock::sleep(LATENCY).await; drop(fetched); kio::clock::sleep(Duration::from_secs(1)).await; @@ -195,7 +195,7 @@ async fn a_refetch_within_the_linger_stays_on_the_relay(version: &str) { group .write_frame(Timestamp::ZERO, Bytes::from_static(b"segment")) .unwrap(); - group.finish().unwrap(); + let group = group.finish().unwrap(); let mut fetched = waiting.await.unwrap(); assert_eq!(&fetched.read_frame().await.unwrap().unwrap().payload[..], b"segment"); drop(fetched); diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index fa14fc57cf9..a78a0c46d7f 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -55,7 +55,7 @@ fn publish_finished(origin: &moq_net::origin::Producer) -> (moq_net::origin::Rou } group.finish().unwrap(); } - track.finish().unwrap(); + let _finished = track.clone().finish().unwrap(); let subscribed = Arc::new(AtomicBool::new(false)); let flag = subscribed.clone(); diff --git a/rs/moq-net/tests/integration/finished_broadcast_mock.rs b/rs/moq-net/tests/integration/finished_broadcast_mock.rs index 975b956de5b..f8b24c903d0 100644 --- a/rs/moq-net/tests/integration/finished_broadcast_mock.rs +++ b/rs/moq-net/tests/integration/finished_broadcast_mock.rs @@ -93,7 +93,7 @@ async fn round(finish_broadcast: bool) -> (Vec>, Option) let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, PAYLOAD).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let track = track.finish().unwrap(); drop(track); if finish_broadcast { broadcast.broadcast().close(); diff --git a/rs/moq-net/tests/integration/late_lower_group.rs b/rs/moq-net/tests/integration/late_lower_group.rs index d7b51aac9bc..fce88922796 100644 --- a/rs/moq-net/tests/integration/late_lower_group.rs +++ b/rs/moq-net/tests/integration/late_lower_group.rs @@ -147,7 +147,7 @@ async fn session(version: &str, relay: bool, start: Option) -> Vec<(u64, us write_group(&track, 1); kio::clock::sleep(Duration::from_millis(10)).await; write_group(&track, 0); - track.finish().unwrap(); + let track = track.finish().unwrap(); let got = kio::clock::timeout(TIMEOUT * 3, reader) .await @@ -180,7 +180,7 @@ async fn in_process(start: Option) -> Vec<(u64, usize)> { write_group(&track, 1); kio::clock::sleep(Duration::from_millis(10)).await; write_group(&track, 0); - track.finish().unwrap(); + let track = track.finish().unwrap(); let got = kio::clock::timeout(TIMEOUT * 3, reader) .await .expect("reader hung") @@ -280,7 +280,7 @@ async fn merged(version: &str) -> (Vec<(u64, usize)>, Vec<(u64, usize)>) { // Idle time lets the merged demand reach the publisher before the lower group exists. kio::clock::sleep(Duration::from_millis(10)).await; write_group(&track, 0); - track.finish().unwrap(); + let track = track.finish().unwrap(); let mut live_read = vec![(1, 4)]; live_read.extend(read_all(&mut live).await); diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index f5418981587..13892eead29 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -97,7 +97,7 @@ async fn read(version: Option<&str>, range: Range) -> Result, Error> { None => break, } } - track.finish().unwrap(); + let _track = track.finish().unwrap(); Ok(read) } @@ -221,5 +221,5 @@ async fn a_relative_start_reports_the_publishers_start_over_a_frameless_newest_g .expect("group timeout") .unwrap(); assert_eq!(group.map(|group| group.sequence), Some(5)); - track.finish().unwrap(); + let _track = track.finish().unwrap(); } diff --git a/rs/moq-net/tests/integration/range_fill.rs b/rs/moq-net/tests/integration/range_fill.rs index 60c84436009..63a405f74f7 100644 --- a/rs/moq-net/tests/integration/range_fill.rs +++ b/rs/moq-net/tests/integration/range_fill.rs @@ -179,7 +179,7 @@ async fn a_recovery_outlives_the_track_finishing() { // Superseded, the copy expires them, while the reader keeps the subscription live. kio::clock::sleep(cache::DEFAULT_EXPIRY * 2 + Duration::from_secs(2)).await; let mut second = fixture.subscribe([Range::groups(1..4)]).await; - fixture.track.finish().unwrap(); + let _track = fixture.track.finish().unwrap(); assert_eq!(receive(&mut second, 3).await, (1..4).collect()); }) .await diff --git a/rs/moq-net/tests/integration/range_read.rs b/rs/moq-net/tests/integration/range_read.rs index 85aff5ffdd7..345487a135f 100644 --- a/rs/moq-net/tests/integration/range_read.rs +++ b/rs/moq-net/tests/integration/range_read.rs @@ -115,9 +115,7 @@ fn one_range(groups: std::ops::Range) -> Subscription { async fn history(version: Version, relay: bool, finished: bool) { let (remote, track, _held) = fixture(version, relay).await; - if finished { - track.finish().unwrap(); - } + let _finished = finished.then(|| track.clone().finish().unwrap()); let mut sub = remote.track("video").unwrap().subscribe(one_range(1..2)).await.unwrap(); assert_eq!(read(&mut sub).await, [1], "{version} relay={relay} finished={finished}"); } diff --git a/rs/moq-net/tests/integration/received_rewind.rs b/rs/moq-net/tests/integration/received_rewind.rs index 8c7d79c9bd2..56ab1bd0d55 100644 --- a/rs/moq-net/tests/integration/received_rewind.rs +++ b/rs/moq-net/tests/integration/received_rewind.rs @@ -118,7 +118,7 @@ async fn relay( // Sent later, so group 0's send time lands after group 1's. kio::clock::sleep(Duration::from_millis(10)).await; write_group(&track, 0); - track.finish().unwrap(); + let track = track.finish().unwrap(); let got = kio::clock::timeout(TIMEOUT * 3, reader) .await @@ -190,7 +190,7 @@ async fn fetch_only(version: &str) -> Vec, moq broadcast.announce().unwrap(); write_group(&track, 0); write_group(&track, 1); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version.parse::().unwrap()); diff --git a/rs/moq-net/tests/integration/relay_upstream_close.rs b/rs/moq-net/tests/integration/relay_upstream_close.rs index 80c536ba01c..1bf96c1d8c0 100644 --- a/rs/moq-net/tests/integration/relay_upstream_close.rs +++ b/rs/moq-net/tests/integration/relay_upstream_close.rs @@ -155,7 +155,7 @@ async fn round(name: &str, end: End) -> Vec { } group.finish().unwrap(); } - track.finish().unwrap(); + let _finished = track.clone().finish().unwrap(); } match end { diff --git a/rs/moq-net/tests/integration/route_change.rs b/rs/moq-net/tests/integration/route_change.rs index d882c5f0841..168a9dbc04c 100644 --- a/rs/moq-net/tests/integration/route_change.rs +++ b/rs/moq-net/tests/integration/route_change.rs @@ -738,7 +738,7 @@ async fn lagging_route_dies(version: Version) { for frame in 0..FRAMES { write(&mut group, 2, frame); } - group.finish().unwrap(); + let group = group.finish().unwrap(); a_r.server.abort(Error::Cancel); a_r.client.abort(Error::Cancel); diff --git a/rs/moq-net/tests/integration/session_close.rs b/rs/moq-net/tests/integration/session_close.rs index 8991869dab5..617e527e1d2 100644 --- a/rs/moq-net/tests/integration/session_close.rs +++ b/rs/moq-net/tests/integration/session_close.rs @@ -155,7 +155,7 @@ async fn close_delivers_a_finished_track_for(version: &str) { let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"last".as_slice()).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let started = kio::clock::now(); kio::clock::timeout(TIMEOUT, pair.client.close()) @@ -299,7 +299,7 @@ async fn close_tail_for(version: &str) { let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"last".as_slice()).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let close = kio::clock::sim::spawn(pair.client.close()); kio::clock::sleep(Duration::from_millis(100)).await; assert!( @@ -337,7 +337,7 @@ async fn close_requires_subscriber_fin_for(version: &str) { let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"last".as_slice()).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let started = kio::clock::now(); let res = pair.client.close().await; assert!(matches!(res, Err(Error::Timeout)), "{version}: {res:?}"); @@ -370,7 +370,7 @@ async fn peer_close_reads_buffered_tail(version: &str) { let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"last".as_slice()).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); pair.client.close().await.expect("released draft still drains on ACKs"); let (got, _) = reader.await.unwrap(); assert_eq!(got, vec![b"last".to_vec()], "{version}"); @@ -396,7 +396,7 @@ async fn peer_close_before_receiver_poll_keeps_buffered_tail() { let mut group = track.append_group().unwrap(); group.write_frame(Timestamp::ZERO, b"last".as_slice()).unwrap(); group.finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); let res = pair.client.close().await; // From lite-05 the close waits for the subscriber's FIN, which the gate holds back. match version { diff --git a/rs/moq-net/tests/integration/slow_joiner.rs b/rs/moq-net/tests/integration/slow_joiner.rs index b9c844f068a..4c28c27812d 100644 --- a/rs/moq-net/tests/integration/slow_joiner.rs +++ b/rs/moq-net/tests/integration/slow_joiner.rs @@ -76,7 +76,7 @@ async fn stalled_read(version: Version, budget: Duration) -> BTreeSet { group.finish().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; } - source.finish().unwrap(); + let _source = source.finish().unwrap(); *gate.write().ok().unwrap() = true; // Read until the track ends, so a skipped group can't be one that merely arrived late. diff --git a/rs/moq-net/tests/integration/socket.rs b/rs/moq-net/tests/integration/socket.rs index f4de1ac8219..99e1486ca37 100644 --- a/rs/moq-net/tests/integration/socket.rs +++ b/rs/moq-net/tests/integration/socket.rs @@ -405,7 +405,7 @@ async fn a_peer_reset_after_fin_resets_the_session() { if reset { half.abort(Error::Cancel).unwrap(); } else { - half.finish().unwrap(); + let _half = half.finish().unwrap(); } kio::clock::sleep(SETTLE).await; let late = accepted.producer.write_frame(None, &b"late"[..]); @@ -441,7 +441,7 @@ async fn track_sessions_carry_messages_both_ways() { assert_eq!(recv(&mut replies).await.unwrap().unwrap(), b"pong"); // Finishing a half closes the pipe that way. - dialed.producer.finish().unwrap(); + let _finished = dialed.producer.finish().unwrap(); assert_eq!(recv(&mut reader).await.unwrap(), None); } } @@ -583,7 +583,7 @@ async fn a_dial_waits_for_its_peer() { let (dialed, accepted) = kio::clock::timeout(TIMEOUT, async { futures::join!(dial, accept) }) .await .expect("connect timeout"); - let (mut dialed, accepted) = (dialed.unwrap(), accepted.unwrap()); + let (dialed, accepted) = (dialed.unwrap(), accepted.unwrap()); assert_eq!(dialed.session(), accepted.session()); dialed.producer.finish().unwrap(); } @@ -894,7 +894,7 @@ async fn an_endpoint_announces_only_its_roles() { let (dialed, accepted) = kio::clock::timeout(TIMEOUT, async { futures::join!(dial, accept) }) .await .expect("connect timeout"); - let (mut dialed, accepted) = (dialed.unwrap(), accepted.unwrap()); + let (dialed, accepted) = (dialed.unwrap(), accepted.unwrap()); assert_eq!(dialed.session(), accepted.session()); dialed.producer.finish().unwrap(); let found = kio::clock::timeout(TIMEOUT, eve.consume().request("room/.server/bob", None)).await; @@ -917,12 +917,12 @@ async fn the_first_burst_survives_a_late_subscribe_answer() { for payload in [b"one", b"two", b"six"] { send(&stream.producer, payload); } - stream.producer.finish().unwrap(); + let _finished = stream.producer.clone().finish().unwrap(); stream }; let (dialed, accepted) = futures::join!(dial, accept); let dialed = dialed.unwrap(); - dialed.producer.finish().unwrap(); + let _finished = dialed.producer.clone().finish().unwrap(); let mut reader = dialed.consumer.ordered(); for payload in [b"one", b"two", b"six"] { assert_eq!(recv(&mut reader).await.unwrap().unwrap(), payload); @@ -944,18 +944,17 @@ async fn the_first_tcp_writes_survive_a_late_subscribe_answer() { for payload in [b"first".as_slice(), b"", b"last"] { stream.producer.write_frame(None, payload).unwrap(); } - stream.producer.finish().unwrap(); - stream + (stream.producer.finish().unwrap(), stream.consumer) }; let (dialed, accepted) = futures::join!(dial, accept); let mut dialed = dialed.unwrap(); - let mut accepted = accepted; + let (_finished, mut accepted) = accepted; for payload in [b"first".as_slice(), b"", b"last"] { assert_eq!(read(&mut dialed.consumer).await.unwrap().unwrap(), payload, "{version}"); } assert_eq!(read(&mut dialed.consumer).await.unwrap(), None); dialed.producer.finish().unwrap(); - assert_eq!(read(&mut accepted.consumer).await.unwrap(), None); + assert_eq!(read(&mut accepted).await.unwrap(), None); } } @@ -1036,7 +1035,7 @@ async fn an_older_hop_opted_into_hidden_connects() { .await; let alice = Endpoint::new(&client, "room", "alice").unwrap(); let bob = fixture.endpoint(LITE, "bob").await; - let (mut dialed, accepted) = connect_tcp(&alice, &bob).await; + let (dialed, accepted) = connect_tcp(&alice, &bob).await; assert_eq!(dialed.session(), accepted.session()); dialed.producer.finish().unwrap(); } diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index ec53e7424e9..abf6f57c968 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -118,7 +118,7 @@ async fn ahead_then_live(version: Option<&str>, relay: bool) -> (Vec, Vec = next(&mut live).await.into_iter().collect(); write_group(&track, 4); - track.finish().unwrap(); + let track = track.finish().unwrap(); live_got.extend(read_all(&mut live).await); let ahead_got = read_all(&mut ahead).await; @@ -170,7 +170,7 @@ async fn sparse_ranges_reach_the_publisher_on_lite07() { for sequence in 0..=4 { write_group(&track, sequence); } - track.finish().unwrap(); + let track = track.finish().unwrap(); let mut got = read_all(&mut reader).await; got.sort_unstable(); assert_eq!(got, [0, 3], "{version}"); @@ -273,6 +273,7 @@ async fn initial_mixed_ranges_keep_the_absolute_history() { for relay in [false, true] { for finished in [false, true] { let fixture = range_fixture_version(version, relay).await; + let mut _finished = None; if finished { let mut warm = subscribe( &fixture.remote, @@ -282,7 +283,7 @@ async fn initial_mixed_ranges_keep_the_absolute_history() { ) .await; assert_eq!(next(&mut warm).await, Some(5)); - fixture.track.finish().unwrap(); + _finished = Some(fixture.track.clone().finish().unwrap()); assert_eq!(next(&mut warm).await, None); } let subscription = Subscription::default() diff --git a/rs/moq-net/tests/integration/subscription_end_integrity.rs b/rs/moq-net/tests/integration/subscription_end_integrity.rs index ebf1268131c..fb043e4b25b 100644 --- a/rs/moq-net/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-net/tests/integration/subscription_end_integrity.rs @@ -133,7 +133,7 @@ async fn round(drop_session: bool) -> (Vec>, Option) { // does whenever a finish races a group still in flight. let mut tail = track.append_group().unwrap(); tail.write_frame(Timestamp::ZERO, TAIL[0]).unwrap(); - track.finish().unwrap(); + let track = track.finish().unwrap(); settle().await; // The rest of the group, its clean end, and the disconnect happen with no await in diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index 205d875436f..80aa0f6e7d2 100644 --- a/rs/moq-net/tests/integration/track_tail.rs +++ b/rs/moq-net/tests/integration/track_tail.rs @@ -340,7 +340,7 @@ async fn draft18_a_join_reaching_a_finished_track_keeps_its_head() { .expect("no subscriber appeared"); // Kept alive, as a publisher draining its session does: a finished track whose producer // is gone lets its cache reclaim the head, and that FETCH is refused. - track.finish().unwrap(); + let track = track.finish().unwrap(); let _track = track; let (frames, err) = kio::clock::timeout(TIMEOUT, reader) @@ -390,7 +390,7 @@ async fn ietf_leaving_cancels_a_blocked_end_of_track() { // Out of stream credit, so the marker cannot open. pair.server_transport.withhold_unis(); - track.finish().unwrap(); + let _finished = track.clone().finish().unwrap(); kio::clock::sleep(GRACE / 10).await; assert!( track.subscription().is_some(), @@ -446,7 +446,7 @@ async fn a_group_whose_first_frame_trails_its_header_is_delivered() { .expect("no subscriber appeared"); track.finish_at(moq_net::track::Position::group(2), None).unwrap(); - let mut groups = [track.append_group().unwrap(), track.append_group().unwrap()]; + let groups = [track.append_group().unwrap(), track.append_group().unwrap()]; // Paused time advances only once every task is idle: both headers and the end // have reached the subscriber, ahead of any frame. kio::clock::sleep(GRACE / 10).await; @@ -455,7 +455,7 @@ async fn a_group_whose_first_frame_trails_its_header_is_delivered() { "{version}: the track ended before its groups showed" ); - for group in &mut groups { + for mut group in groups { group.write_frame(Timestamp::ZERO, PAYLOAD).unwrap(); group.finish().unwrap(); } diff --git a/rs/moq-net/tests/integration/tracks.rs b/rs/moq-net/tests/integration/tracks.rs index ef3103d87d4..c8c68cd6f47 100644 --- a/rs/moq-net/tests/integration/tracks.rs +++ b/rs/moq-net/tests/integration/tracks.rs @@ -83,7 +83,7 @@ async fn a_session_lists_its_peers_tracks() { assert_eq!(next(&mut tracks).await, "+b"); drop(a); assert_eq!(next(&mut tracks).await, "-a"); - b.finish().unwrap(); + let b = b.finish().unwrap(); drop(b); assert_eq!(next(&mut tracks).await, "~b", "TRACKS_FINISH, not TRACKS_REMOVE"); @@ -188,7 +188,7 @@ async fn a_relay_shares_its_upstream_listing() { assert_eq!(next(&mut one).await, "+b"); assert_eq!(next(&mut two).await, "+b"); - a.finish().unwrap(); + let a = a.finish().unwrap(); drop(a); assert_eq!(next(&mut one).await, "~a"); assert_eq!(next(&mut two).await, "~a"); diff --git a/rs/moq-relay/tests/integration/auth_lifetime.rs b/rs/moq-relay/tests/integration/auth_lifetime.rs index b4b4e480811..7a8be457f88 100644 --- a/rs/moq-relay/tests/integration/auth_lifetime.rs +++ b/rs/moq-relay/tests/integration/auth_lifetime.rs @@ -894,7 +894,7 @@ async fn a_rechecked_grant_resizes_live_sessions() { group .write_frame(moq_net::Timestamp::ZERO, b"media".as_ref()) .expect("write frame"); - group.finish().expect("finish group"); + let group = group.finish().expect("finish group"); assert_eq!(group.sequence, sequence); }; for (index, sub) in subs.iter_mut().enumerate() { diff --git a/rs/moq-stats/src/produce.rs b/rs/moq-stats/src/produce.rs index 87c5ef8cc7d..e56e09d67b0 100644 --- a/rs/moq-stats/src/produce.rs +++ b/rs/moq-stats/src/produce.rs @@ -537,7 +537,7 @@ impl Snapshot { true => self.largest.map_or(0, |largest| largest + 1), false => stamp.group, }; - if let Some(mut group) = self.group.take() { + if let Some(group) = self.group.take() { group.finish()?; } self.group = Some(self.track.create_group(moq_net::group::Info { sequence })?); @@ -565,10 +565,11 @@ impl Snapshot { } fn finish(&mut self) -> moq_json::Result<()> { - if let Some(mut group) = self.group.take() { + if let Some(group) = self.group.take() { group.finish()?; } - Ok(self.track.finish()?) + // The output keeps its own clone, whose appends the end refuses. + Ok(self.track.clone().finish().map(drop)?) } } diff --git a/rs/moq-tokio/tests/integration/backend.rs b/rs/moq-tokio/tests/integration/backend.rs index 29a00dc44ba..eba13076027 100644 --- a/rs/moq-tokio/tests/integration/backend.rs +++ b/rs/moq-tokio/tests/integration/backend.rs @@ -668,7 +668,7 @@ async fn quic_client_close_drains_finished_track() { .write_frame(moq_net::Timestamp::ZERO, payload) .expect("failed to write frame"); group.finish().expect("failed to finish group"); - track.finish().expect("failed to finish track"); + let _track = track.finish().expect("failed to finish track"); let mut close = Box::pin(connection.close()); assert!(futures::FutureExt::now_or_never(close.as_mut()).is_none()); @@ -810,7 +810,7 @@ async fn quic_client_close_drains_migrated_predecessor() { .write_frame(moq_net::Timestamp::ZERO, payload) .expect("failed to write frame"); group.finish().expect("failed to finish group"); - track.finish().expect("failed to finish track"); + let _track = track.finish().expect("failed to finish track"); connection.close().await.expect("the close drains"); client.close().await; diff --git a/rs/moq-tokio/tests/integration/broadcast.rs b/rs/moq-tokio/tests/integration/broadcast.rs index 4e5cca42e6a..24d20e0a691 100644 --- a/rs/moq-tokio/tests/integration/broadcast.rs +++ b/rs/moq-tokio/tests/integration/broadcast.rs @@ -1307,9 +1307,10 @@ async fn rejoin_replays_a_current_warm_cache(version: &str, open: bool) { group .write_frame(moq_net::Timestamp::ZERO, b"v0".as_ref()) .expect("write frame"); - if !open { - group.finish().expect("finish group"); - } + let (mut group, _finished) = match open { + true => (Some(group), None), + false => (None, Some(group.finish().expect("finish group"))), + }; let mut config = moq_tokio::listen::Config::default(); config.bind = Some("[::]:0".parse().unwrap()); @@ -1381,6 +1382,8 @@ async fn rejoin_replays_a_current_warm_cache(version: &str, open: bool) { assert_eq!(read(&mut reading, &ctx).await, format!("v{frame}"), "{ctx}"); } group + .as_mut() + .expect("open") .write_frame(moq_net::Timestamp::ZERO, update.as_bytes()) .expect("write frame"); } else { diff --git a/rs/moq-tokio/tests/integration/datagram_tracks.rs b/rs/moq-tokio/tests/integration/datagram_tracks.rs index d7c20361e69..95d6ccb1c09 100644 --- a/rs/moq-tokio/tests/integration/datagram_tracks.rs +++ b/rs/moq-tokio/tests/integration/datagram_tracks.rs @@ -229,7 +229,7 @@ async fn run(relay: bool, js_publishes: bool) { expect_line(&mut lines, "received").await; audio.finish(); events.finish(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); drop(child.stdin.take()); assert!(child.wait().await.unwrap().success(), "JS subscriber failed"); } diff --git a/rs/moq-tokio/tests/integration/sim.rs b/rs/moq-tokio/tests/integration/sim.rs index 58f5f5a82d9..0929b3e5c19 100644 --- a/rs/moq-tokio/tests/integration/sim.rs +++ b/rs/moq-tokio/tests/integration/sim.rs @@ -221,7 +221,7 @@ async fn serve(network: &Network, version: Version, seed: u64) -> Arrivals { group.finish().unwrap(); kio::clock::sleep(INTERVAL).await; } - source.finish().unwrap(); + let _source = source.finish().unwrap(); }; let read = async { let mut arrivals = Vec::new(); diff --git a/rs/moq-tokio/tests/integration/subscription_end_integrity.rs b/rs/moq-tokio/tests/integration/subscription_end_integrity.rs index 69ca34cbd1e..a5e3ba26d7a 100644 --- a/rs/moq-tokio/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-tokio/tests/integration/subscription_end_integrity.rs @@ -142,7 +142,7 @@ async fn round(drop_session: bool) -> (usize, Option) { // The final group, a clean group end and a clean track end, innermost first and with // no await in between: the session has sent none of it yet. write_group(&track); - track.finish().expect("finish track"); + let track = track.finish().expect("finish track"); drop(track); // The publisher is done, so it disconnects. Nothing it could have awaited first. diff --git a/rs/moq-transcode/src/lib.rs b/rs/moq-transcode/src/lib.rs index 857c79a2a29..154bc9b83ce 100644 --- a/rs/moq-transcode/src/lib.rs +++ b/rs/moq-transcode/src/lib.rs @@ -2047,7 +2047,7 @@ mod tests { write_keyframe(&mut group); group.finish().unwrap(); match finish { - true => source._track.finish().unwrap(), + true => drop(source._track.clone().finish().unwrap()), false => source._track.clone().abort(moq_net::Error::Cancel).unwrap(), } diff --git a/rs/moq-transcode/src/rung.rs b/rs/moq-transcode/src/rung.rs index 68599a603c9..6bfeaee9f6f 100644 --- a/rs/moq-transcode/src/rung.rs +++ b/rs/moq-transcode/src/rung.rs @@ -144,7 +144,7 @@ struct Writing(Option); impl Writing { fn finish(mut self) -> moq_net::Result<()> { - self.0.take().expect("owned group").finish() + self.0.take().expect("owned group").finish().map(drop) } fn abort(mut self, err: moq_net::Error) -> moq_net::Result<()> { @@ -212,7 +212,8 @@ pub(crate) fn serve(rung: Rung, request: moq_net::track::Request) -> impl Future // to count, so finishing then would reject the very group it was fetching. match (live, fetches) { (Ok(Ended::Finished), Ok(())) => { - producer.finish()?; + // Released with `serving`, the last clone, which then no longer aborts it. + drop(producer.finish()?); serving.0 = None; Ok(()) } diff --git a/rs/moq-video/src/decode/consumer.rs b/rs/moq-video/src/decode/consumer.rs index c2357cf62e5..a75172aff28 100644 --- a/rs/moq-video/src/decode/consumer.rs +++ b/rs/moq-video/src/decode/consumer.rs @@ -843,7 +843,7 @@ mod tests { consumer.reader(Lane::Min).track.set_delay(Delay::default()); write(12, &[3000]); write(13, &[4000, 3800, 3900, 4100]); - track.finish().unwrap(); + let _track = track.finish().unwrap(); got.clear(); while let Some(frame) = consumer.next_frame().await.unwrap() { got.push(frame.timestamp.as_micros()); @@ -1413,7 +1413,7 @@ mod tests { let (broadcast, mut track) = live_track(); group(&mut track, 0, &[0, 1, 2, 3]).finish().unwrap(); group(&mut track, 1, &[4, 5]).finish().unwrap(); - track.finish().unwrap(); + let _track = track.finish().unwrap(); // A budget past the whole 5 s backlog, so the start keeps every cached group and both // decoders read them all. diff --git a/rs/moq-video/src/encode/producer.rs b/rs/moq-video/src/encode/producer.rs index db9f759ca4d..cdee6e9ce33 100644 --- a/rs/moq-video/src/encode/producer.rs +++ b/rs/moq-video/src/encode/producer.rs @@ -524,7 +524,8 @@ impl Owned { /// End the track cleanly, best effort: it is usually already going away. fn finish(self) { let ended = match self { - Self::Track(track) => track.finish().map_err(Error::from), + // The caller is done with the track, so the finished handle goes with it. + Self::Track(track) => track.finish().map(drop).map_err(Error::from), Self::Producer(mut producer) => producer.finish(), Self::Done => Ok(()), }; diff --git a/rs/moq-webrtc/src/codec/mod.rs b/rs/moq-webrtc/src/codec/mod.rs index 0962e37fdc3..9f8f55a0a28 100644 --- a/rs/moq-webrtc/src/codec/mod.rs +++ b/rs/moq-webrtc/src/codec/mod.rs @@ -164,7 +164,8 @@ impl DeferredVideo { /// Finish the media track, whether or not a frame ever created its importer. pub fn finish(&mut self) -> Result<()> { match &mut self.state { - DeferredState::Pending(pending) => pending.track.finish()?, + // The pending state keeps its own clone, whose appends the end refuses. + DeferredState::Pending(pending) => drop(pending.track.clone().finish()?), DeferredState::Active(import) => import.finish()?, // The track already failed, so there is nothing clean to end. DeferredState::Failed(_) | DeferredState::Poisoned => {} diff --git a/test/interop/clients/rust/finish.rs b/test/interop/clients/rust/finish.rs index 60051b406b6..ace885ec69d 100644 --- a/test/interop/clients/rust/finish.rs +++ b/test/interop/clients/rust/finish.rs @@ -102,7 +102,7 @@ async fn main() -> anyhow::Result<()> { .broadcast() .create_track("live", moq_net::track::Info::default())?; track.write_frame(None, b"session-alive".to_vec())?; - track.finish()?; + let _track = track.finish()?; health.announce()?; let ack = args.finish_ack.context("publisher needs --finish-ack")?; let mut complete = String::new(); diff --git a/test/interop/clients/rust/socket-js.rs b/test/interop/clients/rust/socket-js.rs index c0e9a19fed2..4fbd032d7f0 100644 --- a/test/interop/clients/rust/socket-js.rs +++ b/test/interop/clients/rust/socket-js.rs @@ -71,13 +71,13 @@ async fn main() -> anyhow::Result<()> { for i in 0..3 { stream.producer.write_frame(None, vec![own + i])?; } - stream.producer.finish()?; + let finished = stream.producer.finish()?; for i in 0..3 { let frame = stream.consumer.read_frame().await?.context("short TCP half")?; ensure!(frame.payload.as_ref() == [peer + i], "wrong TCP frame"); } ensure!(stream.consumer.read_frame().await?.is_none(), "extra TCP frame"); - Box::new(stream) + Box::new((finished, stream.consumer)) } else { let mut stream = if dial { endpoint.dial_track("acceptor", None)?.await? @@ -100,9 +100,9 @@ async fn main() -> anyhow::Result<()> { stream.producer.write_frame(None, vec![own + i])?; } } - stream.producer.finish()?; + let finished = stream.producer.finish()?; ensure!(reader.next_group().await?.is_none(), "extra track frame"); - Box::new((stream.producer, reader)) + Box::new((finished, reader)) }; eprintln!("socket data verified {} {}", args[4], args[1]); if tcp { diff --git a/test/interop/clients/rust/socket.rs b/test/interop/clients/rust/socket.rs index b1cf420eeb4..106f5942b94 100644 --- a/test/interop/clients/rust/socket.rs +++ b/test/interop/clients/rust/socket.rs @@ -85,7 +85,7 @@ async fn main() -> anyhow::Result<()> { } group.finish()?; } - producer.finish()?; + let _producer = producer.finish()?; for sequence in 0..3 { let mut next = consumer.next_group().await?.context("short track")?; ensure!(next.sequence == sequence, "wrong group order"); diff --git a/test/interop/clients/rust/tail.rs b/test/interop/clients/rust/tail.rs index 9be6786735d..8a544f61223 100644 --- a/test/interop/clients/rust/tail.rs +++ b/test/interop/clients/rust/tail.rs @@ -167,6 +167,8 @@ async fn main() -> anyhow::Result<()> { .connect(url) .established() .await?; + // Held until the reader acknowledged the end, as the producer was. + let mut _finished = None; if let Some(mut group) = head { ensure!( commands.next_line().await?.as_deref() == Some("late tail"), @@ -183,7 +185,7 @@ async fn main() -> anyhow::Result<()> { } group.finish()?; } - track.finish()?; + _finished = Some(track.finish()?); } else if !cached { let mut demand = track.demand(); while demand.wanted_changed().await?.is_none() {}