From f6c09b12627f8d74de7a6256c8a06a449e3b1ac9 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 08:33:05 -0800 Subject: [PATCH 1/9] chore(quest): claim quest/m2/group-api.md Quest-Claim: 4eaa21678156a7a0 From dc2acfa20dffb4cbe94f2e99ca419e1fe8913d2b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 09:10:34 -0800 Subject: [PATCH 2/9] feat(net)!: append_group takes an optional start, a group ends with finish, fail ends a track in error, and Fill splits groups from lookups Co-Authored-By: Claude Opus 5.5 --- doc/lib/js/net.md | 4 +- doc/lib/rs/moq-net.md | 4 +- js/net/api/index.api.md | 17 +- js/net/src/cache.test.ts | 3 +- js/net/src/fill.test.ts | 196 +-- js/net/src/fill.ts | 144 +- js/net/src/ietf/range.ts | 6 +- js/net/src/ietf/subscriber.ts | 9 +- js/net/src/lite/copy_fill.test.ts | 26 +- js/net/src/lite/fills.test.ts | 23 +- js/net/src/lite/fills.ts | 10 +- js/net/src/lite/publisher.test.ts | 8 +- js/net/src/lite/subscriber.ts | 11 +- js/net/src/mock.ts | 12 + js/net/src/resume.test.ts | 10 +- js/net/src/track.test.ts | 40 +- js/net/src/track.ts | 35 +- rs/hang/examples/video.rs | 2 +- rs/hang/src/catalog/consumer.rs | 6 +- rs/moq-archive/benches/producer.rs | 2 +- rs/moq-archive/src/consumer/tests.rs | 6 +- rs/moq-archive/src/consumer/track.rs | 97 +- rs/moq-archive/src/producer/backends.rs | 4 +- rs/moq-archive/src/producer/tests.rs | 28 +- rs/moq-audio/src/decode/consumer.rs | 2 +- rs/moq-audio/src/encode/producer.rs | 7 +- rs/moq-bench/src/connection.rs | 14 +- rs/moq-boy/src/input.rs | 9 +- rs/moq-c/src/consume.rs | 4 +- rs/moq-c/src/publish.rs | 28 +- rs/moq-c/src/test.rs | 4 +- rs/moq-cli/src/archive.rs | 4 +- rs/moq-cli/src/fetch.rs | 4 +- rs/moq-cli/src/main.rs | 4 +- rs/moq-cli/src/play/video.rs | 4 +- rs/moq-cli/tests/integration/instances.rs | 7 +- rs/moq-crypto/benches/protect.rs | 2 +- rs/moq-crypto/src/e2ee/group.rs | 8 +- rs/moq-crypto/src/e2ee/tests.rs | 26 +- rs/moq-crypto/src/e2ee/track.rs | 6 +- rs/moq-crypto/tests/transport.rs | 2 +- rs/moq-ffi/src/bench.rs | 2 +- rs/moq-ffi/src/media.rs | 8 +- rs/moq-ffi/src/producer.rs | 23 +- rs/moq-ffi/src/test.rs | 6 +- rs/moq-gst/src/sink/imp.rs | 2 +- rs/moq-hls/src/export/archive_tests.rs | 2 +- rs/moq-hls/src/export/mod.rs | 26 +- rs/moq-hls/src/export/rendition.rs | 2 +- rs/moq-hls/src/server/include_tests.rs | 2 +- rs/moq-json/src/snapshot/mod.rs | 8 +- rs/moq-json/src/snapshot/producer.rs | 10 +- rs/moq-json/src/stream/mod.rs | 2 +- rs/moq-json/src/stream/producer.rs | 2 +- rs/moq-json/src/window/mod.rs | 4 +- rs/moq-json/src/window/producer.rs | 8 +- rs/moq-mux/src/catalog/hang/consumer.rs | 22 +- rs/moq-mux/src/catalog/producer.rs | 2 +- rs/moq-mux/src/codec/h264/export.rs | 6 +- rs/moq-mux/src/codec/h265/export.rs | 6 +- rs/moq-mux/src/container/consumer.rs | 140 +- rs/moq-mux/src/container/fmp4/export_test.rs | 2 +- rs/moq-mux/src/container/fmp4/import.rs | 4 +- rs/moq-mux/src/container/group.rs | 2 +- rs/moq-mux/src/container/producer.rs | 16 +- rs/moq-mux/src/container/source.rs | 14 +- rs/moq-mux/src/container/ts/export_test.rs | 16 +- .../src/container/ts/export_timing_test.rs | 12 +- rs/moq-mux/src/container/ts/recovery_test.rs | 4 +- rs/moq-mux/src/container/ts/release_test.rs | 2 +- rs/moq-mux/src/container/ts/si.rs | 2 +- rs/moq-mux/src/linger.rs | 10 +- rs/moq-mux/tests/legacy_audio.rs | 2 +- .../tests/integration/ietf_conformance.rs | 2 +- rs/moq-net-tests/tests/integration/restart.rs | 5 +- rs/moq-net-tests/tests/integration/serve.rs | 4 +- .../tests/integration/snapshot.rs | 2 +- rs/moq-net/benches/group.rs | 22 +- rs/moq-net/benches/memory.rs | 2 +- rs/moq-net/benches/origin.rs | 14 +- rs/moq-net/benches/ranges.rs | 6 +- rs/moq-net/benches/refresh.rs | 2 +- rs/moq-net/benches/session/mod.rs | 18 +- rs/moq-net/benches/tail.rs | 8 +- rs/moq-net/benches/track.rs | 64 +- rs/moq-net/benches/viewers.rs | 2 +- rs/moq-net/src/fuzz.rs | 10 +- rs/moq-net/src/fuzz/ingest.rs | 2 +- rs/moq-net/src/fuzz/session.rs | 8 +- rs/moq-net/src/ietf/object.rs | 2 +- rs/moq-net/src/ietf/publisher.rs | 206 +-- rs/moq-net/src/ietf/subscriber.rs | 60 +- rs/moq-net/src/lite/ietf.rs | 14 +- rs/moq-net/src/lite/publisher.rs | 130 +- rs/moq-net/src/lite/subscriber.rs | 91 +- rs/moq-net/src/lite/subscriber/fills.rs | 20 +- rs/moq-net/src/model/broadcast.rs | 44 +- rs/moq-net/src/model/group.rs | 127 +- rs/moq-net/src/model/origin.rs | 212 +-- rs/moq-net/src/model/resume.rs | 188 +-- rs/moq-net/src/model/resume_model.rs | 4 +- rs/moq-net/src/model/subscription.rs | 2 +- rs/moq-net/src/model/track.rs | 1438 +++++++++-------- rs/moq-net/src/model/track/fill.rs | 102 +- rs/moq-net/src/model/track/miss.rs | 26 +- rs/moq-net/src/reconnect/tests.rs | 4 +- rs/moq-net/src/recv.rs | 2 +- rs/moq-net/src/session/tests.rs | 8 +- rs/moq-net/tests/group_charge.rs | 4 +- .../tests/integration/announce_to_serve.rs | 5 +- .../tests/integration/answer_behind_cache.rs | 4 +- rs/moq-net/tests/integration/auth.rs | 33 +- .../tests/integration/catalog_acquisition.rs | 5 +- rs/moq-net/tests/integration/catalog_churn.rs | 7 +- .../tests/integration/catalog_handover.rs | 3 +- .../tests/integration/claim_continues.rs | 5 +- rs/moq-net/tests/integration/compress.rs | 15 +- rs/moq-net/tests/integration/control_stats.rs | 5 +- rs/moq-net/tests/integration/drained_claim.rs | 5 +- rs/moq-net/tests/integration/drop_record.rs | 4 +- rs/moq-net/tests/integration/empty_group.rs | 7 +- rs/moq-net/tests/integration/errored_end.rs | 11 +- .../tests/integration/failover_chain.rs | 11 +- .../tests/integration/fastest_reader.rs | 23 +- rs/moq-net/tests/integration/fetch_cancel.rs | 14 +- rs/moq-net/tests/integration/fetch_fanout.rs | 5 +- .../tests/integration/fetch_from_feed.rs | 7 +- rs/moq-net/tests/integration/fetch_only.rs | 11 +- .../tests/integration/fetch_pipeline.rs | 10 +- .../integration/finished_broadcast_mock.rs | 5 +- rs/moq-net/tests/integration/finite_relay.rs | 11 +- rs/moq-net/tests/integration/flights.rs | 15 +- rs/moq-net/tests/integration/goaway.rs | 13 +- .../tests/integration/half_read_frame.rs | 4 +- .../tests/integration/history_groups.rs | 4 +- rs/moq-net/tests/integration/history_join.rs | 5 +- .../tests/integration/idle_cancel_refetch.rs | 4 +- .../tests/integration/late_lower_group.rs | 2 +- .../tests/integration/late_tail_reader.rs | 6 +- rs/moq-net/tests/integration/mesh_sweep.rs | 5 +- rs/moq-net/tests/integration/model.rs | 2 +- rs/moq-net/tests/integration/mount.rs | 5 +- rs/moq-net/tests/integration/multi_cdn.rs | 5 +- rs/moq-net/tests/integration/nested_claim.rs | 5 +- rs/moq-net/tests/integration/partial_group.rs | 7 +- rs/moq-net/tests/integration/path_routes.rs | 6 +- rs/moq-net/tests/integration/quiet_catalog.rs | 5 +- rs/moq-net/tests/integration/range_anchors.rs | 6 +- rs/moq-net/tests/integration/range_fill.rs | 10 +- rs/moq-net/tests/integration/range_read.rs | 5 +- .../tests/integration/received_rewind.rs | 2 +- rs/moq-net/tests/integration/rejoin.rs | 69 +- .../tests/integration/relay_upstream_close.rs | 5 +- rs/moq-net/tests/integration/replacement.rs | 5 +- rs/moq-net/tests/integration/route_change.rs | 71 +- rs/moq-net/tests/integration/route_cluster.rs | 2 +- .../tests/integration/route_failover.rs | 2 +- rs/moq-net/tests/integration/route_health.rs | 7 +- .../tests/integration/segmented_frame.rs | 5 +- rs/moq-net/tests/integration/session_close.rs | 21 +- .../integration/settled_end_survives_abort.rs | 7 +- rs/moq-net/tests/integration/slow_joiner.rs | 2 +- rs/moq-net/tests/integration/socket.rs | 9 +- rs/moq-net/tests/integration/source_errors.rs | 9 +- rs/moq-net/tests/integration/stream_credit.rs | 71 +- .../tests/integration/subscribe_ranges.rs | 20 +- .../tests/integration/subscribe_tracks.rs | 5 +- .../tests/integration/subscribe_with_track.rs | 9 +- .../tests/integration/subscriber_max_age.rs | 9 +- .../integration/subscription_end_integrity.rs | 11 +- rs/moq-net/tests/integration/support/mod.rs | 23 +- .../integration/track_abort_over_session.rs | 3 +- .../tests/integration/track_stream_demand.rs | 5 +- rs/moq-net/tests/integration/track_tail.rs | 23 +- rs/moq-net/tests/integration/tracks.rs | 5 +- rs/moq-net/tests/integration/tracks_ietf.rs | 9 +- rs/moq-net/tests/integration/untimed.rs | 13 +- rs/moq-net/tests/integration/warm_backfill.rs | 6 +- rs/moq-net/tests/integration/wide_key.rs | 9 +- .../tests/integration/widened_max_age.rs | 6 +- rs/moq-net/tests/integration/zero_copy.rs | 5 +- rs/moq-relay/src/fetch.rs | 10 +- rs/moq-relay/src/internal.rs | 24 +- rs/moq-relay/src/web.rs | 14 +- rs/moq-relay/tests/drills.rs | 24 +- .../tests/integration/auth_lifetime.rs | 35 +- .../tests/integration/bitrate_caps.rs | 6 +- .../tests/integration/cluster_unknown.rs | 6 +- rs/moq-relay/tests/integration/connection.rs | 8 +- rs/moq-relay/tests/integration/embed.rs | 6 +- .../tests/integration/goaway_cluster.rs | 42 +- .../tests/integration/public_rules.rs | 4 +- rs/moq-relay/tests/integration/quic_sim.rs | 4 +- .../tests/integration/runtime_uring.rs | 24 +- .../tests/integration/runtime_workers.rs | 6 +- rs/moq-relay/tests/integration/smoke.rs | 36 +- rs/moq-relay/tests/integration/socket_auth.rs | 6 +- .../tests/integration/tenant_matrix.rs | 4 +- .../tests/integration/upstream_links.rs | 4 +- rs/moq-stats/src/aggregate.rs | 4 +- rs/moq-stats/src/consume.rs | 7 +- rs/moq-stats/src/produce.rs | 19 +- rs/moq-tokio/examples/chat.rs | 2 +- rs/moq-tokio/examples/clock.rs | 2 +- rs/moq-tokio/src/client.rs | 6 +- rs/moq-tokio/src/connection.rs | 36 +- rs/moq-tokio/src/server.rs | 6 +- rs/moq-tokio/tests/integration/backend.rs | 18 +- rs/moq-tokio/tests/integration/broadcast.rs | 138 +- rs/moq-tokio/tests/integration/migrate.rs | 6 +- .../tests/integration/receive_credit.rs | 90 +- rs/moq-tokio/tests/integration/relay_fill.rs | 2 +- rs/moq-tokio/tests/integration/runtime.rs | 6 +- rs/moq-tokio/tests/integration/sim.rs | 2 +- rs/moq-tokio/tests/integration/sim_client.rs | 2 +- .../integration/subscription_end_integrity.rs | 6 +- rs/moq-transcode/src/lib.rs | 46 +- rs/moq-transcode/src/rung.rs | 71 +- rs/moq-uring/benches/session_lite.rs | 6 +- .../tests/integration/receive_credit.rs | 21 +- rs/moq-uring/tests/integration/session.rs | 12 +- rs/moq-uring/tests/integration/web.rs | 6 +- rs/moq-video/src/decode/consumer.rs | 20 +- test/interop/clients/js-native/replace.ts | 1 + test/interop/clients/js-native/tail.ts | 4 + test/interop/clients/rust/control.rs | 2 +- test/interop/clients/rust/finish.rs | 2 +- test/interop/clients/rust/goaway.rs | 2 +- test/interop/clients/rust/socket.rs | 2 +- test/interop/clients/rust/tail.rs | 8 +- 230 files changed, 2841 insertions(+), 2807 deletions(-) diff --git a/doc/lib/js/net.md b/doc/lib/js/net.md index 4f8bad7637c..4c71f60a96a 100644 --- a/doc/lib/js/net.md +++ b/doc/lib/js/net.md @@ -40,7 +40,7 @@ route.announce(); - **The origin holds the routes, not the connection.** `origin.route(path)` creates a route that owns a new broadcast; fill its tracks through `route.broadcast`. Closing a session withdraws its announcements and leaves the routes for the next one. A route is visible at once unless created `{ hidden: true }`, which keeps it invisible, locally and remotely, until `announce()`. `withdraw()` hides it again and `announce()` brings the same stream back. `close()` retracts it and closes its broadcast, as closing the broadcast does. - **Answer claimed paths with a route.** `origin.claim(prefix)` returns a `Claim` over a prefix, and `claim.requested()` yields each requested path. Answer with `request.route()`, a new exact route under the claim's instance (a fresh one if the claim names its own), so on `moq-lite-07-wip` readers resolved through the claim continue (older wires mint another instance for it, restarting their subscription), or `request.route({ hidden: true })` to fill its broadcast before `announce()` answers the requesters; closing it or its broadcast before then refuses them as unroutable, so `using job = request.route({ hidden: true })` refuses on a throw. Serve a broadcast you already hold with `request.serve(broadcast)`, or refuse with `request.reject(err)`. -- **End content by finishing tracks.** A broadcast has no finished state. When the input ends, `finish()` each track, then `close()` it; closing a track without finishing aborts it. The broadcast stays announced and keeps serving them until you `close()` it. How long to keep it up for late readers is yours to decide. +- **End content by finishing tracks.** A broadcast has no finished state. When the input ends, `finish()` each track, then `close()` it; closing a track without finishing aborts it. `fail(error)` ends a track in error instead: unlike `abort`, readers still get every group written, then the error. The broadcast stays announced and keeps serving them until you `close()` it. How long to keep it up for late readers is yours to decide. - **Requests can pin an instance.** `consumer.request(path, { instance })` resolves only through a route announcing that [publisher instance](/concept/moq-lite#publisher-instances). The resolved broadcast's `instance` names the stream it came through, pinned or not. `origin.route(path)` mints a random instance when it is created and keeps it across `withdraw()` and `announce()`. Unless one is named, a claim moves to a fresh instance each time a job holding its current one ends, and a job takes the claim's. Pass `origin.route(path, { instance: { id, epoch } })` only for a publisher that continues its group sequences across restarts and raises the epoch each time. - **Follow restarts.** `origin.follow(path)` follows whichever publisher instance serves the path: its `active` changes to a fresh broadcast on a restart, clears on an end, and resolves again on the next start, so read it reactively and close it when done. Instances are never stitched, so subscribe again to each new broadcast. Another route of the same instance taking over (instances travel only on `moq-lite-07-wip`; older wires mint one per announcement) keeps `active` as is, and each track subscription resumes there from the first group it lacks. A refusal ends it. Pass `{ instance }` to pin one stream, which it waits for again after an end. `request(path)` instead keeps its accepted instance and ends once that instance stops serving; while pending, it fails `Unroutable` once discovery of its path has synced without a route for it. To list what is live, iterate `announced(scope)`. See [identity and recovery](/concept/identity) to choose between following and holding one instance. - **Discovery follows what you watch.** A `consume` origin asks the relay for announcements only under the prefixes its readers watch with `announced(scope)`, `request(path)`, or `follow(path)`, stops asking about a prefix 2s after nothing at or beneath it is watched, and asks again on reconnect. Every request and follower watches its path from creation until closed, so it outlives the listing that found it. A relay that refuses an announce request downgrades that session: requests subscribe blind through it, and followers keep waiting for a session that can discover. @@ -50,7 +50,7 @@ route.announce(); - **One receive estimate per connection.** `connection.viewers` divides it among watched broadcasts, max-min fair by each viewer's ceiling, so several players on one pooled connection don't each select against the whole downlink. Holding a viewer requests PROBE, and the viewers' ceilings, summed, are the PROBE target a relay advertising `Increase` probes the downlink up to. `setTarget(0)` opts out. `watch`, `update`, and `setTarget` throw a `RangeError` when the ceilings or the target would pass `Viewers.MAX_TARGET` (`Number.MAX_SAFE_INTEGER`), the most a PROBE target carries. - **List a broadcast's tracks.** `for await (const event of broadcast.tracks())` reports each track the broadcast lists (`added`, with its `Track.Info`), one `synced`, then `added` and `removed` as tracks come and go, until the broadcast ends; leaving the loop stops listing. Over a session it needs `moq-lite-07-wip`, and syncs when the peer does, so a track added after `synced` is new at the source. A track served only on request is never listed. See [discovery](/concept/moq-lite#discovery). - **One track per name.** Concurrent subscriptions share one request and producer. `createTrack` on a name with a request still queued answers it. The application owns sequence numbers: the broadcast keeps nothing of an ended track, so a track that replaces it, created or requested, starts at 0. A name always means the same content, so the replacement continues past its predecessor's groups by writing its first group with an explicit sequence. Sequences are `bigint`, so every ID the wire carries fits, past 2^53 included: `track.createGroup(5n)`, `{ absolute: 10n }`. Frame indices and relative anchors stay `number`. -- **Serve history on request.** `track.requests()` opens a handle that serves the groups readers miss: ones their ranges name below the newest group written that the cache no longer holds, or never did. Each run of misses arrives as a `Track.Fill` from `await requests.requestedFill()`, shared by every reader missing it. `accept(sequence)` it into the cache and write the group's frames as first published, `dropGroups(start, end)` what the source lacks (sequences are `bigint`), and serve `wanted()` until it is `undefined`: a reader that leaves or narrows stops wanting its groups. `close()` the fill when done; whatever is still wanted is named dropped. A `fetchGroup` of an uncached group asks the handle at once, even for a group not written yet, which a live write then answers; with no handle open it fails with `NotFound`, as in Rust, and a reader's miss is given up. A reader only asks for what its `delay.max` still wants, so a reader at the live edge never asks. This serves lite FETCH and lite-07 ranged subscriptions from the same track, as Rust's `requests()` does. A moq-transport FETCH is refused, so a moq-transport reader never reaches it. +- **Serve history on request.** `track.requests()` opens a handle that serves the groups readers miss: ones their ranges name below the newest group written that the cache no longer holds, or never did. Each run of misses arrives as a `Track.FillGroups` (`kind: "groups"`) from `await requests.requestedFill()`, shared by every reader missing it. `accept(sequence)` it into the cache and write the group's frames as first published, `dropGroups(start, end)` what the source lacks (sequences are `bigint`), and serve `wanted()` until it is `undefined`: a reader that leaves or narrows stops wanting its groups. `close()` the fill when done; whatever is still wanted is named dropped. A `fetchGroup` of an uncached group asks the handle at once, even for a group not written yet, which a live write then answers; with no handle open it fails with `NotFound`, as in Rust, and a reader's miss is given up. A reader only asks for what its `delay.max` still wants, so a reader at the live edge never asks. A range starting at a `time` no cached group resolves arrives as a `Track.FillLookup` (`kind: "lookup"`) instead: `accept` the group containing its `time`, or `close()` it and the reader falls back to the groups cached. This serves lite FETCH and lite-07 ranged subscriptions from the same track, as Rust's `requests()` does. A moq-transport FETCH is refused, so a moq-transport reader never reaches it. - **Timing is per track, with no default.** A track that declares a `timescale` carries a `timestamp` on every frame; one without is [untimed](/concept/moq-lite#subscriptions) and each frame carries `Time.Timestamp.unscaled(group.sequence)`, its group's key, which has no time: `as`, `asMillis`, and `asMicros` throw on it. A scaled timestamp on an untimed track, an unscaled one on a timed track, or another key throws `TimestampMismatch`. Omitting it means untimed, as in Rust. Nothing stamps a frame for you: the publisher passes the timestamp, and the `Timed` type (`{ value, at }`) carries one into the `@moq/json` producers. - **Durations and instants are `Clock` types.** Every duration (`maxAge`, `delay`, timeouts, RTT) is a `Clock.Duration` and every monotonic time a `Clock.Instant`, from [`@moq/clock`](./clock), which `@moq/net` re-exports as `Clock`: `maxAge: Moq.Clock.Duration.secs(30)`. Neither converts to a number implicitly; read one with an explicit unit, such as `asMillis()`. The wire still carries whole milliseconds, rounded up. Frame timestamps stay `Time.Timestamp`, a tick count at the track's timescale. - **A subscription's `delay` is a `Track.Delay { min, max }`, as in Rust.** Staleness is `delay.max`: it counts from a group's successor, by media time and by wall clock, whichever reaches it first. `delay.min` is the target latency, carried on moq-lite 07; a peer that cannot carry it leaves it `null` (not stated). Passing the old `maxAge` or `maxDelay` key throws a `TypeError` naming `delay.max`. The publisher's own staleness bound is the separate `Track.Info.maxAge`, which caps `delay.max` and fetches. diff --git a/doc/lib/rs/moq-net.md b/doc/lib/rs/moq-net.md index d8ff52e1e7c..3567eafa421 100644 --- a/doc/lib/rs/moq-net.md +++ b/doc/lib/rs/moq-net.md @@ -23,9 +23,9 @@ What you use it for, beyond what the concept page already describes: - **Discovery follows what you watch.** A client session asks the relay for announcements only under the prefixes its subscribe origin's readers watch, with `announced()`, `request`, or `follow`, stops asking about a prefix 2s after nothing at or beneath it is watched, and asks again on reconnect. A broadcast resolved through a discovered route keeps its path watched until dropped. `request` owns discovery of its path, so no separate watch is needed. A server session, or a client fed into an origin handle marked `with_link(origin::Link::Peer)` or `Link::Upstream`, asks for everything it may, so a relay discovers everything. An HTTP gateway (the moq-hls `Server`, the moq-webrtc WHEP router) watches its whole scope while it lives, so the paths its callers name never open a request each. moq-lite-03/04 sessions, whose announcements mark no initial set, still ask for everything. - **Relay by opting into proxying.** On moq-lite-07 (`moq-lite-07-wip`, opt-in) a session sends its peer only the routes to its origin's own claims, so an application never becomes transit for anyone else. A relay built on the library marks the handle it publishes with `origin.clone().with_proxy(true)` to carry what it learned from other peers too; `moq-relay` does so for every session. Older versions advertise everything either way. - **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. `accept_track()` yields an `Incoming` dial to `accept` or `reject` (dropping it rejects). `dial_track(server, info)` and an accepted 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. A group is keyed by its start, its first frame's timestamp in the track's timescale, and starts only rise. An untimed track has no timescale, so its frames carry `Timestamp::unscaled(key)`, the group's key, and a timestamp's `scale()` is `None`: conversions such as `as_millis()` fail on it, and it compares with no scaled timestamp. Every frame write takes a `Timestamp`, and one that doesn't match its track is refused with `TimestampMismatch`. `append_group(start)` opens the next one, declaring the range below it skipped, and `create_group` places one without declaring anything. The broadcast keeps nothing of an ended track, and a name always means the same content, so a producer that replaces it starts its groups past its predecessor's. 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. +- **One track per name.** Concurrent subscriptions share one request and producer. A group is keyed by its start, its first frame's timestamp in the track's timescale, and starts only rise. An untimed track has no timescale, so its frames carry `Timestamp::unscaled(key)`, the group's key, and a timestamp's `scale()` is `None`: conversions such as `as_millis()` fail on it, and it compares with no scaled timestamp. Every frame write takes a `Timestamp`, and one that doesn't match its track is refused with `TimestampMismatch`. `append_group(start)` opens the next one, declaring the range below it skipped, and `append_group(None)` opens it one past the largest start, for a track with no media clock; `create_group` places one without declaring anything. The broadcast keeps nothing of an ended track, and a name always means the same content, so a producer that replaces it starts its groups past its predecessor's. 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: `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. Ending a group returns a `group::Finished`, which can be read or aborted to release its cache: `finish(end)` ends it whole where its content stops, so a reader can tell the group starting there continues it, and `close()` ends it without one. +- **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`, and `fail(err)` does the same with an error that readers get after every group below the end. A finished track 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. Ending a group returns a `group::Finished`, which can be read or aborted to release its cache: `finish_at(end)` ends it whole where its content stops, so a reader can tell the group starting there continues it, and `finish()` ends it without one. - **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. An on-demand publisher ends a track nobody wants with `abort_unwanted`, which keeps it for a reader that joined since, rather than by dropping its producer. - **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 from the connection's arrival (30 s by default, `with_timeout`), across your transport handshake (`Server::deadline`), 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 0a60027e0ec..c84b353cd9f 100644 --- a/js/net/api/index.api.md +++ b/js/net/api/index.api.md @@ -726,23 +726,33 @@ export namespace Track { priority?: number; signal?: AbortSignal; } - export class Fill { + export type Fill = Track.FillGroups | Track.FillLookup; + export class FillGroups { [Symbol.dispose](): void; accept(sequence: bigint, info?: Track.Info): Group.Producer; close(): void; dropGroups(start: bigint, end: bigint): void; readonly end: bigint; isWanted(sequence: bigint): boolean; + readonly kind: "groups"; get maxDelay(): Clock.Duration | null; get order(): Track.Order; get priority(): number; refuseGroups(start: bigint, end: bigint, error: Error): void; readonly start: bigint; - readonly time?: Time.Timestamp; unwanted(sequence: bigint): Promise; wanted(): bigint | undefined; wantedChanged(): Promise; } + export class FillLookup { + [Symbol.dispose](): void; + accept(sequence: bigint, info?: Track.Info): Group.Producer; + close(): void; + readonly kind: "lookup"; + get maxDelay(): Clock.Duration | null; + get priority(): number; + readonly time: Time.Timestamp; + } export interface Finished { abort(error: Error): void; close(): void; @@ -803,8 +813,9 @@ export namespace Track { get closed(): Signals.GetPromise; createGroup(sequence: bigint): Group.Producer; demand(): Track.Demand; + fail(error: Error): Track.Finished; finish(): Track.Finished; - finishAt(end: Track.Position, error?: Error): void; + finishAt(end: Track.Position): void; info(): Promise; largest(): Track.Position | undefined; readonly name: string; diff --git a/js/net/src/cache.test.ts b/js/net/src/cache.test.ts index 1ee844c4394..d098dee8207 100644 --- a/js/net/src/cache.test.ts +++ b/js/net/src/cache.test.ts @@ -4,6 +4,7 @@ import { Manual } from "@moq/clock/test"; import * as cache from "./cache.ts"; import { StreamCode, StreamError, TooFarBehind } from "./error.ts"; import { hooks, staleHole } from "./internal.ts"; +import { groupsOf } from "./mock.ts"; import { Timestamp } from "./time.ts"; import { Producer as TrackProducer } from "./track.ts"; @@ -185,7 +186,7 @@ test("a forgotten stale run is asked of a fill", async () => { const next = reader.recvGroup(); const asked: bigint[][] = []; for (;;) { - const fill = await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)]); + const fill = groupsOf(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)])); if (!fill) break; asked.push([fill.start, fill.end]); } diff --git a/js/net/src/fill.test.ts b/js/net/src/fill.test.ts index 61763a19ca7..34fe8f15e4b 100644 --- a/js/net/src/fill.test.ts +++ b/js/net/src/fill.test.ts @@ -9,11 +9,11 @@ import { rejectGroups } from "./fill.ts"; import type { Consumer as GroupConsumer } from "./group.ts"; import { hooks, staleHole } from "./internal.ts"; import * as Lite from "./lite/index.ts"; -import { createMockTransportPair } from "./mock.ts"; +import { createMockTransportPair, groupsOf, requestedGroups } from "./mock.ts"; import { Producer as OriginProducer } from "./origin.ts"; import * as Path from "./path.ts"; import { Timescale, Timestamp } from "./time.ts"; -import type { Fill, Producer, Requests, Subscription } from "./track.ts"; +import type { FillGroups, Producer, Requests, Subscription } from "./track.ts"; import { wireOf } from "./wire.ts"; const enc = new TextEncoder(); @@ -27,10 +27,10 @@ type Archive = Map; // Serve every fill from `archive` until the track closes, dropping what it lacks. Returns the // fills it took, so a test can count them. -function respond(requests: Requests, archive: Archive): Fill[] { - const fills: Fill[] = []; +function respond(requests: Requests, archive: Archive): FillGroups[] { + const fills: FillGroups[] = []; void (async () => { - for (let fill = await requests.requestedFill(); fill; fill = await requests.requestedFill()) { + for (let fill = await requestedGroups(requests); fill; fill = await requestedGroups(requests)) { fills.push(fill); serve(fill, archive); } @@ -38,7 +38,7 @@ function respond(requests: Requests, archive: Archive): Fill[] { return fills; } -function serve(fill: Fill, archive: Archive): void { +function serve(fill: FillGroups, archive: Archive): void { for (let sequence = fill.wanted(); sequence !== undefined; sequence = fill.wanted()) { const frames = archive.get(sequence); if (!frames) { @@ -129,8 +129,8 @@ test("fill: a fetch of a group about to be written asks the handler at once, and const { broadcast, track } = resumed(5n); const requests = track.requests(); const fetching = wireOf(broadcast).fetchGroup("video", 7n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect([fill.start, fill.end]).toEqual([7n, 8n]); expect(fill.wanted()).toBe(7n); @@ -162,8 +162,8 @@ test("fill: concurrent fetches of one group share one fill", async () => { const a = wireOf(broadcast).fetchGroup("video", 3n); const b = wireOf(broadcast).fetchGroup("video", 3n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect([fill.start, fill.end]).toEqual([3n, 4n]); // The second fetch joined it rather than queueing its own. await yieldNow(); @@ -185,8 +185,8 @@ test("fill: a fetch cancelled while its fill awaits a reply withdraws the fill", const controller = new AbortController(); const fetching = wireOf(broadcast).fetchGroup("video", 2n, { signal: controller.signal }); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect(await fill.wantedChanged()).toBe(2n); expect(fill.isWanted(2n)).toBe(true); @@ -198,7 +198,7 @@ test("fill: a fetch cancelled while its fill awaits a reply withdraws the fill", // Nothing reads it, so closing the withdrawn fill records nothing. fill.close(); const later = wireOf(broadcast).fetchGroup("video", 2n); - const refill = await requests.requestedFill(); + const refill = await requestedGroups(requests); expect(refill?.start).toBe(2n); if (refill) serve(refill, new Map([[2n, ["late"]]])); expect(await frames(await later)).toEqual(["late"]); @@ -213,8 +213,8 @@ test("fill: an answer aborted below the end does not hold the end open", async ( const { broadcast, track } = resumed(1n); const requests = track.requests(); const fetching = wireOf(broadcast).fetchGroup("video", 0n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); const group = fill.accept(0n); group.writeFrame({ payload: enc.encode("backfill"), timestamp: Timestamp.unscaled(group.sequence) }); if (parked) { @@ -255,8 +255,8 @@ async function failedAnswerHoldsTheEnd(error: Error) { expect((await ordered.nextGroup())?.sequence).toBe(0n); const requests = track.requests(); const fetching = wireOf(broadcast).fetchGroup("video", 1n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); fill.accept(1n).abort(error); fill.close(); await fetching.catch(() => undefined); @@ -298,7 +298,7 @@ test("fill: a group a lowered floor asks the feed for is not asked of a fill", a hooks.receiveGroup(track, { sequence: 1n, start: 0 }).finish(); expect((await live.recvGroup())?.sequence).toBe(1n); const requests = track.requests(); - const asked = requests.requestedFill(); + const asked = requestedGroups(requests); const history = track.subscribe({ ranges: [{ start: { absolute: 0n }, end: { absolute: 1n } }], @@ -325,8 +325,8 @@ test("fill: a failed answer is withheld from a subscribed reader that reads at o const reader = track.subscribe({ ranges: [{ start: { absolute: 0n } }], delay: { max: null } }); const requests = track.requests(); const fetching = wireOf(broadcast).fetchGroup("video", 1n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); fill.accept(1n).abort(new Error("archive failed")); const seen: unknown[] = []; for (let recv = hooks.tryRecvGroup(reader, dispositions); recv.kind !== "idle"; ) { @@ -349,8 +349,8 @@ test("fill: a held answer that fails keeps its frames and its failure", async () const track = broadcast.createTrack("video", { maxAge: null }); const requests = track.requests(); const fetching = wireOf(broadcast).fetchGroup("video", 1n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); const answer = fill.accept(1n); answer.writeFrame({ payload: enc.encode("fill 1"), timestamp: Timestamp.unscaled(answer.sequence) }); const group = await fetching; @@ -377,9 +377,9 @@ test("fill: an answer withheld after a probe judged it is asked again", async () }); const ordered = reader.ordered(); const first = ordered.nextGroup(); - const fill = await requests.requestedFill(); + const fill = await requestedGroups(requests); expect(fill && [fill.start, fill.end]).toEqual([0n, 4n]); - if (!fill) throw new Error("no fill"); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); fill.accept(0n).finish(); const answer = fill.accept(2n); answer.writeFrame({ payload: enc.encode("fill 2"), timestamp: Timestamp.unscaled(answer.sequence) }); @@ -392,7 +392,7 @@ test("fill: an answer withheld after a probe judged it is asked again", async () expect((await second)?.sequence).toBe(1n); const third = ordered.nextGroup(); - const again = await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)]); + const again = groupsOf(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)])); expect(again && [again.start, again.end]).toEqual([2n, 3n]); if (again) serve(again, new Map([[2n, ["again"]]])); expect((await third)?.sequence).toBe(2n); @@ -421,7 +421,7 @@ test("fill: a gap below a group that fails after a probe is asked", async () => group.abort(new StreamError(StreamCode.Cancel)); await yieldNow(); const next = ordered.nextGroup(); - const fill = await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)]); + const fill = groupsOf(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)])); expect(fill && [fill.start, fill.end]).toEqual([0n, 2n]); fill?.close(); @@ -443,7 +443,7 @@ test("fill: a gap the newest group rises over after a probe is asked", async () group.finish(); expect(reader.tryRecvGroup()?.sequence).toBe(5n); reader.tryRecvGroup(); - const fill = await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)]); + const fill = groupsOf(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)])); expect(fill && [fill.start, fill.end]).toEqual([3n, 5n]); fill?.close(); @@ -459,7 +459,7 @@ test("fill: a miss judged with no handler open is asked once one opens", async ( const reader = track.subscribe({ ranges: [{ start: { absolute: 0n } }], delay: { max: null } }); expect(reader.tryRecvGroup()?.sequence).toBe(2n); reader.tryRecvGroup(); - const out = await first.requestedFill(); + const out = await requestedGroups(first); expect(out && [out.start, out.end]).toEqual([0n, 2n]); first.close(); const group = track.createGroup(5n); @@ -469,7 +469,7 @@ test("fill: a miss judged with no handler open is asked once one opens", async ( const second = track.requests(); reader.tryRecvGroup(); - const fill = await Promise.race([second.requestedFill(), yieldNow().then(() => undefined)]); + const fill = groupsOf(await Promise.race([second.requestedFill(), yieldNow().then(() => undefined)])); expect(fill && [fill.start, fill.end]).toEqual([3n, 5n]); fill?.close(); @@ -547,7 +547,7 @@ test("fill: closing a fill drops what is still wanted, and closing the handler d const { broadcast, track } = resumed(5n); const requests = track.requests(); const a = wireOf(broadcast).fetchGroup("video", 1n); - const fill = await requests.requestedFill(); + const fill = await requestedGroups(requests); fill?.close(); await expect(a).rejects.toBeInstanceOf(NotFound); @@ -565,15 +565,15 @@ test("fill: a refusal fails the readers waiting now, and a later reader asks aga const { broadcast, track } = resumed(5n); const requests = track.requests(); const waiting = wireOf(broadcast).fetchGroup("video", 2n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); const refusal = new StreamError(StreamCode.Cancel, { message: "storage busy" }); fill.refuseGroups(2n, 3n, refusal); fill.close(); await expect(waiting).rejects.toBe(refusal); const later = wireOf(broadcast).fetchGroup("video", 2n); - const again = await requests.requestedFill(); + const again = await requestedGroups(requests); expect(again?.start).toBe(2n); if (again) serve(again, new Map([[2n, ["ok"]]])); expect(await frames(await later)).toEqual(["ok"]); @@ -586,8 +586,8 @@ test("fill: a group arriving after a refusal reaches the reader the refusal name const { broadcast, track } = resumed(5n); const requests = track.requests(); const waiting = wireOf(broadcast).fetchGroup("video", 2n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); fill.refuseGroups(2n, 3n, new StreamError(StreamCode.Cancel, { message: "storage busy" })); // Before the waiting fetch looks again. const group = track.createGroup(2n); @@ -608,8 +608,8 @@ test("fill: the track's skip of a run a reader's fill refused is what the reader delay: { max: null }, }); const first = reader.recvGroup(); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); fill.refuseGroups(0n, 2n, new StreamError(StreamCode.Cancel, { message: "storage busy" })); // The publisher declares the refused run never produced; its verdict wins, as in Rust. track.skipGroups(0n, 2n); @@ -626,8 +626,8 @@ test("fill: a fill names the most urgent priority and loosest budget among its r const requests = track.requests(); const low = track.subscribe({ ...history, priority: 1, delay: { max: Duration.millis(60_000) } }); void drain(low); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect([fill.start, fill.end]).toEqual([0n, 5n]); expect(fill.priority).toBe(1); expect(fill.maxDelay).toEqual(Duration.millis(60_000)); @@ -659,8 +659,8 @@ test("fill: a stale verdict leaves an outstanding fill owed", async () => { const requests = track.requests(); track.createGroup(3n).finish(); const fetching = wireOf(broadcast).fetchGroup("video", 2n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect(fill.wanted()).toBe(2n); hooks.dropTrackGroups(track, 2n, 3n, staleHole(500)); @@ -682,8 +682,8 @@ test("fill: a group arriving live answers the fill", async () => { const late = track.createGroup(3n); late.finish(); const fetching = wireOf(broadcast).fetchGroup("video", 1n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); // The producer writes it itself before the handler gets to it. const live = track.createGroup(1n); @@ -711,7 +711,7 @@ test("fill: an ordered reader stops waiting on an unanswered fill once its budge }); const next = reader.ordered().nextGroup(); // The handler takes the fill for the missing groups and never answers. - const fill = await requests.requestedFill(); + const fill = await requestedGroups(requests); expect([fill?.start, fill?.end]).toEqual([0n, 5n]); // Group 5 arrived when the reader asked, so its budget gives up the holes below a second on. @@ -740,7 +740,7 @@ test("fill: an arrival-order reader stops waiting on an unanswered fill once its }); expect((await reader.recvGroup())?.sequence).toBe(5n); const next = reader.recvGroup(); - const fill = await requests.requestedFill(); + const fill = await requestedGroups(requests); expect([fill?.start, fill?.end]).toEqual([0n, 5n]); // The fill never answers; the holes go past the budget, and the finished track ends the read. @@ -770,8 +770,8 @@ test("fill: a handler hears that a reader stopped wanting what it handed out pas order: "ascending", }); const next = reader.ordered().nextGroup(); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect(await fill.wantedChanged()).toBe(0n); const changed = fill.wantedChanged(); const unwanted = fill.unwanted(0n); @@ -818,9 +818,9 @@ test("fill: a bounded reader keeps waiting on a fresh fill once an older one goe expect((await reader.recvGroup())?.sequence).toBe(2n); expect((await reader.recvGroup())?.sequence).toBe(5n); const next = reader.recvGroup(); - const fills: Fill[] = []; + const fills: FillGroups[] = []; for (let i = 0; i < 2; i++) { - const fill = await requests.requestedFill(); + const fill = await requestedGroups(requests); if (fill) fills.push(fill); } expect(fills.map((fill) => [fill.start, fill.end])).toEqual([ @@ -853,8 +853,8 @@ test("fill: a reader joining a wider fill is owed only its own ranges", async () order: "ascending", }); void drain(wide); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect([fill.start, fill.end]).toEqual([0n, 10n]); // A narrower reader joins the same fill for 2 and 7 alone. @@ -898,8 +898,8 @@ test("fill: a group no reader reads any more stays withdrawn, and widening back const ranges = (start: bigint) => [{ start: { absolute: start }, end: { absolute: 5n } }]; const reader = track.subscribe({ ranges: ranges(0n), delay: { max: null }, order: "ascending" }); void drain(reader); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect([fill.start, fill.end]).toEqual([0n, 5n]); reader.update({ ranges: ranges(3n), delay: { max: null }, order: "ascending" }); @@ -910,7 +910,7 @@ test("fill: a group no reader reads any more stays withdrawn, and widening back reader.update({ ranges: ranges(0n), delay: { max: null }, order: "ascending" }); await yieldNow(); expect(fill.isWanted(1n)).toBe(false); - const again = await requests.requestedFill(); + const again = await requestedGroups(requests); expect([again?.start, again?.end]).toEqual([0n, 3n]); // Each narrowing and widening back asks anew, never spending the refill an eviction gets. @@ -918,7 +918,7 @@ test("fill: a group no reader reads any more stays withdrawn, and widening back reader.update({ ranges: ranges(0n), delay: { max: null }, order: "ascending" }); await yieldNow(); expect(again?.isWanted(1n)).toBe(false); - const third = await requests.requestedFill(); + const third = await requestedGroups(requests); expect([third?.start, third?.end]).toEqual([0n, 3n]); third?.close(); @@ -942,14 +942,14 @@ test("fill: a refusal under an old budget is asked afresh on each widening, neve const old = new StreamError(StreamCode.Old, { message: "old" }); // Each widening past the last refusal's budget asks a new fill for the run. for (const budget of [60_000, 120_000, 240_000]) { - const fill = await requests.requestedFill(); + const fill = await requestedGroups(requests); expect([fill?.start, fill?.end]).toEqual([0n, 5n]); - if (!fill) throw new Error("no fill"); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); rejectGroups(fill, 0n, 5n, old, { budget, everyone: false }); fill.close(); reader.update(terms(budget * 2)); } - expect(await requests.requestedFill()).toMatchObject({ start: 0n, end: 5n }); + expect(await requestedGroups(requests)).toMatchObject({ start: 0n, end: 5n }); reader.close(); requests.close(); @@ -962,8 +962,8 @@ test("fill: what a reader's sequence cursor passes, a fill no longer owes it", a const reader = track.subscribe(history); // A logical reader that already holds what lies below the floor raises its copy's cursor. expect(hooks.tryNextGroup(reader, 0n).kind).toBe("idle"); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect(fill.wanted()).toBe(0n); const changed = fill.wantedChanged(); await changed; @@ -988,8 +988,8 @@ test("fill: a filled group stays wanted only while a reader will still read it", const reader = track.subscribe(history); const next = reader.ordered().nextGroup(); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect(fill.wanted()).toBe(0n); const source = fill.accept(0n); source.writeFrame({ payload: enc.encode("g0"), timestamp: Timestamp.unscaled(source.sequence) }); @@ -1027,8 +1027,8 @@ test("fill: a reader changing only its order wakes the handler", async () => { const requests = track.requests(); const reader = track.subscribe(history); void drain(reader); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect(await fill.wantedChanged()).toBe(0n); const changed = fill.wantedChanged(); @@ -1052,7 +1052,7 @@ test("fill: a reader parked on a miss asks once a handler opens", async () => { // A handler opening wakes it to ask. const requests = track.requests(); - const fill = await requests.requestedFill(); + const fill = await requestedGroups(requests); expect([fill?.start, fill?.end]).toEqual([0n, 5n]); if (fill) serve(fill, new Map([[0n, ["old 0"]]])); expect((await next)?.sequence).toBe(0n); @@ -1066,8 +1066,8 @@ test("fill: a reader joins a fill still served after its handler's handle closed const { broadcast, track } = resumed(5n); const requests = track.requests(); const first = wireOf(broadcast).fetchGroup("video", 2n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); requests.close(); // The fill is still out, so a second fetch joins it rather than failing at once. @@ -1086,8 +1086,8 @@ test("fill: a group the track gives up elsewhere answers the fill", async () => const { broadcast, track } = resumed(5n); const requests = track.requests(); const fetching = wireOf(broadcast).fetchGroup("video", 2n); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect(fill.wanted()).toBe(2n); // An upstream SUBSCRIBE_DROP, say: the handler is no longer asked for it. @@ -1113,7 +1113,7 @@ test("fill: a stale run that does not settle the reader is still asked for", asy delay: { max: Duration.millis(500) }, }); void drain(reader); - const fill = await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)]); + const fill = groupsOf(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)])); expect(fill && [fill.start, fill.end]).toEqual([0n, 2n]); fill?.close(); @@ -1138,7 +1138,7 @@ test("fill: a stale run given up after a probe is asked on the next", async () = const asked = async () => { const fills: bigint[][] = []; for (;;) { - const fill = await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)]); + const fill = groupsOf(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)])); if (!fill) return fills; fills.push([fill.start, fill.end]); fill.close(); @@ -1164,8 +1164,8 @@ test("fill: a stale run that does not settle the reader leaves its own refusal r delay: { max: Duration.millis(500) }, }); const first = reader.recvGroup(); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); const refusal = new StreamError(StreamCode.Cancel, { message: "storage busy" }); fill.refuseGroups(0n, 2n, refusal); expect(hooks.tryDrop(reader)).toMatchObject({ kind: "drop", start: 0n, end: 2n, error: refusal }); @@ -1184,8 +1184,8 @@ test("fill: a stale run that does not settle the reader keeps its pending refusa delay: { max: Duration.millis(500) }, }); const first = reader.recvGroup(); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); const refusal = new StreamError(StreamCode.Cancel, { message: "storage busy" }); fill.refuseGroups(0n, 1n, refusal); fill.refuseGroups(3n, 4n, refusal); @@ -1231,7 +1231,7 @@ test("fill: a stale verdict settles a reader of every range it judged", async () expect(hooks.tryDrop(reader)).toMatchObject({ start: 0n, end: 2n, stale: 500 }); expect(hooks.tryDrop(reader)).toMatchObject({ start: 4n, end: 6n, stale: 500 }); expect(hooks.tryRecvGroup(reader, false)).toEqual({ kind: "done" }); - const fill = await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)]); + const fill = groupsOf(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)])); expect(fill).toBeUndefined(); reader.close(); @@ -1252,7 +1252,7 @@ test("fill: a stale verdict settles a partly overlapping reader only where it re expect(hooks.tryDrop(wider)).toMatchObject({ start: 1n, end: 2n, stale: 500 }); expect(hooks.tryDrop(wider)).toMatchObject({ start: 4n, end: 6n, stale: 500 }); expect(hooks.tryDrop(wider)).toBeUndefined(); - expect(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)])).toBeUndefined(); + expect(groupsOf(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)]))).toBeUndefined(); // Stops at 4, which the upstream judged against 5: its own newest, which no verdict convicts. // Both runs are unknown to it, and asked for. const narrower = subscribe([ @@ -1263,7 +1263,7 @@ test("fill: a stale verdict settles a partly overlapping reader only where it re expect(hooks.tryDrop(narrower)).toBeUndefined(); const asked: bigint[][] = []; for (;;) { - const fill = await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)]); + const fill = groupsOf(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)])); if (!fill) break; asked.push([fill.start, fill.end]); } @@ -1291,8 +1291,8 @@ test("fill: a cache-miss fetch of a dynamic track serves the one track the broad const group = track.createGroup(4n); group.finish(); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); serve(fill, new Map([[1n, ["one"]]])); expect(await frames(await fetching)).toEqual(["one"]); @@ -1300,7 +1300,7 @@ test("fill: a cache-miss fetch of a dynamic track serves the one track the broad const second = wireOf(broadcast).fetchGroup("video", 2n); const queued = await Promise.race([wireOf(broadcast).requested(), yieldNow().then(() => "none")]); expect(queued).toBe("none"); - const refill = await requests.requestedFill(); + const refill = await requestedGroups(requests); if (refill) serve(refill, new Map([[2n, ["two"]]])); expect(await frames(await second)).toEqual(["two"]); @@ -1327,9 +1327,9 @@ async function session(alpn: string) { live.writeFrame({ payload: enc.encode("live 3"), timestamp: Timestamp.fromMillis(3000) }); live.finish(); const requests = track.requests(); - const fills: Fill[] = []; + const fills: FillGroups[] = []; void (async () => { - for (let fill = await requests.requestedFill(); fill; fill = await requests.requestedFill()) { + for (let fill = await requestedGroups(requests); fill; fill = await requestedGroups(requests)) { fills.push(fill); for (let sequence = fill.wanted(); sequence !== undefined; sequence = fill.wanted()) { if (sequence === 1n) { @@ -1429,7 +1429,7 @@ test("fill: an OLD answer under the max age is held as stale until forgotten", a const asked = async () => { const fills: bigint[][] = []; for (;;) { - const fill = await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)]); + const fill = groupsOf(await Promise.race([requests.requestedFill(), yieldNow().then(() => undefined)])); if (!fill) return fills; fills.push([fill.start, fill.end]); fill.close(); @@ -1441,8 +1441,8 @@ test("fill: an OLD answer under the max age is held as stale until forgotten", a // A reader of the run alone, which the verdict does not settle, waits on the same fill. const bounded = track.subscribe({ ...terms, ranges: [{ start: { absolute: 0n }, end: { absolute: 3n } }] }); bounded.tryRecvGroup(); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect([fill.start, fill.end]).toEqual([0n, 3n]); const old = new StreamError(StreamCode.Old, { message: "old" }); rejectGroups(fill, 0n, 3n, old, { budget: 10_000, everyone: true }); @@ -1530,7 +1530,7 @@ test("fill: a refused head gives its group up, and the bounded reader moves past const { broadcast, track } = headless(); const requests = track.requests(); void (async () => { - for (let fill = await requests.requestedFill(); fill; fill = await requests.requestedFill()) { + for (let fill = await requestedGroups(requests); fill; fill = await requestedGroups(requests)) { fill.refuseGroups(fill.start, fill.end, new NotFound("no head")); fill.close(); } @@ -1556,7 +1556,7 @@ test.each([ const requests = track.requests(); let asked = 0; void (async () => { - for (let fill = await requests.requestedFill(); fill; fill = await requests.requestedFill()) { + for (let fill = await requestedGroups(requests); fill; fill = await requestedGroups(requests)) { // A reader asking again would loop forever: refuse past a few, so the test still ends. if (++asked > 3) fill.refuseGroups(fill.start, fill.end, new NotFound("asked again")); else if (end === "drop") fill.dropGroups(fill.start, fill.end); @@ -1581,7 +1581,7 @@ test("fill: a drop of a held group landing while its head is asked leaves the he const requests = track.requests(); const ordered = track.subscribe(twoAndThree).ordered(); const first = ordered.nextGroup(); - const fill = await requests.requestedFill(); + const fill = await requestedGroups(requests); if (!fill) throw new Error("no head asked"); expect([fill.start, fill.end]).toEqual([2n, 3n]); @@ -1650,7 +1650,7 @@ function lookups(requests: Requests, lookup: (time: number) => bigint | undefine const times: number[] = []; void (async () => { for (let fill = await requests.requestedFill(); fill; fill = await requests.requestedFill()) { - if (fill.time !== undefined) { + if (fill.kind === "lookup") { const ms = fill.time.asMillis(); times.push(ms / 1000); const answer = lookup(ms); @@ -1662,8 +1662,6 @@ function lookups(requests: Requests, lookup: (time: number) => bigint | undefine }); group.finish(); } - // A lookup owes no group. - expect(fill.wanted()).toBeUndefined(); fill.close(); continue; } @@ -1749,8 +1747,9 @@ test("fill: a lookup whose answer leaves the cache unstarted falls back to the g const next = reader.ordered().nextGroup(); // The handler answers with group 2 but never writes its first frame. const lookup = await requests.requestedFill(); - expect(lookup?.time?.asMillis()).toBe(2500); - lookup?.accept(2n); + if (lookup?.kind !== "lookup") throw new Error("no lookup"); + expect(lookup.time.asMillis()).toBe(2500); + lookup.accept(2n); await yieldNow(); // Idle past the cache window, so the next write evicts the unstarted answer, and group 5. @@ -1803,13 +1802,14 @@ test("fill: replacing the ranges withdraws a lookup still out", async () => { const reader = track.subscribe(fromTime(2500)); expect(reader.tryRecvGroup()).toBeUndefined(); const lookup = await requests.requestedFill(); - expect(lookup?.time?.asMillis()).toBe(2500); + if (lookup?.kind !== "lookup") throw new Error("no lookup"); + expect(lookup.time.asMillis()).toBe(2500); - // Its fill follows the readers waiting on it: the ascending one, until it leaves. - expect(lookup?.order).toBe("ascending"); + // It follows the readers waiting on it: the one with no age budget, until it leaves. + expect(lookup.maxDelay).toBeNull(); reader.update({ ranges: [{ start: { absolute: 5n } }], delay: { max: null }, order: "ascending" }); expect(reader.tryRecvGroup()?.sequence).toBe(5n); - expect(lookup?.order).toBe("descending"); + expect(lookup.maxDelay?.asMillis()).toBe(0); reader.close(); requests.close(); diff --git a/js/net/src/fill.ts b/js/net/src/fill.ts index a7c7442494c..0cc58483121 100644 --- a/js/net/src/fill.ts +++ b/js/net/src/fill.ts @@ -434,12 +434,12 @@ export class FillState { } /** The still-wanted runs of a fill, in ascending order. @internal */ -export let wantedRuns: (fill: Fill) => Run[]; +export let wantedRuns: (fill: FillGroups) => Run[]; /** * Wait for a change to the groups or readers of a fill, which a lost {@link race} releases. * @internal */ -export let fillChanged: (fill: Fill) => GetPromise; +export let fillChanged: (fill: FillGroups) => GetPromise; /** * The budget in milliseconds an OLD answer was judged under, and whether that is the publisher's * max age, which binds every reader, rather than the request's own budget. @@ -477,12 +477,33 @@ export interface Lookup { * refusal answers only `[start, end)`, for now. Mirrors the Rust `Fill::reject_groups`. * @internal */ -export let rejectGroups: (fill: Fill, start: bigint, end: bigint, error: Error, judged: Judged | undefined) => void; +export let rejectGroups: ( + fill: FillGroups, + start: bigint, + end: bigint, + error: Error, + judged: Judged | undefined, +) => void; // Constructs the public handles from within this module; assigned in their static blocks. -let makeFill: (state: FillState, pending: Pending) => Fill; +let makeGroups: (state: FillState, pending: Pending) => FillGroups; +let makeLookup: (state: FillState, pending: Pending, time: Timestamp) => FillLookup; let makeRequests: (state: FillState) => Requests; +// The most urgent delivery priority among the readers waiting on `pending` now. +function priorityOf(pending: Pending): number { + let priority: number | undefined; + for (const asker of pending.askers) priority = Math.max(priority ?? asker.priority(), asker.priority()); + return priority ?? 0; +} + +// The most tolerant age budget among the readers waiting on `pending` now, or `null` for none. +function maxDelayOf(pending: Pending): Duration | null { + let max = 0; + for (const asker of pending.askers) max = Math.max(max, asker.maxDelay()); + return max < NO_MAX_DELAY ? Duration.millis(max) : null; +} + /** * A {@link Requests} handle on `state`, for a producer's `requests()`. * @@ -522,14 +543,15 @@ export class Requests { } /** - * Wait until readers miss a run of groups, returning the {@link Fill} to serve. Resolves - * `undefined` once the track closes with nothing queued, or this handle closes, even while - * it waits. + * Wait until readers miss a run of groups or a time, returning the {@link Fill} to serve: + * a {@link FillGroups} or a {@link FillLookup}, told apart by `kind`. Resolves `undefined` + * once the track closes with nothing queued, or this handle closes, even while it waits. */ async requestedFill(): Promise { const pending = await this.#state.next(this.#closed); if (!pending) return undefined; - return makeFill(this.#state, pending); + if (pending.time !== undefined) return makeLookup(this.#state, pending, pending.time); + return makeGroups(this.#state, pending); } /** @@ -547,9 +569,18 @@ export class Requests { } } +/** + * What a track's readers miss, from {@link Requests.requestedFill}: a {@link FillGroups} run of + * groups to serve, or a {@link FillLookup} of the group containing a time. Mirrors the Rust + * `track::Fill`; tell them apart by `kind`. + * + * @public + */ +export type Fill = FillGroups | FillLookup; + /** * A run of groups readers miss, from {@link Requests.requestedFill}: `start` up to the exclusive - * `end`. Mirrors the Rust `track::Fill`. + * `end`. Mirrors the Rust `track::FillGroups`. * * Its {@link priority}, {@link maxDelay}, and {@link order} follow its readers as they change, so * read them as each group is served. Call {@link accept} for each group the source has, writing @@ -563,23 +594,13 @@ export class Requests { * * @public */ -export class Fill { +export class FillGroups { + /** Tells it apart from a {@link FillLookup}. */ + readonly kind = "groups"; /** The first group to fill. */ readonly start: bigint; /** The exclusive end group. */ readonly end: bigint; - /** - * The presentation time a reader's range starts at that no group the cache holds resolves, - * so this fill looks it up: {@link accept} the group containing it, the newest one starting - * at or before it, or the oldest group when every group starts after it. The reader's range - * then starts there, once that group's first frame is written. Mirrors the Rust `Fill::time`. - * - * A lookup owes no group, so {@link wanted} is `undefined` and {@link isWanted} false - * throughout; it waits only on its first accept. Closed unanswered, as a handler that can't - * resolve times does, the reader's range reaches back to the oldest group the cache holds. - * `undefined` for a fill of groups. - */ - readonly time?: Timestamp; #state: FillState; #pending: Pending; @@ -591,11 +612,10 @@ export class Fill { this.#pending = pending; this.start = pending.start; this.end = pending.end; - this.time = pending.time; } static { - makeFill = (state, pending) => new Fill(state, pending); + makeGroups = (state, pending) => new FillGroups(state, pending); wantedRuns = (fill) => fill.#pending.owed(); fillChanged = (fill) => Signal.race(fill.#pending.revision); rejectGroups = (fill, start, end, error, judged) => { @@ -611,9 +631,7 @@ export class Fill { /** The most urgent delivery priority among the readers waiting on it now. */ get priority(): number { - let priority: number | undefined; - for (const asker of this.#pending.askers) priority = Math.max(priority ?? asker.priority(), asker.priority()); - return priority ?? 0; + return priorityOf(this.#pending); } /** @@ -621,9 +639,7 @@ export class Fill { * publisher's {@link Info.maxAge} alone bounds it. Each reader still enforces its own. */ get maxDelay(): Duration | null { - let max = 0; - for (const asker of this.#pending.askers) max = Math.max(max, asker.maxDelay()); - return max < NO_MAX_DELAY ? Duration.millis(max) : null; + return maxDelayOf(this.#pending); } /** Which end to fill first now: `"descending"`, newest first, if any reader asks it. */ @@ -711,6 +727,74 @@ export class Fill { fillOps.settle(this.#state, this.#pending); } + /** Closes the fill; see {@link close}. */ + [Symbol.dispose](): void { + this.close(); + } +} + +/** + * A reader's range starts at a {@link time} no group the cache holds resolves, so it asks the + * source which group contains it: from {@link Requests.requestedFill}. Mirrors the Rust + * `track::FillLookup`. + * + * {@link accept} the group containing the time: the newest one starting at or before it, or the + * oldest group when every group starts after it. The reader's range then starts there, once that + * group's first frame is written. A lookup owes no group, so it waits only on its first accept. + * Closed unanswered, as a handler that can't resolve times does, the reader's range reaches back + * to the oldest group the cache holds. + * + * @public + */ +export class FillLookup { + /** Tells it apart from a {@link FillGroups}. */ + readonly kind = "lookup"; + /** The presentation time to look up. */ + readonly time: Timestamp; + + #state: FillState; + #pending: Pending; + + private constructor(state: FillState, pending: Pending, time: Timestamp) { + this.#state = state; + this.#pending = pending; + this.time = time; + } + + static { + makeLookup = (state, pending, time) => new FillLookup(state, pending, time); + } + + /** The most urgent delivery priority among the readers waiting on it now. */ + get priority(): number { + return priorityOf(this.#pending); + } + + /** + * The most tolerant age budget among the readers waiting on it now, or `null` for none: the + * publisher's {@link Info.maxAge} alone bounds it. Each reader still enforces its own. + */ + get maxDelay(): Duration | null { + return maxDelayOf(this.#pending); + } + + /** + * Insert group `sequence`, the one containing {@link time}, into the track's cache, answering + * the lookup, and return the producer to write its frames into. `info` commits the track's + * {@link Info} if it has none yet. Throws a `RangeError` at or past the live edge the lookup + * was asked below, and an error if the group is cached whole or the track is closed. + */ + accept(sequence: bigint, info?: Info): GroupProducer { + checkSequence(sequence); + return fillOps.accept(this.#state, this.#pending, sequence, info); + } + + /** Done serving: unanswered, the reader's range falls back to the groups cached. Idempotent. */ + close(): void { + fillOps.settle(this.#state, this.#pending); + } + + /** Closes the lookup; see {@link close}. */ [Symbol.dispose](): void { this.close(); } diff --git a/js/net/src/ietf/range.ts b/js/net/src/ietf/range.ts index 77e0f4ae7e7..58e6304b070 100644 --- a/js/net/src/ietf/range.ts +++ b/js/net/src/ietf/range.ts @@ -1,6 +1,6 @@ import { race, Signal } from "@moq/signals"; import { error, NotFound, ProtocolViolation, StreamCode, StreamError } from "../error.ts"; -import { type Fill, fillChanged, wantedRuns } from "../fill.ts"; +import { type FillGroups, fillChanged, wantedRuns } from "../fill.ts"; import type * as group from "../group.ts"; import { receiveFrame, skipPayload } from "../payload.ts"; import type { Cursor, Reader } from "../stream.ts"; @@ -11,7 +11,7 @@ import { decodeFetchObject, EndOfRange } from "./object.ts"; /** The groups one standalone FETCH writes, sharing the joining FETCH's object and payload decoder. @internal */ export class RangeFetch { - readonly fill: Fill; + readonly fill: FillGroups; readonly first: bigint; readonly last: bigint; readonly bound?: number; @@ -27,7 +27,7 @@ export class RangeFetch { #finished = false; constructor(options: { - fill: Fill; + fill: FillGroups; first: bigint; track: track.Producer; timescale?: Timescale; diff --git a/js/net/src/ietf/subscriber.ts b/js/net/src/ietf/subscriber.ts index 2b898d488b8..4d9fe2471fc 100644 --- a/js/net/src/ietf/subscriber.ts +++ b/js/net/src/ietf/subscriber.ts @@ -20,7 +20,7 @@ import { sessionCause, unauthorized, } from "../error.ts"; -import { type Fill, fillChanged, type Requests, wantedRuns } from "../fill.ts"; +import { type FillGroups, fillChanged, type Requests, wantedRuns } from "../fill.ts"; import type * as netGroup from "../group.ts"; import { Cost, routesEqual, UNKNOWN_HOP, type WireRoute } from "../hop.ts"; import { finalSequence, hiddenBelow, hooks, maxDelayOf, scopeCaptures, scopeHead, scopeOverlaps } from "../internal.ts"; @@ -1150,6 +1150,11 @@ export class Subscriber { for (;;) { const fill = await untilAborted(requests.requestedFill(), signal); if (!fill) break; + // FETCH asks by group alone, so a lookup goes unanswered and its reader falls back. + if (fill.kind === "lookup") { + fill.close(); + continue; + } const run = async () => { try { // The join may already bring a miss in this run. Let it answer first instead @@ -1191,7 +1196,7 @@ export class Subscriber { async #runRangeFetch( broadcast: Path.Valid, producer: track.Producer, - options: { fill: Fill; start: bigint; end: bigint; signal: AbortSignal }, + options: { fill: FillGroups; start: bigint; end: bigint; signal: AbortSignal }, ) { const { fill, start, end: until, signal } = options; const version = this.#session.version; diff --git a/js/net/src/lite/copy_fill.test.ts b/js/net/src/lite/copy_fill.test.ts index 38dede13033..f0208699184 100644 --- a/js/net/src/lite/copy_fill.test.ts +++ b/js/net/src/lite/copy_fill.test.ts @@ -11,12 +11,12 @@ import { accept as acceptSession, connect as connectSession } from "../connectio import { StreamCode, StreamError } from "../error.ts"; import type { Consumer as GroupConsumer } from "../group.ts"; import { hooks } from "../internal.ts"; -import { createMockTransportPair } from "../mock.ts"; +import { createMockTransportPair, requestedGroups } from "../mock.ts"; import { lines } from "../open.ts"; import { Producer as OriginProducer } from "../origin.ts"; import * as Path from "../path.ts"; import { Timescale, Timestamp } from "../time.ts"; -import type { Fill, Producer, Subscriber, Subscription } from "../track.ts"; +import type { FillGroups, Producer, Subscriber, Subscription } from "../track.ts"; import { wireOf } from "../wire.ts"; import * as Lite from "./index.ts"; import { Publisher as LitePublisher } from "./publisher.ts"; @@ -40,7 +40,7 @@ async function peers(alpn: string) { const track = broadcast.createTrack("video", { timescale: Timescale.MILLI, maxAge: null }); const requests = track.requests(); void (async () => { - for (let fill = await requests.requestedFill(); fill; fill = await requests.requestedFill()) { + for (let fill = await requestedGroups(requests); fill; fill = await requestedGroups(requests)) { for (let sequence = fill.wanted(); sequence !== undefined; sequence = fill.wanted()) { if (sequence === 1n) { fill.dropGroups(1n, 2n); @@ -255,10 +255,10 @@ test("copy fill: a filled group stops downloading once every reader left or pass write(track.createGroup(1n), 1n, "live"); // The archive answers group 0 with one frame and keeps it open. const requests = track.requests(); - const fills: Fill[] = []; + const fills: FillGroups[] = []; const archived = (async () => { - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); fills.push(fill); const group = fill.accept(0n); group.writeFrame({ payload: enc.encode("old 0"), timestamp: Timestamp.fromMillis(0) }); @@ -322,10 +322,10 @@ test("copy fill: a filled group nobody holds any more stops downloading", async write(track.createGroup(1n), 1n, "live"); // The archive answers group 0 with one frame and never finishes it. const requests = track.requests(); - const fills: Fill[] = []; + const fills: FillGroups[] = []; const archived = (async () => { - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); fills.push(fill); const group = fill.accept(0n); group.writeFrame({ payload: enc.encode("old 0"), timestamp: Timestamp.fromMillis(0) }); @@ -393,10 +393,10 @@ test("copy fill: a yielded group its subscription's drop names ends", async () = // The archive answers group 0 with one frame and keeps it open, so its stream is still open, and // group 1 whole. const requests = track.requests(); - const fills: Fill[] = []; + const fills: FillGroups[] = []; const archived = (async () => { - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); fills.push(fill); const group = fill.accept(0n); group.writeFrame({ payload: enc.encode("old 0"), timestamp: Timestamp.fromMillis(0) }); @@ -499,7 +499,7 @@ test.each([Lite.ALPN_05, Lite.ALPN_06, Lite.ALPN_07_WIP])( let archived = false; const requests = track.requests(); void (async () => { - for (let fill = await requests.requestedFill(); fill; fill = await requests.requestedFill()) { + for (let fill = await requestedGroups(requests); fill; fill = await requestedGroups(requests)) { for (let sequence = fill.wanted(); sequence !== undefined; sequence = fill.wanted()) { if (sequence !== 2n || !archived) { fill.refuseGroups(sequence, sequence + 1n, new StreamError(StreamCode.NotFound)); diff --git a/js/net/src/lite/fills.test.ts b/js/net/src/lite/fills.test.ts index d5e50374ff3..f6e589ad5d5 100644 --- a/js/net/src/lite/fills.test.ts +++ b/js/net/src/lite/fills.test.ts @@ -6,16 +6,17 @@ import { Signal } from "@moq/signals"; import { Producer as BroadcastProducer } from "../broadcast.ts"; import { StreamCode, StreamError } from "../error.ts"; import { hooks, type Run } from "../internal.ts"; +import { requestedGroups } from "../mock.ts"; import { Tail } from "../tail.ts"; import { Timestamp } from "../time.ts"; -import type { Fill, Producer } from "../track.ts"; +import type { FillGroups, Producer } from "../track.ts"; import { dropped, passing, RangeFills, type RecoveryHandle, type Refused } from "./fills.ts"; const enc = new TextEncoder(); // A copy whose first group is 4, read from group 0 with no budget, and the fill for 0 to 4 its // reader asks of it. -async function missing(): Promise<{ broadcast: BroadcastProducer; track: Producer; fill: Fill; close(): void }> { +async function missing(): Promise<{ broadcast: BroadcastProducer; track: Producer; fill: FillGroups; close(): void }> { const broadcast = new BroadcastProducer(); const track = broadcast.createTrack("video", { maxAge: null }); const group = track.createGroup(4n); @@ -28,8 +29,8 @@ async function missing(): Promise<{ broadcast: BroadcastProducer; track: Produce .ordered() .nextGroup() .catch(() => undefined); - const fill = await requests.requestedFill(); - if (!fill) throw new Error("no fill"); + const fill = await requestedGroups(requests); + if (fill?.kind !== "groups") throw new Error("no fill of groups"); expect([fill.start, fill.end]).toEqual([0n, 4n]); return { broadcast, @@ -288,7 +289,7 @@ test("range fills: a range start past the asked groups refuses only the fills ow .ordered() .nextGroup() .catch(() => undefined); - const again = await requests.requestedFill(); + const again = await requestedGroups(requests); expect(again?.wanted()).toBe(0n); again?.close(); @@ -345,8 +346,8 @@ test("range fills: a passing refusal ends with the fills it answered", async () .ordered() .nextGroup() .catch(() => undefined); - const again = await requests.requestedFill(); - if (!again) throw new Error("no fill"); + const again = await requestedGroups(requests); + if (again?.kind !== "groups") throw new Error("no fill of groups"); fills.push(again); fills.poll(tail, true); expect(again.wanted()).toBe(1n); @@ -417,8 +418,8 @@ test("range fills: a recovery's refusal is taken once", async () => { .ordered() .nextGroup() .catch(() => undefined); - const again = await requests.requestedFill(); - if (!again) throw new Error("no fill"); + const again = await requestedGroups(requests); + if (again?.kind !== "groups") throw new Error("no fill of groups"); fills.push(again); fills.poll(tail, true); expect(again.wanted()).toBe(1n); @@ -465,8 +466,8 @@ test("range fills: an older recovery ending keeps a newer one's coverage", async .ordered() .nextGroup() .catch(() => undefined); - const again = await requests.requestedFill(); - if (!again) throw new Error("no fill"); + const again = await requestedGroups(requests); + if (again?.kind !== "groups") throw new Error("no fill of groups"); fills.push(again); fills.poll(tail, true); expect(opened.map((entry) => entry.groups)).toEqual([ diff --git a/js/net/src/lite/fills.ts b/js/net/src/lite/fills.ts index 0848c06e1ae..8712d20fca7 100644 --- a/js/net/src/lite/fills.ts +++ b/js/net/src/lite/fills.ts @@ -115,7 +115,7 @@ export interface FillAsk { export class RangeFills { readonly #copy: track.Producer; readonly #recover: (groups: Run, priority: number) => RecoveryHandle; - #held: track.Fill[] = []; + #held: track.FillGroups[] = []; /** What the subscription asks for the fills now. */ ask: FillAsk = { groups: [], priority: NO_PRIORITY }; // Bumped on every input `poll` reads that no other signal reports. @@ -153,7 +153,7 @@ export class RangeFills { return this.#recoveries.size > 0; } - push(fill: track.Fill): void { + push(fill: track.FillGroups): void { this.#held.push(fill); this.#bump(); } @@ -252,7 +252,7 @@ export class RangeFills { const ask: FillAsk = { groups: [], priority: NO_PRIORITY }; // Every run a held fill still owes, recovered or not. const owed: Run[] = []; - const held: track.Fill[] = []; + const held: track.FillGroups[] = []; // Not asked of the subscription: a run being recovered waits on its own, and a group already // refused is answered once its fill reaches it. const waiting = [...this.#recovering]; @@ -414,14 +414,14 @@ export class RangeFills { } // The run `fill` owes first in its order, extending from the group it owes first. -function nextRun(fill: track.Fill): Run | undefined { +function nextRun(fill: track.FillGroups): Run | undefined { const owed = wantedRuns(fill); return fill.order === "ascending" ? owed[0] : owed.at(-1); } // Answer `[start, end)` of `fill`: a lost group is named dropped, as a FETCH's miss is, and // anything else is refused for now, recorded nowhere. -function answer(refusal: Refusal, fill: track.Fill, start: bigint, end: bigint): void { +function answer(refusal: Refusal, fill: track.FillGroups, start: bigint, end: bigint): void { if (refusal.lost) fill.dropGroups(start, end); else fill.refuseGroups(start, end, refusal.error); } diff --git a/js/net/src/lite/publisher.test.ts b/js/net/src/lite/publisher.test.ts index a4f33c9dc93..acc963637cd 100644 --- a/js/net/src/lite/publisher.test.ts +++ b/js/net/src/lite/publisher.test.ts @@ -239,7 +239,7 @@ async function subscribeEnd( // arrives late opens no stream at all, so there is nothing firmer to wait on. await clock.advance(Duration.ZERO); } - if (error) track.finishAt({ group: BigInt(Math.max(-1, ...sequences) + 1), frame: 0 }, error); + if (error) track.fail(error); else track.finish(); track.close(); @@ -2484,7 +2484,9 @@ test("lite draft-06: an errored end is not declared early", async () => { const first = track.createGroup(0n); first.writeFrame(textFrame("hello")); first.finish(); - track.finishAt({ group: 2n, frame: 0 }, new StreamError(StreamCode(71))); + // An errored end past the live edge, which only a received copy forwards: group 1 is still + // to come below it. + hooks.endTrack(track, { group: 2n, frame: 0 }, new StreamError(StreamCode(71))); const start = await decodeSubscribeResponse(client.reader, Version.DRAFT_06); expect("start" in start).toBe(true); @@ -2506,7 +2508,7 @@ test("lite draft-06: a subscription capped short of an errored end gets its boun const sub = await servedSubscription({ version: Version.DRAFT_06, startGroup: 0n, endGroup: 1n }); try { for (const sequence of [0n, 1n, 2n, 3n]) sub.serve(sequence); - sub.track.finishAt({ group: 4n, frame: 0 }, new StreamError(StreamCode(71))); + sub.track.fail(new StreamError(StreamCode(71))); for (;;) { const resp = await decodeSubscribeResponse(sub.client.reader, Version.DRAFT_06); if (!("finish" in resp)) continue; diff --git a/js/net/src/lite/subscriber.ts b/js/net/src/lite/subscriber.ts index 87c757209da..0f328053898 100644 --- a/js/net/src/lite/subscriber.ts +++ b/js/net/src/lite/subscriber.ts @@ -2773,6 +2773,11 @@ export class Subscriber { const maxAge = (await producer.info().catch(() => undefined))?.maxAge; const framing = { compress: entry.compress, timescale: entry.timescale, maxAge }; for (let fill = await requests.requestedFill(); fill; fill = await requests.requestedFill()) { + // The wire fetches by group alone, so a lookup goes unanswered and its reader falls back. + if (fill.kind === "lookup") { + fill.close(); + continue; + } // One group is what FETCH carries; more go through the subscription. if (fills && fill.end - fill.start > 1n) { fills.push(fill); @@ -2807,7 +2812,7 @@ export class Subscriber { consumed: Consumed, producer: track.Producer, framing: Framing, - fill: track.Fill, + fill: track.FillGroups, ): Promise { try { let last: bigint | undefined; @@ -3070,7 +3075,7 @@ export class Subscriber { consumed: Consumed, name: string, framing: Framing, - fill: track.Fill, + fill: track.FillGroups, sequence: bigint, ): Promise { const cancel = new AbortController(); @@ -3124,7 +3129,7 @@ export class Subscriber { consumed: Consumed, name: string, framing: Framing, - fill: track.Fill, + fill: track.FillGroups, sequence: bigint, cancel: AbortSignal, ): Promise { diff --git a/js/net/src/mock.ts b/js/net/src/mock.ts index f92a7fe3c61..5071711c0bb 100644 --- a/js/net/src/mock.ts +++ b/js/net/src/mock.ts @@ -9,10 +9,22 @@ import { Manual } from "@moq/clock/test"; import type { Getter } from "@moq/signals"; import { Consumer as BroadcastConsumer } from "./broadcast.ts"; import type { TransportStats } from "./connection/stats.ts"; +import type { Fill, FillGroups, Requests } from "./fill.ts"; import type { Frame } from "./group.ts"; import type { SendStream } from "./stream.ts"; import { Timestamp } from "./time.ts"; +/** `fill` as a run of groups, for a test that expects no lookup: a lookup throws. */ +export function groupsOf(fill: Fill | undefined): FillGroups | undefined { + if (fill?.kind === "lookup") throw new Error("expected a fill of groups, got a lookup"); + return fill; +} + +/** The next fill `requests` hands out, for a test that expects only runs of groups. */ +export async function requestedGroups(requests: Requests): Promise { + return groupsOf(await requests.requestedFill()); +} + /** A UTF-8 text frame stamped `timestamp` (now by default), for a test writing to a timed track. */ export function textFrame(text: string, timestamp = Timestamp.now()): Frame { return { payload: new TextEncoder().encode(text), timestamp }; diff --git a/js/net/src/resume.test.ts b/js/net/src/resume.test.ts index 0d3531f56bc..1fa2ed9acde 100644 --- a/js/net/src/resume.test.ts +++ b/js/net/src/resume.test.ts @@ -11,6 +11,7 @@ import { Version as IetfVersion } from "./ietf/version.ts"; import * as Instance from "./instance.ts"; import { hooks, staleHole } from "./internal.ts"; import type { Lister } from "./listing.ts"; +import { requestedGroups } from "./mock.ts"; import { Producer } from "./origin.ts"; import * as Path from "./path.ts"; import { Front, routeFailed } from "./resume.ts"; @@ -285,9 +286,9 @@ test("a backfill waits on a fill the finished route still owes", async () => { const handles = sources.map((source) => source.consume()); const [ta, tb] = sources.map(copy); const requests = tb.producer.requests(); - const fills: track.Fill[] = []; + const fills: track.FillGroups[] = []; void (async () => { - for (let fill = await requests.requestedFill(); fill; fill = await requests.requestedFill()) fills.push(fill); + for (let fill = await requestedGroups(requests); fill; fill = await requestedGroups(requests)) fills.push(fill); })(); tb.write(6n); tb.producer.finish(); @@ -3237,7 +3238,7 @@ test("a routed track's errored end outlives the copy that declared it", async () const sub = front.consumer.track("seq").subscribe(); ta.write(0n); const failed = new StreamError(StreamCode(71)); - ta.producer.finishAt({ group: 1n, frame: 0 }, failed); + ta.producer.fail(failed); const group = await sub.recvGroup(); expect(group?.sequence).toBe(0n); group?.close(); @@ -3290,7 +3291,8 @@ test("an end a replaced copy declared holds across a swap", async () => { expect(await sub.finished()).toEqual({ group: 2n, frame: 0 }); // A copy declaring another end leaves the first one, and its error with it. - tb.producer.finishAt({ group: 3n, frame: 0 }, new StreamError(StreamCode(70), { message: "other" })); + // Past its live edge, which only a received copy declares with an error. + hooks.endTrack(tb.producer, { group: 3n, frame: 0 }, new StreamError(StreamCode(70), { message: "other" })); await settle(); expect(sub.closed.peek()).not.toBeInstanceOf(Error); expect(hooks.subscriberEnd(sub)).toEqual({ group: 2n, frame: 0 }); diff --git a/js/net/src/track.test.ts b/js/net/src/track.test.ts index e6be84d4f0f..1169da8915a 100644 --- a/js/net/src/track.test.ts +++ b/js/net/src/track.test.ts @@ -4948,9 +4948,9 @@ test("reading a shed frame head requests refresh", async () => { producer.close(); }); -// An end declared with an error keeps the history below it: a reader gets every group, then the +// A track ended by `fail` keeps the history below its end: a reader gets every group, then the // error, even one arriving after the producer closed. -test("an errored end keeps its history", async () => { +test("a failed track keeps its history", async () => { const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI, maxAge: null }); for (const sequence of [0n, 1n]) { const group = producer.createGroup(sequence); @@ -4959,7 +4959,7 @@ test("an errored end keeps its history", async () => { group.finish(); } const failed = new StreamError(StreamCode(71)); - producer.finishAt({ group: 2n, frame: 0 }, failed); + producer.fail(failed); producer.close(); expect(producer.closed.peek()).toBe(failed); @@ -4985,6 +4985,40 @@ test("an errored end keeps its history", async () => { expect(() => polledOrdered.tryNextGroup()).toThrow(failed); }); +// `fail` ends where `finish` would, after the highest group written, so a late group below it is +// still taken. Like `finish`, it leaves whatever outcome was already given. +test("fail ends at the live edge and leaves an end already given", async () => { + const failed = new StreamError(StreamCode(71)); + const producer = new TrackProducer("test").accept({ timescale: Timescale.MILLI, maxAge: null }); + const latest = producer.createGroup(2n); + latest.writeFrame(textFrame("c", Timestamp.fromMillis(2))); + latest.finish(); + producer.fail(failed); + expect(() => producer.createGroup(3n)).toThrow(); + const late = producer.createGroup(1n); + late.writeFrame(textFrame("b", Timestamp.fromMillis(1))); + late.finish(); + const sub = producer.subscribe({ ranges: [{ start: { absolute: 1n } }], delay: { max: Duration.millis(30_000) } }); + expect((await sub.recvGroup())?.sequence).toBe(1n); + expect((await sub.recvGroup())?.sequence).toBe(2n); + await expect(sub.recvGroup()).rejects.toBe(failed); + producer.close(); + + // An end already declared stands: the track still finishes cleanly. + const finished = new TrackProducer("finished").accept({ timescale: Timescale.MILLI, maxAge: null }); + finished.finish(); + finished.fail(failed); + finished.close(); + expect(finished.closed.peek()).toBeNull(); + + // So does an abort. + const aborted = new TrackProducer("aborted").accept({ timescale: Timescale.MILLI, maxAge: null }); + const cause = new StreamError(StreamCode(70)); + aborted.abort(cause); + aborted.fail(failed); + expect(aborted.closed.peek()).toBe(cause); +}); + // Creating a group says nothing about the gap it leaves: groups may be created out of order. An // append says the producer will not go back, so it skips every hole below it that was never // produced, replacing a drop already given and reported. A received copy's groups arrive in any diff --git a/js/net/src/track.ts b/js/net/src/track.ts index 0ce09c6b669..23719c442d4 100644 --- a/js/net/src/track.ts +++ b/js/net/src/track.ts @@ -70,7 +70,7 @@ import { } from "./window.ts"; import { type Broadcast as BroadcastWire, registerTrackConsumer } from "./wire.ts"; -export { Fill, Requests } from "./fill.ts"; +export { type Fill, FillGroups, FillLookup, Requests } from "./fill.ts"; // The group a non-blocking read takes, skipping drops and throwing the track's error; // `undefined` when nothing is deliverable now. @@ -751,9 +751,9 @@ class TrackState { // One past the highest group received, including evicted content. received = new Signal(0n); /** - * The declared end, by {@link Producer.finishAt} or a clean close at the head of the - * sequence after the highest produced, with the error the track ended with there. One - * value, so a wake on it sees both. Mirrors the Rust `End`. + * The declared end, by {@link Producer.finishAt}, {@link Producer.fail}, or a clean close at + * the head of the sequence after the highest produced, with the error the track ended with + * there. One value, so a wake on it sees both. Mirrors the Rust `End`. */ end = new Signal(undefined); // A wire subscription's pending tail still owes a group below the end, so reaching the @@ -2205,15 +2205,13 @@ export class Producer { * group, independently of closure. Throws if the track is closed, already has an end, or * `end` would orphan a group or frame already produced. * - * With an `error`, the track ended that way rather than cleanly, yet keeps its history, unlike - * {@link abort}: readers still get every group below the end, and a reader reaching the end - * gets the error instead of the end of stream. + * Always a clean end; {@link fail} ends the track in error. */ - finishAt(end: Position, error?: Error): void { + finishAt(end: Position): void { if (this.#state.closed.peek() !== undefined) throw new Error("track is closed"); const declared = this.#state.end.peek()?.at; if (declared !== undefined) throw new Error(`track already ends at ${declared.group}/${declared.frame}`); - this.#declareEnd(end, error, false); + this.#declareEnd(end, undefined, false); } // The wire's end: repeating it is a no-op, and a mid-group end may refine the group @@ -2376,6 +2374,21 @@ export class Producer { return this; } + /** + * End the track with `error` after the highest sequence written, the end {@link finish} + * declares, returning it as {@link Finished}. Mirrors the Rust `fail`. + * + * Unlike {@link abort}, the track keeps its history: readers still get every group below the + * end, and a reader reaching the end gets `error` instead of the end of stream. Like + * {@link finish}, a no-op once an end is declared or the track closed: the outcome already + * given stands, so a cleanup path can fail whatever the track's state. + */ + fail(error: Error): Finished { + if (this.#state.end.peek() === undefined && this.#state.closed.peek() === undefined) + this.#declareEnd({ group: this.#received, frame: 0 }, error, false); + return this; + } + /** * Abort the track and every subscriber, mirroring the error to their open groups. Terminal * and idempotent. @@ -2392,8 +2405,8 @@ export class Producer { /** * Release this producer, like dropping the last Rust producer. Idempotent. * - * With an end declared ({@link finish} or {@link finishAt}), the track ends there and its - * subscribers drain to it. Without one, the track aborts: nothing finished it. + * With an end declared ({@link finish}, {@link finishAt}, or {@link fail}), the track ends + * there and its subscribers drain to it. Without one, the track aborts: nothing finished it. */ close(): void { if (this.#state.end.peek() !== undefined) this.#close(undefined); diff --git a/rs/hang/examples/video.rs b/rs/hang/examples/video.rs index f037c7f5958..bf5f860cd2c 100644 --- a/rs/hang/examples/video.rs +++ b/rs/hang/examples/video.rs @@ -69,7 +69,7 @@ fn create_track(broadcast: &mut moq_net::broadcast::Producer) -> anyhow::Result< // This catalog never changes, so its one group starts at zero, where the media's timeline does. let mut group = catalog_track.append_group(0)?; group.write_frame(moq_net::Timestamp::ZERO, catalog.to_json()?)?; - group.close()?; + group.finish()?; // Actually create the media track now. // track_info() pins the microsecond timescale that the legacy container encodes with, and diff --git a/rs/hang/src/catalog/consumer.rs b/rs/hang/src/catalog/consumer.rs index c9de8cb7abf..b32f135b56d 100644 --- a/rs/hang/src/catalog/consumer.rs +++ b/rs/hang/src/catalog/consumer.rs @@ -138,7 +138,7 @@ mod test { let published = serde_json::json!({ "echo": { "path": reference } }).to_string(); let mut group = track.append_group(0).unwrap(); group.write_frame(moq_net::Timestamp::ZERO, published).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let result = consumer.next().await; if accepted { assert!(result.unwrap().unwrap().echo.is_some()); @@ -164,7 +164,7 @@ mod test { group .write_frame(moq_net::Timestamp::ZERO, published.to_json().unwrap()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(consumer.next().await.unwrap(), Some(published)); } @@ -193,7 +193,7 @@ mod test { group .write_frame(moq_net::Timestamp::ZERO, r#"{"version":5,"video":[]}"#) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert!(matches!( consumer.next().await, Err(crate::Error::UnsupportedVersion(5)) diff --git a/rs/moq-archive/benches/producer.rs b/rs/moq-archive/benches/producer.rs index 229dfc11ce5..01ce8c0fa15 100644 --- a/rs/moq-archive/benches/producer.rs +++ b/rs/moq-archive/benches/producer.rs @@ -34,7 +34,7 @@ fn setup(tracks: usize, groups: u64) -> (broadcast::Producer, Vec Result<()> { if let Some(open) = self.open.take() { - open.group.close()?; + open.group.finish()?; } Ok(()) } @@ -124,7 +124,7 @@ impl Live { self.close()?; match end { End::Finish(at) => { - self.producer.finish_at(Position::new(at.group, at.frame), None)?; + self.producer.finish_at(Position::new(at.group, at.frame))?; // An empty group stores no object, so the replay declares it never produces what // the archive holds nothing for up to the end, and the end settles over it. let fin = at.group + u64::from(at.frame != 0); @@ -134,8 +134,7 @@ impl Live { End::Error(code) => { // After the newest stored sequence, keeping the history an abort would refuse. let err = moq_net::StreamError::from_code(code).into(); - self.producer - .finish_at(Position::group(self.next.unwrap_or(0)), Some(err))?; + drop(self.producer.clone().fail(err)?); } } Ok(()) @@ -144,21 +143,47 @@ impl Live { /// Serve `fill` from the archive, a group at a time in the fill's order as its readers pick /// them up, until every group is answered or nobody waits on it. -pub(super) async fn serve(shared: Arc>, index: Arc>, mut fill: Fill) { - if let Some(pts) = fill.time() { - return look_up(&shared, &index, &fill, pts).await; +pub(super) async fn serve(shared: Arc>, index: Arc>, fill: Fill) { + match fill { + Fill::Lookup(lookup) => look_up(&shared, &index, &lookup).await, + Fill::Groups(mut fill) => { + while let Some(sequence) = fill.wanted_changed().await { + serve_group(&shared, &index, Asker::Fill(&fill), sequence).await; + } + } + } +} + +/// Who a served group answers: a fill's readers, or a lookup, which owes no group. +#[derive(Clone, Copy)] +enum Asker<'a> { + Fill(&'a FillGroups), + Lookup(&'a FillLookup), +} + +impl Asker<'_> { + /// Name `groups` as never to be delivered; a lookup owes none. + fn drop_groups(self, groups: std::ops::Range) { + if let Self::Fill(fill) = self { + fill.drop_groups(groups); + } } - while let Some(sequence) = fill.wanted_changed().await { - serve_group(&shared, &index, &fill, sequence).await; + + fn accept(self, sequence: u64) -> moq_net::Result { + match self { + Self::Fill(fill) => fill.accept(sequence, None), + Self::Lookup(lookup) => lookup.accept(sequence, None), + } } } -/// Answer `fill`'s lookup of `pts`, in the track's timescale, with the group containing it: the +/// Answer `lookup`'s time, in the track's timescale, with the group containing it: the /// newest group starting at or before it, found among the objects whose keys say they may hold /// it, or the oldest stored group when every one starts after it. A group starts at its key, /// as the live cache resolves it. Left unanswered when the archive holds no group, or the store /// fails. -async fn look_up(shared: &Shared, index: &Mutex, fill: &Fill, pts: u64) { +async fn look_up(shared: &Shared, index: &Mutex, lookup: &FillLookup) { + let pts = lookup.time(); let (around, timed) = { let index = index.lock().unwrap(); (index.around(pts), index.timed()) @@ -178,7 +203,7 @@ async fn look_up(shared: &Shared, index: &Mutex, fill: .find(|(_, entry)| !entry.frames.is_empty() && entry.sequence <= pts) .map(|(_, entry)| entry.sequence); if let Some(sequence) = found { - return serve_group(shared, index, fill, sequence).await; + return serve_group(shared, index, Asker::Lookup(lookup), sequence).await; } } @@ -196,7 +221,7 @@ async fn look_up(shared: &Shared, index: &Mutex, fill: .find(|(position, entry)| !entry.frames.is_empty() && (*position > 0 || object.frame_start == 0)) .map(|(_, entry)| entry.sequence); if let Some(sequence) = found { - return serve_group(shared, index, fill, sequence).await; + return serve_group(shared, index, Asker::Lookup(lookup), sequence).await; } next = index.lock().unwrap().after(Some(start)); } @@ -226,25 +251,29 @@ async fn load( } } -/// Answer group `sequence` of `fill` from the objects holding it, drop the run of sequences +/// Answer group `sequence` for `asker` from the objects holding it, drop the run of sequences /// around it that the archive does not hold, or refuse it for now when the store fails. -async fn serve_group(shared: &Shared, index: &Mutex, fill: &Fill, sequence: u64) { - let frame = fill.frame_start(sequence); +async fn serve_group(shared: &Shared, index: &Mutex, asker: Asker<'_>, sequence: u64) { + let frame = match asker { + Asker::Fill(fill) => fill.frame_start(sequence), + // A lookup is answered from the group's first frame. + Asker::Lookup(_) => 0, + }; let (holding, after, timed, timescale) = { let index = index.lock().unwrap(); let (holding, after) = index.holding(sequence, frame); (holding, after, index.timed(), index.timescale) }; let next = after.map_or(u64::MAX, |start| start.0); - // A lookup owes no group, so nothing says when its readers stop waiting: it finishes the read. - let lookup = fill.time().is_some(); let mut objects = Vec::with_capacity(holding.len()); for (start, path) in &holding { let load = super::object(shared, path, *start, timed); - let loaded = match lookup { - true => load.await, - false => { + let loaded = match asker { + // A lookup owes no group, so nothing says when its readers stop waiting: it finishes + // the read. + Asker::Lookup(_) => load.await, + Asker::Fill(fill) => { let unwanted = std::pin::pin!(fill.unwanted(sequence)); match future::select(unwanted, std::pin::pin!(load)).await { // Every reader narrowed past it: the fill moves on to the groups it still owes. @@ -258,14 +287,16 @@ async fn serve_group(shared: &Shared, index: &Mutex, f Err(Error::NotFound(_)) => { // Pruned since it was listed. index.lock().unwrap().forget(*start); - fill.drop_groups(sequence..sequence + 1); + asker.drop_groups(sequence..sequence + 1); return; } Err(err) => { // The store still lists it, so a later reader asks again. tracing::warn!(%path, sequence, %err, "archived group is unavailable"); let err = moq_net::Error::Stream(moq_net::StreamError::Internal); - fill.refuse_groups(sequence..sequence + 1, err); + if let Asker::Fill(fill) = asker { + fill.refuse_groups(sequence..sequence + 1, err); + } return; } } @@ -273,13 +304,13 @@ async fn serve_group(shared: &Shared, index: &Mutex, f let Some(first) = objects.first() else { // Older than the oldest stored object: pruned, or never stored. - fill.drop_groups(0..next); + asker.drop_groups(0..next); return; }; let Some(position) = first.entries.iter().position(|entry| entry.sequence >= sequence) else { // A gap after the object's last entry. let last = first.entries.last().map_or(0, |entry| entry.sequence + 1); - fill.drop_groups(last..next); + asker.drop_groups(last..next); return; }; let found = &first.entries[position]; @@ -289,7 +320,7 @@ async fn serve_group(shared: &Shared, index: &Mutex, f 0 => sequence, _ => first.entries[position - 1].sequence + 1, }; - fill.drop_groups(gap..found.sequence); + asker.drop_groups(gap..found.sequence); return; } let start = match position { @@ -298,7 +329,7 @@ async fn serve_group(shared: &Shared, index: &Mutex, f }; if start > frame { // Its head was pruned. - fill.drop_groups(sequence..sequence + 1); + asker.drop_groups(sequence..sequence + 1); return; } @@ -312,16 +343,18 @@ async fn serve_group(shared: &Shared, index: &Mutex, f } _ => { // A continuation went missing, so the group can't be served whole. - fill.drop_groups(sequence..sequence + 1); + asker.drop_groups(sequence..sequence + 1); return; } } } - if !lookup && !fill.is_wanted(sequence) { + if let Asker::Fill(fill) = asker + && !fill.is_wanted(sequence) + { return; } - let Ok(mut producer) = fill.accept(sequence, None) else { + let Ok(mut producer) = asker.accept(sequence) else { return; }; for (index, stored) in stored { @@ -337,7 +370,7 @@ async fn serve_group(shared: &Shared, index: &Mutex, f return; } } - let _ = producer.close(); + let _ = producer.finish(); } /// The served properties of a track stored with `info`: no max age, since the archive's diff --git a/rs/moq-archive/src/producer/backends.rs b/rs/moq-archive/src/producer/backends.rs index 50430993924..5b42cedf8c5 100644 --- a/rs/moq-archive/src/producer/backends.rs +++ b/rs/moq-archive/src/producer/backends.rs @@ -37,7 +37,7 @@ fn source(groups: u64, chat: &[(u64, &[&str])]) -> (broadcast::Producer, [track: let pts = Timestamp::from_millis(sequence * 1_000 + frame * 500).unwrap(); group.write_frame(pts, format!("v{sequence}.{frame}")).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } let text = source .create_track(CHAT, track::Info::default().with_max_age(None)) @@ -49,7 +49,7 @@ fn source(groups: u64, chat: &[(u64, &[&str])]) -> (broadcast::Producer, [track: .write_frame(moq_net::Timestamp::unscaled(*sequence), frame.to_string()) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } (source, [video, text]) } diff --git a/rs/moq-archive/src/producer/tests.rs b/rs/moq-archive/src/producer/tests.rs index c0d44718551..73a8c0cd40f 100644 --- a/rs/moq-archive/src/producer/tests.rs +++ b/rs/moq-archive/src/producer/tests.rs @@ -49,7 +49,7 @@ fn group(track: &track::Producer, sequence: u64, frames: &[(u64, &str)]) { for (pts, payload) in frames { group.write_frame(ms(*pts), payload.to_string()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } /// Let the producer catch up without moving time far. @@ -294,7 +294,7 @@ async fn an_open_untimed_group_is_cut_at_each_flush() { [[(0, vec!["a".to_string()])], [(0, vec!["b".to_string()])]] ); - open.close().unwrap(); + open.finish().unwrap(); let _data = data.finish().unwrap(); broadcast.close(); finished(task).await; @@ -319,12 +319,12 @@ async fn an_untimed_group_splits_by_wall_clock() { settle().await; sleep(SECOND / 2).await; } - open.close().unwrap(); + open.finish().unwrap(); settle().await; sleep(2 * SECOND).await; let mut next = data.create_group(group::Info { start: 1 }).unwrap(); next.write_frame(moq_net::Timestamp::unscaled(1), "f").unwrap(); - next.close().unwrap(); + next.finish().unwrap(); settle().await; let _data = data.finish().unwrap(); broadcast.close(); @@ -367,7 +367,7 @@ async fn an_idle_track_is_flushed_within_the_bound() { // The open group continues in the next object. open.write_frame(ms(100), "b").unwrap(); - open.close().unwrap(); + open.finish().unwrap(); settle().await; let _video = video.finish().unwrap(); broadcast.close(); @@ -409,8 +409,8 @@ async fn a_restart_mid_group_loses_and_duplicates_nothing() { settle().await; timed_group.write_frame(ms(300), "d").unwrap(); untimed_group.write_frame(moq_net::Timestamp::unscaled(0), "d").unwrap(); - timed_group.close().unwrap(); - untimed_group.close().unwrap(); + timed_group.finish().unwrap(); + untimed_group.finish().unwrap(); settle().await; let _video = video.finish().unwrap(); let _data = data.finish().unwrap(); @@ -467,7 +467,7 @@ async fn a_partial_group_resumes_after_its_last_stored_frame() { let task = spawn(&store, &broadcast, config); settle().await; partial.write_frame(ms(600), "d").unwrap(); - partial.close().unwrap(); + partial.finish().unwrap(); settle().await; let _video = video.finish().unwrap(); broadcast.close(); @@ -552,7 +552,7 @@ async fn track_names_stay_one_segment_through_a_resume() { subscribed(track).await; let mut group = track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(moq_net::Timestamp::unscaled(0), "x").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } settle().await; sleep(SECOND).await; @@ -680,8 +680,8 @@ async fn markers_wait_for_the_listing_to_end() { last.write_frame(ms(1000), "b").unwrap(); last.write_frame(ms(1100), "c").unwrap(); // A mid-group end: frames 0 and 1 of group 1. - video.finish_at(Position::new(1, 2), None).unwrap(); - last.close().unwrap(); + video.finish_at(Position::new(1, 2)).unwrap(); + last.finish().unwrap(); settle().await; sleep(SECOND).await; // Ended, but a track re-added under the name would continue it. @@ -705,14 +705,12 @@ async fn markers_wait_for_the_listing_to_end() { async fn an_errored_end_records_its_error() { let store = store(); let broadcast = broadcast::Info::new().produce(); - let mut video = broadcast.create_track("video", timed()).unwrap(); + let video = broadcast.create_track("video", timed()).unwrap(); let task = spawn(&store, &broadcast, config()); subscribed(&video).await; group(&video, 0, &[(0, "a")]); group(&video, 1, &[(1000, "b")]); - video - .finish_at(Position::group(2), Some(moq_net::Error::App(7))) - .unwrap(); + let _video = video.fail(moq_net::Error::App(7)).unwrap(); settle().await; broadcast.close(); finished(task).await; diff --git a/rs/moq-audio/src/decode/consumer.rs b/rs/moq-audio/src/decode/consumer.rs index f3d0da8fe1f..9abca1046cb 100644 --- a/rs/moq-audio/src/decode/consumer.rs +++ b/rs/moq-audio/src/decode/consumer.rs @@ -2773,7 +2773,7 @@ mod tests { keyframe: true, }; container.write(&mut group, &[frame]).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); if read(sequence) { next_frame(&mut consumer).await.unwrap().expect("one frame per packet"); } diff --git a/rs/moq-audio/src/encode/producer.rs b/rs/moq-audio/src/encode/producer.rs index 1d3fb4c6f89..3971d4607a4 100644 --- a/rs/moq-audio/src/encode/producer.rs +++ b/rs/moq-audio/src/encode/producer.rs @@ -296,12 +296,7 @@ impl Producer { /// while this producer is still held. Readers keep every packet published before it. fn fail_track(&mut self) { let _ = self.track.cut(None); - let track = self.track.track(); - let next = track.largest().map_or(0, |largest| largest.group.saturating_add(1)); - let _ = track.clone().finish_at( - moq_net::track::Position::group(next), - Some(moq_net::StreamError::Internal.into()), - ); + let _ = self.track.track().clone().fail(moq_net::StreamError::Internal.into()); } /// The name of the published track, which is [`Options::track`] resolved. diff --git a/rs/moq-bench/src/connection.rs b/rs/moq-bench/src/connection.rs index 7ae5d84b385..1989a48bd20 100644 --- a/rs/moq-bench/src/connection.rs +++ b/rs/moq-bench/src/connection.rs @@ -302,7 +302,7 @@ async fn produce( stats.frame_sent(zeros.len()); } - group.close()?; + group.finish()?; if sequence == 0 { published.establish(); } @@ -749,7 +749,7 @@ mod tests { .unwrap(); wait_for(&stats.frames_recv, 2).await; assert!(!stats.ready()); - complete.close().unwrap(); + complete.finish().unwrap(); wait_for(&stats.subscriptions_established, 1).await; assert!(stats.ready()); let _track = track.finish().unwrap(); @@ -1054,7 +1054,7 @@ mod tests { group .write_frame(moq_net::Timestamp::ZERO, Bytes::from_static(b"{}")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let announced = discover(&origin, "bench/current"); @@ -1094,7 +1094,7 @@ mod tests { group .write_frame(moq_net::Timestamp::ZERO, serde_json::to_vec(&header).unwrap()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); task.await.unwrap().unwrap(); @@ -1115,7 +1115,7 @@ mod tests { group .write_frame(moq_net::Timestamp::from_millis(n).unwrap(), header(n)) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let stats = Arc::new(Stats::default()); @@ -1175,7 +1175,7 @@ mod tests { let payload = if i == 0 { header(n) } else { Bytes::from_static(b"{}") }; group.write_frame(at, payload).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } let stats = Arc::new(Stats::default()); @@ -1195,7 +1195,7 @@ mod tests { write_group(&mut track, 1, &[1_100]); write_group(&mut track, 2, &[1_500, 1_600]); - first.close().unwrap(); + first.finish().unwrap(); wait_for(&stats.groups_recv, 2).await; // A last group moves the live frontier past group 2, so 1 and 2 are accounted. diff --git a/rs/moq-boy/src/input.rs b/rs/moq-boy/src/input.rs index bb4d739b789..bc9bb73c59f 100644 --- a/rs/moq-boy/src/input.rs +++ b/rs/moq-boy/src/input.rs @@ -71,9 +71,9 @@ impl Replies { /// A session track carries no timescale, so its groups have no time to start at: each starts one /// past the newest the track holds. fn send(track: &moq_net::track::Producer, message: Vec) -> moq_net::Result<()> { - let mut group = track.append_group(track.largest().map_or(0, |largest| largest.group + 1))?; + let mut group = track.append_group(None)?; group.write_frame(moq_net::Timestamp::unscaled(group.start), message)?; - group.close()?; + group.finish()?; Ok(()) } @@ -295,10 +295,7 @@ mod tests { }; // The reader parks on this group's first frame, which never arrives. - let _stalled = session - .producer - .append_group(session.producer.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let _stalled = session.producer.append_group(None).unwrap(); tokio::task::yield_now().await; send(&mut session, r#"{"type":"buttons","buttons":["a"]}"#); diff --git a/rs/moq-c/src/consume.rs b/rs/moq-c/src/consume.rs index 0ba8738f4ef..6a066b0ffb7 100644 --- a/rs/moq-c/src/consume.rs +++ b/rs/moq-c/src/consume.rs @@ -1484,7 +1484,7 @@ mod read_tests { }], ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; let mut ids = Vec::::new(); let callback = unsafe { OnStatus::new((&mut ids as *mut Vec).cast(), Some(received)) }.unwrap(); @@ -1632,7 +1632,7 @@ mod tests { } .write_to(&mut group) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } async fn frame(&self) -> Option { diff --git a/rs/moq-c/src/publish.rs b/rs/moq-c/src/publish.rs index 2436e473864..7ea2c1de9b1 100644 --- a/rs/moq-c/src/publish.rs +++ b/rs/moq-c/src/publish.rs @@ -35,7 +35,7 @@ enum Request { /// One group of a fill, handed to C as a group request: the frozen ABI answers fills a /// group at a time. struct GroupRequest { - fill: Arc, + fill: Arc, sequence: u64, /// Dropped once the request is answered or freed, so its fill's next group follows. _pending: oneshot::Sender<()>, @@ -112,12 +112,6 @@ enum Family { #[derive(Clone)] pub struct Children(Arc>); -/// One past the newest group's start, or 0 on an empty track: where a group the caller gave -/// no start for begins, which stands in until every write carries a timestamp. -fn next_start(track: &moq_net::track::Producer) -> u64 { - track.largest().map_or(0, |largest| largest.group.saturating_add(1)) -} - /// The family of a standalone broadcast of its own. #[cfg(test)] impl Default for Children { @@ -1032,6 +1026,12 @@ impl Publish { Request::Track(request) => State::lock().publish.track_request.insert(*request)?, Request::Datagram(request) => State::lock().publish.datagram_request.insert(request)?, Request::Fill(fill) => { + // A lookup of a time owes no group, and a request names one: drop it + // unanswered, as a handler that can't resolve times does, so the reader + // falls back to the groups held. + let moq_net::track::Fill::Groups(fill) = fill else { + continue; + }; let mut serve = Box::pin(Self::serve_fill(callback, Arc::new(fill))); fills.push(move |waiter: &kio::Waiter| waiter.poll_future(serve.as_mut())); continue; @@ -1043,12 +1043,7 @@ impl Publish { /// Hand `fill` to C a group at a time, each once the one before it reached a reader or /// nobody reads it any more, until every group is answered or nobody waits on the fill. - async fn serve_fill(callback: OnStatus, fill: Arc) { - // A lookup of a time owes no group, and a request names one: drop it unanswered, as a - // handler that can't resolve times does, so the reader falls back to the groups held. - if fill.time().is_some() { - return; - } + async fn serve_fill(callback: OnStatus, fill: Arc) { let mut changes = (*fill).clone(); while let Some(sequence) = changes.wanted_changed().await { let (pending, answered) = oneshot::channel(); @@ -1224,7 +1219,7 @@ impl Publish { /// group producer. pub fn track_group(&mut self, track: Id) -> Result { let raw = self.tracks.get_mut(track).ok_or(Error::TrackNotFound)?; - let group = raw.inner.append_group(next_start(&raw.inner))?; + let group = raw.inner.append_group(None)?; self.insert_group(group) } @@ -1275,8 +1270,7 @@ impl Publish { /// Declare a raw track's exclusive final group sequence. pub fn track_finish_at(&mut self, track: Id, final_sequence: u64) -> Result<(), Error> { let raw = self.tracks.get_mut(track).ok_or(Error::TrackNotFound)?; - raw.inner - .finish_at(moq_net::track::Position::group(final_sequence), None)?; + raw.inner.finish_at(moq_net::track::Position::group(final_sequence))?; Ok(()) } @@ -1558,7 +1552,7 @@ impl Publish { .remove(group) .and_then(|group| group.inner.take()) .ok_or(Error::GroupNotFound)?; - group.close()?; + group.finish()?; Ok(()) } diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index b790ff6215f..9b79b8277a0 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -5007,7 +5007,7 @@ fn a_group_request_nobody_reads_is_withdrawn() { group .write_frame(moq_net::Timestamp::from_millis(10).unwrap(), &b"live"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); reader }; let first = id(group_cb.recv_reading(&mut reader)); @@ -5052,7 +5052,7 @@ fn a_rejected_group_request_binds_only_its_readers() { group .write_frame(moq_net::Timestamp::from_millis(10).unwrap(), &b"live"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); drop(producer.clone().finish().unwrap()); } let subscribe = || { diff --git a/rs/moq-cli/src/archive.rs b/rs/moq-cli/src/archive.rs index 246ca566960..e672bef93f1 100644 --- a/rs/moq-cli/src/archive.rs +++ b/rs/moq-cli/src/archive.rs @@ -410,7 +410,7 @@ mod tests { let track = broadcast.broadcast().create_track("video", info.clone()).unwrap(); let mut group = track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(Timestamp::from_millis(0).unwrap(), path).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); broadcast.announce().unwrap(); instances.push(broadcast.instance()); broadcasts.push((broadcast, track)); @@ -499,7 +499,7 @@ mod tests { let mut group = video.create_group(group::Info { start: sequence * 1000 }).unwrap(); let pts = Timestamp::from_millis(sequence * 1000).unwrap(); group.write_frame(pts, format!("frame {sequence}")).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let _video = video.finish().unwrap(); let recording = diff --git a/rs/moq-cli/src/fetch.rs b/rs/moq-cli/src/fetch.rs index 028c59cb9a9..5bf6c5a868e 100644 --- a/rs/moq-cli/src/fetch.rs +++ b/rs/moq-cli/src/fetch.rs @@ -206,7 +206,7 @@ mod tests { for frame in frames(sequence) { group.write_frame(at, frame).expect("frame"); } - group.close().expect("close"); + group.finish().expect("close"); } let empty = broadcast .broadcast() @@ -270,7 +270,7 @@ mod tests { group .write_frame(moq_net::Timestamp::ZERO, b"secret".as_ref()) .expect("frame"); - group.close().expect("close"); + group.finish().expect("close"); let ready = fixture.relay.ready(); tokio::spawn(fixture.relay.run()); diff --git a/rs/moq-cli/src/main.rs b/rs/moq-cli/src/main.rs index 5210131b3b4..fa3aeb0ea15 100644 --- a/rs/moq-cli/src/main.rs +++ b/rs/moq-cli/src/main.rs @@ -1305,7 +1305,7 @@ mod tests { group .write_frame(moq_net::Timestamp::ZERO, b"admitted".as_ref()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let (auth, admissions) = moq_relay::auth::Auth::embedded("test-cli"); let (trigger, observer) = moq_relay::shutdown::Observer::new(TIMEOUT); let serving = Serving { @@ -1504,7 +1504,7 @@ mod tests { let track = broadcast.broadcast().create_track("live", info).unwrap(); let mut group = track.append_group(0).unwrap(); group.write_frame(moq_net::Timestamp::ZERO, b"live".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let reader = relay.consume(); let mut live = reader diff --git a/rs/moq-cli/src/play/video.rs b/rs/moq-cli/src/play/video.rs index 43fea509254..6403cbf1bbe 100644 --- a/rs/moq-cli/src/play/video.rs +++ b/rs/moq-cli/src/play/video.rs @@ -894,7 +894,7 @@ mod tests { .map(|(index, ms)| frame(ms, index == 0)) .collect(); format.write(&mut group, &frames).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; write(10, vec![100, 80, 90, 110]); write(11, vec![200, 180, 190, 210]); @@ -1269,7 +1269,7 @@ mod tests { .map(|(index, ms)| frame(ms, index == 0)) .collect(); wire().write(&mut group, &frames).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let _published = published.finish().unwrap(); let begin = Instant::now(); diff --git a/rs/moq-cli/tests/integration/instances.rs b/rs/moq-cli/tests/integration/instances.rs index 66164237fcd..ecbcfada31d 100644 --- a/rs/moq-cli/tests/integration/instances.rs +++ b/rs/moq-cli/tests/integration/instances.rs @@ -48,12 +48,11 @@ fn client(version: &str) -> moq_tokio::Client { } fn write(track: &track::Producer, tag: &str) { - let start = track.largest().map_or(0, |largest| largest.group + 1); - let mut group = track.append_group(start).unwrap(); + let mut group = track.append_group(None).unwrap(); group - .write_frame(Timestamp::from_millis(start).unwrap(), tag.as_bytes().to_vec()) + .write_frame(Timestamp::from_millis(group.start).unwrap(), tag.as_bytes().to_vec()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } async fn read(subscription: &mut track::Subscriber) -> String { diff --git a/rs/moq-crypto/benches/protect.rs b/rs/moq-crypto/benches/protect.rs index c9611de2a81..ab3ee518d3b 100644 --- a/rs/moq-crypto/benches/protect.rs +++ b/rs/moq-crypto/benches/protect.rs @@ -44,7 +44,7 @@ fn bench_protect(c: &mut Criterion) { group .write_frame(Timestamp::from_millis(ms).unwrap(), black_box(&grouped)) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }); }); group.throughput(Throughput::Bytes(opus.len() as u64)); diff --git a/rs/moq-crypto/src/e2ee/group.rs b/rs/moq-crypto/src/e2ee/group.rs index 628eb7f2de5..de6ef36bf04 100644 --- a/rs/moq-crypto/src/e2ee/group.rs +++ b/rs/moq-crypto/src/e2ee/group.rs @@ -22,7 +22,7 @@ pub struct Frame { /// Exclusive writer for one group; frames are numbered from 0 in write order. /// -/// Dropping without [`Self::close`] or [`Self::abort`] lets the net group close uncleanly. +/// Dropping without [`Self::finish`] or [`Self::abort`] lets the net group close uncleanly. pub struct Producer { // The error that aborted the group once a write failed after encryption. inner: std::result::Result, @@ -91,13 +91,13 @@ impl Producer { Ok(()) } - /// Close the group without a known end. No more frames will be written. + /// Finish the group without a known end. No more frames will be written. /// /// # Errors /// /// A net error if the group is already closed, or the error a failed write aborted it with. - pub fn close(self) -> Result<()> { - self.inner?.close()?; + pub fn finish(self) -> Result<()> { + self.inner?.finish()?; Ok(()) } diff --git a/rs/moq-crypto/src/e2ee/tests.rs b/rs/moq-crypto/src/e2ee/tests.rs index 464ef24f614..c4ea351151e 100644 --- a/rs/moq-crypto/src/e2ee/tests.rs +++ b/rs/moq-crypto/src/e2ee/tests.rs @@ -466,7 +466,7 @@ fn grouped_roundtrip() { group.write_frame(ms(1), b"frame-zero").unwrap(); group.write_frame(ms(2), b"frame-one").unwrap(); assert_eq!(group.next_frame(), 2); - group.close().unwrap(); + group.finish().unwrap(); let mut group = recv_group(&mut pair.consumer); assert_eq!(group.start(), 1); @@ -606,7 +606,7 @@ fn one_name_keys_its_stream_and_datagram_tracks_apart() { // The same plaintext at the same identity in each kind: group 0 frame 0, and datagram 0. let mut group = track.append_group(0).unwrap(); group.write_frame(ms(1), b"same").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(datagrams.append(ms(1), b"same").unwrap(), 0); assert_eq!(read_frame(&mut recv_group(&mut track_reader)).plaintext, &b"same"[..]); match recv_datagram(&mut datagram_reader) { @@ -630,7 +630,7 @@ fn one_name_keys_its_stream_and_datagram_tracks_apart() { let mut reader = consuming.consume(forged.subscribe(subscribe_all()), "audio").unwrap(); let mut group = forged.create_group(moq_net::group::Info { start: 0 }).unwrap(); group.write_frame(ms(1), sealed).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!( recv_group(&mut reader) .poll_read_frame(&kio::Waiter::noop()) @@ -751,7 +751,7 @@ fn broadcast_speaks_semantic_names() { let mut reader = resolve(&protected.consumer.subscribe("video", subscribe_all()).unwrap()).unwrap(); let mut group = video.append_group(1).unwrap(); group.write_frame(ms(1), b"frame").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(read_frame(&mut recv_group(&mut reader)).plaintext, &b"frame"[..]); // The relay's view holds only the physical name. @@ -853,7 +853,7 @@ fn requests_serve_undeclared_names() { let mut reader = resolve(&subscribing).unwrap(); let mut group = track.append_group(1).unwrap(); group.write_frame(ms(1), b"42").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(read_frame(&mut recv_group(&mut reader)).plaintext, &b"42"[..]); // The handler's own consumer reads the broadcast under semantic names too. @@ -1052,7 +1052,7 @@ fn new_epoch_authenticates_old_does_not() { let mut producer = new.produce(net.clone(), "video").unwrap(); let mut group = producer.append_group(1).unwrap(); group.write_frame(ms(1), b"fresh").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut consumer = consume(&new).consume(net.subscribe(subscribe_all()), "video").unwrap(); assert_eq!(read_frame(&mut recv_group(&mut consumer)).plaintext, &b"fresh"[..]); @@ -1130,7 +1130,7 @@ fn grouped_authentication_ends_track() { let mut pair = pair("video"); let mut group = pair.producer.append_group(0).unwrap(); group.write_frame(ms(1), b"ok").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); // Tamper with a second group by writing ciphertext directly. let semantic = pair.semantic.as_str(); @@ -1139,7 +1139,7 @@ fn grouped_authentication_ends_track() { payload[0] ^= 1; let mut bad = pair.net.create_group(moq_net::group::Info { start: 1 }).unwrap(); bad.write_frame(ms(2), payload).unwrap(); - bad.close().unwrap(); + bad.finish().unwrap(); let waiter = kio::Waiter::noop(); let mut first = recv_group(&mut pair.consumer); @@ -1407,7 +1407,7 @@ fn cancellation_ends_consumer() { let mut pair = pair("video"); let mut group = pair.producer.append_group(1).unwrap(); group.write_frame(ms(1), b"x").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); pair.producer.finish().unwrap(); let waiter = kio::Waiter::noop(); let mut group = recv_group(&mut pair.consumer); @@ -1441,7 +1441,7 @@ fn failed_group_write_does_not_burn_nonce() { group.write_frame(ms(1), b"ok").unwrap(); assert_eq!(group.invocations(), 1); assert_eq!(group.next_frame(), 1); - group.close().unwrap(); + group.finish().unwrap(); let mut group = recv_group(&mut pair.consumer); assert_eq!(read_frame(&mut group).plaintext, &b"ok"[..]); @@ -1452,7 +1452,7 @@ fn failed_net_write_after_encryption_aborts_the_group() { let mut pair = pair("video"); let mut first = pair.producer.append_group(0).unwrap(); first.write_frame(ms(10), b"start").unwrap(); - first.close().unwrap(); + first.finish().unwrap(); // The net track refuses a first frame that rewinds past the one before it, only after // the frame was encrypted, so the group can no longer line its transport index up with @@ -1465,7 +1465,7 @@ fn failed_net_write_after_encryption_aborts_the_group() { let after = group.write_frame(ms(20), b"after").unwrap_err(); assert_eq!(after.to_string(), err.to_string()); assert_eq!(group.invocations(), 2); - assert_eq!(group.close().unwrap_err().to_string(), err.to_string()); + assert_eq!(group.finish().unwrap_err().to_string(), err.to_string()); // Subscribers see the group end with the failure instead of waiting on it. let mut start = recv_group(&mut pair.consumer); @@ -1490,7 +1490,7 @@ fn resumed_group_opens_at_transport_index() { let mut group = producer.append_group(1).unwrap(); group.write_frame(ms(1), b"zero").unwrap(); group.write_frame(ms(2), b"one").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); // Simulate a resume at object 1: skip frame 0 on the net cursor before wrapping. let Poll::Ready(Ok(Some(mut net_group))) = subscriber.poll_recv_group(&kio::Waiter::noop()) else { diff --git a/rs/moq-crypto/src/e2ee/track.rs b/rs/moq-crypto/src/e2ee/track.rs index f34ba1d555f..e02b56d12c0 100644 --- a/rs/moq-crypto/src/e2ee/track.rs +++ b/rs/moq-crypto/src/e2ee/track.rs @@ -33,16 +33,16 @@ impl Producer { /// Start the next group at `start`, in the track's timescale, as /// [`moq_net::track::Producer::append_group`] does. `start` must be above every start this - /// name allocated under the generation. + /// name allocated under the generation; `None` takes the one just past them. /// /// # Errors /// /// [`Error::Reuse`](crate::e2ee::Error::Reuse) if `start` was already allocated, [`Error::Identity`](crate::e2ee::Error::Identity) if /// it exceeds `2^53-1`, or a net error. - pub fn append_group(&mut self, start: u64) -> Result { + pub fn append_group(&mut self, start: impl Into>) -> Result { let (_, inner) = self .claim - .allocate(Some(start), |start| Ok(self.inner.append_group(start)?))?; + .allocate(start.into(), |start| Ok(self.inner.append_group(start)?))?; Ok(self.group(inner)) } diff --git a/rs/moq-crypto/tests/transport.rs b/rs/moq-crypto/tests/transport.rs index c69356b8765..2223210a00a 100644 --- a/rs/moq-crypto/tests/transport.rs +++ b/rs/moq-crypto/tests/transport.rs @@ -103,7 +103,7 @@ async fn grouped_roundtrip(version: &str, payload: &[u8]) { .unwrap(); let mut group = producer.append_group(1).unwrap(); group.write_frame(Timestamp::from_millis(1).unwrap(), payload).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = consumer.recv_group().await.unwrap().unwrap(); let frame = group.read_frame().await.unwrap().unwrap(); assert_eq!(&frame.plaintext[..], payload); diff --git a/rs/moq-ffi/src/bench.rs b/rs/moq-ffi/src/bench.rs index 973d4a85bd1..f192a3ed5f8 100644 --- a/rs/moq-ffi/src/bench.rs +++ b/rs/moq-ffi/src/bench.rs @@ -227,7 +227,7 @@ async fn net_round( // Copy, as a binding's write does, so the baseline does not get zero-copy for free. group.write_frame(timestamp, payload.to_vec()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } let mut consumers = Vec::with_capacity(readers.len()); for reader in readers { diff --git a/rs/moq-ffi/src/media.rs b/rs/moq-ffi/src/media.rs index 7eaacedcf2c..d6812b7839d 100644 --- a/rs/moq-ffi/src/media.rs +++ b/rs/moq-ffi/src/media.rs @@ -1658,7 +1658,7 @@ mod read_tests { }], ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; // Newest first, all before the first read. Group 4 covers the min delay alone, so // without the warmup the start would skip group 3; only the warmup's reach keeps it. @@ -1726,7 +1726,7 @@ mod read_tests { }], ) .unwrap(); - first.close().unwrap(); + first.finish().unwrap(); let Some(MoqMediaRead::Frame { frame }) = reader.next().await.unwrap() else { panic!("expected frame") }; @@ -1745,7 +1745,7 @@ mod read_tests { }], ) .unwrap(); - marker.close().unwrap(); + marker.finish().unwrap(); assert!( matches!(reader.next().await.unwrap(), Some(MoqMediaRead::Gap { timestamp, duration }) if timestamp == micros(10_000) && duration == Duration::from_millis(10)) ); @@ -1765,7 +1765,7 @@ mod read_tests { }], ) .unwrap(); - resumed.close().unwrap(); + resumed.finish().unwrap(); let Some(MoqMediaRead::Frame { frame }) = reader.next().await.unwrap() else { panic!("end is not EOF") }; diff --git a/rs/moq-ffi/src/producer.rs b/rs/moq-ffi/src/producer.rs index 26f1e1fea4b..c6e8b5995bb 100644 --- a/rs/moq-ffi/src/producer.rs +++ b/rs/moq-ffi/src/producer.rs @@ -100,12 +100,6 @@ impl TryFrom for moq_net::track::Info { } } -/// One past the newest group's start, or 0 on an empty track: where a group the caller gave -/// no start for begins. -fn next_start(track: &moq_net::track::Producer) -> u64 { - track.largest().map_or(0, |largest| largest.group.saturating_add(1)) -} - fn raw_track_info(info: Option) -> Result { info.map(moq_net::track::Info::try_from) .transpose() @@ -489,8 +483,7 @@ impl MoqTrackRequests { .reads .wait(|requests, waiter| { loop { - let fill = ready!(requests.poll_requested_fill(waiter))?; - if fill.time().is_none() { + if let moq_net::track::Fill::Groups(fill) = ready!(requests.poll_requested_fill(waiter))? { return Poll::Ready(Ok(fill)); } } @@ -508,7 +501,7 @@ impl MoqTrackRequests { } } -/// A run of groups readers miss, mirroring [`moq_net::track::Fill`]. +/// A run of groups readers miss, mirroring [`moq_net::track::FillGroups`]. /// /// Call [`accept`](Self::accept) for each group you have and [`drop_groups`](Self::drop_groups) /// for the rest, one group at a time as [`wanted_changed`](Self::wanted_changed) yields them; @@ -519,13 +512,13 @@ impl MoqTrackRequests { /// fills you take concurrently: each waits on its own readers. #[derive(uniffi::Object)] pub struct MoqFill { - inner: moq_net::track::Fill, + inner: moq_net::track::FillGroups, /// The watcher `wanted_changed` advances, kept apart from `inner` so its cursor is its own. - changes: Polled, + changes: Polled, } impl MoqFill { - fn new(inner: moq_net::track::Fill) -> Self { + fn new(inner: moq_net::track::FillGroups) -> Self { let changes = Polled::new(inner.clone()); Self { inner, changes } } @@ -849,7 +842,7 @@ impl MoqTrackProducer { let _guard = crate::ffi::enter(); let mut phase = self.phase.lock().unwrap(); let raw = phase.raw()?; - let group = raw.append_group(next_start(raw))?; + let group = raw.append_group(None)?; Ok(Arc::new(MoqGroupProducer::from_inner(group))) } @@ -977,7 +970,7 @@ impl MoqTrackProducer { let _guard = crate::ffi::enter(); let mut phase = self.phase.lock().unwrap(); let raw = phase.raw()?; - raw.finish_at(moq_net::track::Position::group(final_sequence), None)?; + raw.finish_at(moq_net::track::Position::group(final_sequence))?; Ok(()) } } @@ -1092,7 +1085,7 @@ impl MoqGroupProducer { let _guard = crate::ffi::enter(); let mut guard = self.inner.lock(); match std::mem::take(&mut *guard) { - GroupPhase::Writing(group) => *guard = GroupPhase::Finished(group.close()?), + GroupPhase::Writing(group) => *guard = GroupPhase::Finished(group.finish()?), GroupPhase::Finished(group) => *guard = GroupPhase::Finished(group), GroupPhase::Closed => return Err(MoqError::Closed), } diff --git a/rs/moq-ffi/src/test.rs b/rs/moq-ffi/src/test.rs index 7b55eaeedf9..6badfc2a4e3 100644 --- a/rs/moq-ffi/src/test.rs +++ b/rs/moq-ffi/src/test.rs @@ -2632,8 +2632,8 @@ async fn media_group_decodes_arrival_order_groups() { assert_eq!(micros(frame.timestamp), 1_020_000); assert!(!frame.keyframe); - first.close().unwrap(); - second.close().unwrap(); + first.finish().unwrap(); + second.finish().unwrap(); assert!(next_media(&first_media).await.unwrap().is_none()); assert!(next_media(&second_media).await.unwrap().is_none()); } @@ -2646,7 +2646,7 @@ async fn media_group_takes_over_an_unread_group() { let mut group = track.append_group(0).unwrap(); write_legacy(&mut group, 1, 1_000_000, b"a"); write_legacy(&mut group, 2, 1_020_000, b"b"); - group.close().unwrap(); + group.finish().unwrap(); let raw = recv_raw_group(&consumer).await; assert!(raw.read_frame().await.unwrap().is_some()); diff --git a/rs/moq-gst/src/sink/imp.rs b/rs/moq-gst/src/sink/imp.rs index 6a3e50c1ecf..8e0c198edc0 100644 --- a/rs/moq-gst/src/sink/imp.rs +++ b/rs/moq-gst/src/sink/imp.rs @@ -2470,7 +2470,7 @@ mod tests { }; let consumer = broadcast.consume(); let track = broadcast.create_track("video", None).unwrap(); - track.append_group(0).unwrap().close().unwrap(); + track.append_group(0).unwrap().finish().unwrap(); let track = track.finish().unwrap(); assert!(session.finish()); while bus.pop().is_some() {} diff --git a/rs/moq-hls/src/export/archive_tests.rs b/rs/moq-hls/src/export/archive_tests.rs index b52ba10c846..2de63eaecb3 100644 --- a/rs/moq-hls/src/export/archive_tests.rs +++ b/rs/moq-hls/src/export/archive_tests.rs @@ -160,7 +160,7 @@ impl Recording { let timestamp = Timestamp::from_micros(micros).unwrap(); group.write_frame(timestamp, legacy(track, micros, index == 0)).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } } diff --git a/rs/moq-hls/src/export/mod.rs b/rs/moq-hls/src/export/mod.rs index 2b89db0829f..9d95a33fec2 100644 --- a/rs/moq-hls/src/export/mod.rs +++ b/rs/moq-hls/src/export/mod.rs @@ -1508,7 +1508,7 @@ mod tests { for group in 2..5 { let mut writing = media.create_group(group.into()).unwrap(); write_keyframe(&mut writing, group); - writing.close().unwrap(); + writing.finish().unwrap(); } until_listed(&rendition, 4).await; let segment = rendition @@ -1584,7 +1584,7 @@ mod tests { write_keyframe(&mut open, sequence); let mut next = media.create_group((sequence + 1).into()).unwrap(); write_keyframe(&mut next, sequence + 1); - next.close().unwrap(); + next.finish().unwrap(); (media, open) } @@ -1633,7 +1633,7 @@ mod tests { for sequence in 0..3 { let mut group = media.create_group(sequence.into()).unwrap(); write_keyframe(&mut group, sequence); - group.close().unwrap(); + group.finish().unwrap(); } let mut open = media.create_group(3u64.into()).unwrap(); write_keyframe(&mut open, 3); @@ -1668,7 +1668,7 @@ mod tests { let manifest = broadcaster.manifest(None).unwrap().expect("video0 renders"); assert!(!manifest.contains("id=\"video/video1\""), "{manifest}"); - open.close().unwrap(); + open.finish().unwrap(); let manifest = listed_in_manifest(&broadcaster).await; assert!(manifest.contains("id=\"video/video0\""), "{manifest}"); } @@ -1708,7 +1708,7 @@ mod tests { failed(&broken).await; assert!(broadcaster.manifest(None).unwrap().is_none()); - open.close().unwrap(); + open.finish().unwrap(); let manifest = kio::clock::timeout(Duration::from_secs(5), async { loop { if let Some(manifest) = broadcaster.manifest(None).unwrap() { @@ -1816,7 +1816,7 @@ mod tests { assert!(!manifest.contains("id=\"video/video1\""), "{manifest}"); assert!(!manifest.contains("type=\"static\""), "{manifest}"); - open.close().unwrap(); + open.finish().unwrap(); let manifest = listed_in_manifest(&broadcaster).await; assert!(manifest.contains("type=\"static\""), "{manifest}"); } @@ -1844,7 +1844,7 @@ mod tests { .is_err(), "resolved without a listable video" ); - open.close().unwrap(); + open.finish().unwrap(); kio::clock::timeout(Duration::from_secs(1), waiting) .await .expect("video0 is listable once its init is built"); @@ -1872,7 +1872,7 @@ mod tests { for sequence in 0..3 { let mut group = media.create_group(sequence.into()).unwrap(); write_keyframe(&mut group, sequence); - group.close().unwrap(); + group.finish().unwrap(); } kio::clock::timeout(Duration::from_secs(1), waiting) .await @@ -1890,7 +1890,7 @@ mod tests { for sequence in 0..4 { let mut group = media.create_group(sequence.into()).unwrap(); write_keyframe(&mut group, sequence); - group.close().unwrap(); + group.finish().unwrap(); } let broadcaster = Broadcaster::spawned(crate::resolved(&origin, "live").await, Config::default()); @@ -3643,7 +3643,7 @@ mod tests { .write_to(&mut group) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } /// Write group `sequence` at `pts_ms` with a single keyframe. @@ -3667,7 +3667,7 @@ mod tests { } .write_to(&mut group) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// Write group `sequence` at `2 * sequence` seconds: one GOP per grid line. @@ -4070,7 +4070,7 @@ mod tests { let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); let bytes = muxer.fragment(sequence as u32, &frames, None).unwrap(); group.write_frame(frames[0].timestamp, bytes).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; fragment(0, 500, 2_400); fragment(1, 2_500, 4_400); @@ -4654,7 +4654,7 @@ mod tests { } .write_to(&mut group) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } media.at(cap + 1, 2_000); media.at(cap + 2, 4_000); diff --git a/rs/moq-hls/src/export/rendition.rs b/rs/moq-hls/src/export/rendition.rs index 4942ccc9e9b..089b3cb5f7c 100644 --- a/rs/moq-hls/src/export/rendition.rs +++ b/rs/moq-hls/src/export/rendition.rs @@ -3030,7 +3030,7 @@ mod tests { group .write_frame(moq_net::Timestamp::unscaled(0), Bytes::from_static(b"retained")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); self.broadcast.close(); *self.track.lock().unwrap() = Some(track); } diff --git a/rs/moq-hls/src/server/include_tests.rs b/rs/moq-hls/src/server/include_tests.rs index 0c913845b89..e457c7264be 100644 --- a/rs/moq-hls/src/server/include_tests.rs +++ b/rs/moq-hls/src/server/include_tests.rs @@ -73,7 +73,7 @@ fn frames(track: &track::Producer, first: u64) { } .write_to(&mut group) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } } diff --git a/rs/moq-json/src/snapshot/mod.rs b/rs/moq-json/src/snapshot/mod.rs index 91d9287a179..16b74f28e97 100644 --- a/rs/moq-json/src/snapshot/mod.rs +++ b/rs/moq-json/src/snapshot/mod.rs @@ -757,7 +757,7 @@ mod test { .unwrap(); let mut producer = Producer::::new(track.clone(), cfg(false)); producer.update(next(&json!({ "a": 1 }))).unwrap(); - track.finish_at(moq_net::track::Position::group(2), None).unwrap(); + track.finish_at(moq_net::track::Position::group(2)).unwrap(); producer.modify(key()).unwrap()["a"] = json!(2); assert!(matches!( @@ -776,7 +776,7 @@ mod test { .unwrap(); let mut producer = Producer::::new(track.clone(), cfg(false)); producer.update(next(&json!({ "a": 1 }))).unwrap(); - track.finish_at(moq_net::track::Position::group(10), None).unwrap(); + track.finish_at(moq_net::track::Position::group(10)).unwrap(); let _finished = producer.clone().finish().unwrap(); assert!(matches!( @@ -1048,7 +1048,7 @@ mod test { bytes::Bytes::from_static(b"{}"), ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); track } @@ -1170,7 +1170,7 @@ mod test { Bytes::from(serde_json::to_vec(&json!({ "a": 1 })).unwrap()), ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); match consumer.poll_latest(&waiter) { Poll::Ready(Ok(Some(value))) => assert_eq!(value.value, json!({ "a": 1 })), diff --git a/rs/moq-json/src/snapshot/producer.rs b/rs/moq-json/src/snapshot/producer.rs index 72c1327d824..07afc4ffa19 100644 --- a/rs/moq-json/src/snapshot/producer.rs +++ b/rs/moq-json/src/snapshot/producer.rs @@ -492,7 +492,7 @@ impl Track { /// Close the open group without opening a replacement. fn cut(&mut self) -> Result<()> { if let Some(group) = self.group.take() { - group.close()?; + group.finish()?; } Ok(()) } @@ -536,14 +536,14 @@ impl Track { // The previous group is complete; no more frames will be appended to it. if let Some(previous) = self.group.take() { - previous.close()?; + previous.finish()?; } if let Err(err) = group.write_frame(timestamp, payload) { // `append_group` already published this group, and a rejected frame (too large) doesn't // close the track. Dropping the handle does NOT close the group, so leaving it would strand // any subscriber that advanced into it with nothing to read and no end. - let _ = group.close(); + let _ = group.finish(); return Err(err.into()); } @@ -551,7 +551,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 => drop(group.close()?), + false => drop(group.finish()?), } Ok(()) @@ -569,7 +569,7 @@ impl Track { fn finish(&mut self) -> Result<()> { if let Some(group) = self.group.take() { - group.close()?; + group.finish()?; } // Another handle may have declared the end already, which stands. This shared state // keeps its own clone, whose appends the end refuses. diff --git a/rs/moq-json/src/stream/mod.rs b/rs/moq-json/src/stream/mod.rs index 38a8bae395a..db1d7687746 100644 --- a/rs/moq-json/src/stream/mod.rs +++ b/rs/moq-json/src/stream/mod.rs @@ -291,7 +291,7 @@ mod test { bytes::Bytes::from_static(b"{}"), ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); track } diff --git a/rs/moq-json/src/stream/producer.rs b/rs/moq-json/src/stream/producer.rs index e6c417b93a1..09caead9864 100644 --- a/rs/moq-json/src/stream/producer.rs +++ b/rs/moq-json/src/stream/producer.rs @@ -273,7 +273,7 @@ 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(group) => group.close().map(drop), + Some(group) => group.finish().map(drop), None => Ok(()), }; // This shared state keeps its own clone, whose appends the end refuses. diff --git a/rs/moq-json/src/window/mod.rs b/rs/moq-json/src/window/mod.rs index 391330354b3..bb9fd6c4cda 100644 --- a/rs/moq-json/src/window/mod.rs +++ b/rs/moq-json/src/window/mod.rs @@ -319,7 +319,7 @@ mod test { bytes::Bytes::from_static(b"{}"), ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); track } @@ -695,7 +695,7 @@ mod test { checkpoint .write_frame(moq_net::Timestamp::from_millis(1).unwrap(), payload) .unwrap(); - checkpoint.close().unwrap(); + checkpoint.finish().unwrap(); let _track = track.finish().unwrap(); assert_eq!( diff --git a/rs/moq-json/src/window/producer.rs b/rs/moq-json/src/window/producer.rs index bd7a0047869..6d6050b0c94 100644 --- a/rs/moq-json/src/window/producer.rs +++ b/rs/moq-json/src/window/producer.rs @@ -251,7 +251,7 @@ impl Inner { // The group closes either way, so reset first: a `close` error must not leave the encoder // appending ops to a group that is gone. self.encoder.reset(); - group.close()?; + group.finish()?; Ok(()) } @@ -371,14 +371,14 @@ impl Track { // The previous group is complete; no more frames will be appended to it. if let Some(previous) = self.group.take() { - previous.close()?; + previous.finish()?; } if let Err(err) = group.write_frame(timestamp, payload) { // `append_group` already published this group, and a rejected frame (too large) doesn't // close the track. Dropping the handle does NOT close the group, so leaving it would strand // any subscriber that advanced into it with nothing to read and no end. - let _ = group.close(); + let _ = group.finish(); return Err(err.into()); } @@ -398,7 +398,7 @@ impl Track { fn finish(&mut self) -> Result<()> { if let Some(group) = self.group.take() { - group.close()?; + group.finish()?; } // Another handle may have declared the end already, which stands. This shared state // keeps its own clone, whose appends the end refuses. diff --git a/rs/moq-mux/src/catalog/hang/consumer.rs b/rs/moq-mux/src/catalog/hang/consumer.rs index 99fcab42ce3..f79373c3c41 100644 --- a/rs/moq-mux/src/catalog/hang/consumer.rs +++ b/rs/moq-mux/src/catalog/hang/consumer.rs @@ -119,7 +119,7 @@ mod test { group .write_frame(moq_net::Timestamp::ZERO, payload) .expect("catalog frame should write"); - group.close().expect("catalog group should finish"); + group.finish().expect("catalog group should finish"); match consumer.poll_next(&kio::Waiter::noop()) { Poll::Ready(result) => result, @@ -173,7 +173,7 @@ mod test { group .write_frame(moq_net::Timestamp::ZERO, payload) .expect("catalog frame should write"); - group.close().expect("catalog group should finish"); + group.finish().expect("catalog group should finish"); consumer.next().await } @@ -356,7 +356,7 @@ mod test { group .write_frame(moq_net::Timestamp::ZERO, payload) .expect("catalog frame should write"); - group.close().expect("catalog group should finish"); + group.finish().expect("catalog group should finish"); assert_eq!(expect_catalog(consumer.poll_next(&waiter)), catalog); } @@ -369,7 +369,7 @@ mod test { group .write_frame(moq_net::Timestamp::ZERO, r#"{"version":5}"#) .expect("catalog frame should write"); - group.close().expect("catalog group should finish"); + group.finish().expect("catalog group should finish"); assert!(matches!( consumer.poll_next(&kio::Waiter::noop()), @@ -392,7 +392,7 @@ mod test { group .write_frame(moq_net::Timestamp::ZERO, payload) .expect("catalog frame should write"); - group.close().expect("catalog group should finish"); + group.finish().expect("catalog group should finish"); assert_eq!(expect_catalog(consumer.poll_next(&waiter)), catalog); } @@ -410,13 +410,13 @@ mod test { old_group .write_frame(moq_net::Timestamp::ZERO, old_payload) .expect("old catalog frame should write"); - old_group.close().expect("old catalog group should finish"); + old_group.finish().expect("old catalog group should finish"); let mut latest_group = track.append_group(1).expect("latest catalog group should append"); latest_group .write_frame(moq_net::Timestamp::from_millis(1).unwrap(), latest_payload) .expect("latest catalog frame should write"); - latest_group.close().expect("latest catalog group should finish"); + latest_group.finish().expect("latest catalog group should finish"); let _track = track.finish().expect("catalog track should finish"); assert_eq!(expect_catalog(consumer.poll_next(&waiter)), latest); @@ -436,7 +436,7 @@ mod test { old_group .write_frame(moq_net::Timestamp::ZERO, old_payload) .expect("old catalog frame should write"); - old_group.close().expect("old catalog group should finish"); + old_group.finish().expect("old catalog group should finish"); let mut latest_group = track.append_group(1).expect("latest catalog group should append"); @@ -445,7 +445,7 @@ mod test { latest_group .write_frame(moq_net::Timestamp::from_millis(1).unwrap(), latest_payload) .expect("latest catalog frame should write"); - latest_group.close().expect("latest catalog group should finish"); + latest_group.finish().expect("latest catalog group should finish"); assert_eq!(expect_catalog(consumer.poll_next(&waiter)), latest); } @@ -467,7 +467,7 @@ mod test { latest_group .write_frame(moq_net::Timestamp::from_millis(1).unwrap(), latest_payload) .expect("latest catalog frame should write"); - latest_group.close().expect("latest catalog group should finish"); + latest_group.finish().expect("latest catalog group should finish"); let _track = track.finish().expect("catalog track should finish"); assert_eq!(expect_catalog(consumer.poll_next(&waiter)), latest); @@ -475,7 +475,7 @@ mod test { old_group .write_frame(moq_net::Timestamp::ZERO, old_payload) .expect("old catalog frame should write"); - old_group.close().expect("old catalog group should finish"); + old_group.finish().expect("old catalog group 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 75795805588..45d633d24ef 100644 --- a/rs/moq-mux/src/catalog/producer.rs +++ b/rs/moq-mux/src/catalog/producer.rs @@ -339,7 +339,7 @@ impl Outputs { #[cfg(test)] self.published[1].fetch_add(1, std::sync::atomic::Ordering::Relaxed); group.write_frame(at, msf)?; - group.close()?; + group.finish()?; Ok(()) } diff --git a/rs/moq-mux/src/codec/h264/export.rs b/rs/moq-mux/src/codec/h264/export.rs index b8e77bd31cf..751bfa02768 100644 --- a/rs/moq-mux/src/codec/h264/export.rs +++ b/rs/moq-mux/src/codec/h264/export.rs @@ -220,14 +220,14 @@ mod tests { // Group 0 (keyframe-starting group): one IDR frame. let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); write_length_prefixed(&mut g0, 0, &[idr]); - g0.close().unwrap(); + g0.finish().unwrap(); // Group 1 (next group): one P-slice. Consumer marks the first frame // of every group as keyframe by protocol invariant, so the exporter // MUST treat both group-starts as keyframes and inject SPS+PPS twice. let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); write_length_prefixed(&mut g1, 33_000, &[p_slice]); - g1.close().unwrap(); + g1.finish().unwrap(); let _track = track.finish().unwrap(); // Consumer side: run the exporter. @@ -335,7 +335,7 @@ mod tests { let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); let nals: &[&[u8]] = &[&[0x67, 0x42, 0, 0x1f], &[0x68, 0xce], &[0x65, 0x88]]; write_length_prefixed(&mut group, 0, nals); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let consumer = broadcast.consume(); let mut exporter = Export::new(crate::source::announced(&consumer).await, Once(Some(catalog))); diff --git a/rs/moq-mux/src/codec/h265/export.rs b/rs/moq-mux/src/codec/h265/export.rs index 46d376b7055..9d47e2dbabd 100644 --- a/rs/moq-mux/src/codec/h265/export.rs +++ b/rs/moq-mux/src/codec/h265/export.rs @@ -210,11 +210,11 @@ mod tests { let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); write_length_prefixed(&mut g0, 0, &[idr]); - g0.close().unwrap(); + g0.finish().unwrap(); let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); write_length_prefixed(&mut g1, 33_000, &[trail]); - g1.close().unwrap(); + g1.finish().unwrap(); let _track = track.finish().unwrap(); let consumer = broadcast.consume(); @@ -331,7 +331,7 @@ mod tests { let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); let nals: &[&[u8]] = &[&[0x40, 1, 0x0c], &[0x42, 1, 1], &[0x44, 1, 0xc0], &[0x26, 1, 0x88]]; write_length_prefixed(&mut group, 0, nals); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let consumer = broadcast.consume(); let mut exporter = Export::new(crate::source::announced(&consumer).await, Once(Some(catalog))); diff --git a/rs/moq-mux/src/container/consumer.rs b/rs/moq-mux/src/container/consumer.rs index 805ae842346..c9c766956c0 100644 --- a/rs/moq-mux/src/container/consumer.rs +++ b/rs/moq-mux/src/container/consumer.rs @@ -1857,7 +1857,7 @@ mod tests { .write(&mut group, &[frame]) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } /// Drain all available frames with a per-read timeout. @@ -1952,7 +1952,7 @@ mod tests { }], ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// Every item until the track ends: a frame as its timestamp in µs, a gap as its start and @@ -2046,7 +2046,7 @@ mod tests { write_group(&mut track, 0, &[ts(0), ts(10_000)]); let mut group = track.create_group(moq_net::group::Info { start: 20_000 }).unwrap(); group.write_frame(ts(20_000), Bytes::new()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); assert_eq!(items(&mut reader).await, ["0", "10000", "gap 10000+0", "end 10000"]); @@ -2063,7 +2063,7 @@ mod tests { assert!(matches!(reader.read().await.unwrap(), Some(Read::Frame { .. }))); let mut marker = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); marker.write_frame(ts(20_000), Bytes::new()).unwrap(); - marker.close().unwrap(); + marker.finish().unwrap(); if !budget.is_zero() { assert!(reader.poll_read(&kio::Waiter::noop()).is_pending()); @@ -2119,7 +2119,7 @@ mod tests { )); let mut marker = track.create_group(moq_net::group::Info { start: 4 }).unwrap(); marker.write_frame(ts(30_000), Bytes::new()).unwrap(); - marker.close().unwrap(); + marker.finish().unwrap(); assert!(reader.poll_read(&kio::Waiter::noop()).is_pending()); tokio::time::advance(Duration::from_millis(99)).await; assert!(reader.poll_read(&kio::Waiter::noop()).is_pending()); @@ -2162,7 +2162,7 @@ mod tests { let mut marker = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); marker.write_frame(ts(66_000), Bytes::new()).unwrap(); - marker.close().unwrap(); + marker.finish().unwrap(); assert!(matches!(reader.read().await.unwrap(), Some(Read::End { group: 2, .. }))); assert_eq!(reader.arrival(), Some(second), "an end carries no arrival of its own"); } @@ -2277,7 +2277,7 @@ mod tests { Container::Legacy(crate::container::Kind::Audio) .write(&mut open, &[frame]) .unwrap(); - open.close().unwrap(); + open.finish().unwrap(); assert!(matches!( reader.read().await.unwrap(), Some(Read::Frame { group: 5, .. }) @@ -2412,7 +2412,7 @@ mod tests { write_group(&mut track, 1, &[ts(500_000)]); tokio::time::advance(Duration::from_millis(500)).await; assert_eq!(drain(&mut reader), ["frame 0"]); - stalled.close().unwrap(); + stalled.finish().unwrap(); assert_eq!(drain(&mut reader), ["frame 1"]); // A missing group expires the wait after the first group past it arrived. @@ -2467,7 +2467,7 @@ mod tests { } .write_to(&mut group) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); write_group(&mut track, 2, &[ts(1_000_000)]); let read = loop { @@ -2530,7 +2530,7 @@ mod tests { .unwrap(), } } - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let error = loop { @@ -2650,7 +2650,7 @@ mod tests { .unwrap() .write(&mut group, &[packet]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let _track = track.finish().unwrap(); assert_eq!(items(&mut reader).await, ["0", "20000", "gap 40000+20000", "60000"]); @@ -2708,7 +2708,7 @@ mod tests { ], ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let _track = track.finish().unwrap(); assert_eq!(items(&mut reader).await, ["0", "33000"]); @@ -2736,7 +2736,7 @@ mod tests { &[frame(50_000, Bytes::new()), frame(40_000, Bytes::from_static(&[1]))], ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); assert_eq!(items(&mut reader).await, ["0", "20000", "end 50000", "40000"]); } @@ -2791,7 +2791,7 @@ mod tests { track .create_group(moq_net::group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); write_group(&mut track, 2, &[ts(1_000)]); let _track = track.finish().unwrap(); @@ -2929,7 +2929,7 @@ mod tests { // Finish group 0 after consumer has had time to accumulate pending groups let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(50)).await; - group0.close().unwrap(); + group0.finish().unwrap(); }); let frames = read_all(&mut consumer).await.unwrap(); @@ -2973,7 +2973,7 @@ mod tests { let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(50)).await; - group0.close().unwrap(); + group0.finish().unwrap(); }); let frames = read_all(&mut consumer).await.unwrap(); @@ -3014,7 +3014,7 @@ mod tests { let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(50)).await; - group0.close().unwrap(); + group0.finish().unwrap(); }); let frames = read_all(&mut consumer).await.unwrap(); @@ -3070,7 +3070,7 @@ mod tests { assert_eq!(read(&mut consumer), None, "cut group 0 short"); write(&mut group0, ts(1_000_000)); assert_eq!(read(&mut consumer), Some(ts(1_000_000))); - group0.close().unwrap(); + group0.finish().unwrap(); assert_eq!(read(&mut consumer), Some(ts(2_500_000))); // Once the reach falls a full budget behind, the stalled group is skipped. @@ -3079,8 +3079,8 @@ mod tests { write(&mut group2, ts(7_000_000)); assert_eq!(read(&mut consumer), Some(ts(3_000_000))); assert_eq!(read(&mut consumer), Some(ts(5_000_000))); - group1.close().unwrap(); - group2.close().unwrap(); + group1.finish().unwrap(); + group2.finish().unwrap(); } /// A backlog that lands whole before the first read starts at the first group whose first @@ -3111,7 +3111,7 @@ mod tests { ) .unwrap(); if !open { - last.close().unwrap(); + last.finish().unwrap(); } let mut read = Vec::new(); @@ -3168,7 +3168,7 @@ mod tests { ) .unwrap(); } - fifth.close().unwrap(); + fifth.finish().unwrap(); drain(&mut consumer); let expected: Vec<_> = frames(3).into_iter().chain(frames(4)).chain([ts(5_000_000)]).collect(); @@ -3310,7 +3310,7 @@ mod tests { ], ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(0)); assert!(matches!( consumer.read().await.unwrap(), @@ -3364,7 +3364,7 @@ mod tests { assert!(matches!(consumer.read().await.unwrap(), Some(Read::Gap { .. }))); assert_eq!(consumer.read_frame().await.unwrap().unwrap().timestamp, ts(10_000)); - group0.close().unwrap(); + group0.finish().unwrap(); } #[kio::test] @@ -3430,7 +3430,7 @@ mod tests { .write(&mut group, &[media(ts(33_000))]) .unwrap(); write_marker(&mut group, ts(50_000)); // the group's end - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); @@ -3460,7 +3460,7 @@ mod tests { }], ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let frame = consumer.read_frame().await.unwrap().unwrap(); @@ -3494,7 +3494,7 @@ mod tests { for i in 1..5u64 { write_marker(&mut group, ts(i * 1_000)); } - group.close().unwrap(); + group.finish().unwrap(); write_group(&mut track, 1, &[ts(100_000)]); let _track = track.finish().unwrap(); @@ -3533,7 +3533,7 @@ mod tests { }], ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); @@ -3571,7 +3571,7 @@ mod tests { let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(10)).await; - group0.close().unwrap(); + group0.finish().unwrap(); }); let frames = read_all(&mut consumer).await.unwrap(); @@ -3942,7 +3942,7 @@ mod tests { }], ) .unwrap(); - group0.close().unwrap(); + group0.finish().unwrap(); let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); @@ -4121,7 +4121,7 @@ mod tests { ); write(&mut covering, 4_950_000); - covering.close().unwrap(); + covering.finish().unwrap(); let _track = track.finish().unwrap(); let micros: Vec = read_all(&mut consumer) .await @@ -4473,7 +4473,7 @@ mod tests { group .write_frame(moq_net::Timestamp::ZERO, Bytes::from_static(b"FAIL")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); // The first frame decodes; the malformed second frame must surface as an error. @@ -4527,7 +4527,7 @@ mod tests { let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); write_failing(&mut group, None); write_failing(&mut group, Some(0)); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let read = read_past_frames(&mut consumer).await; @@ -4547,7 +4547,7 @@ mod tests { let mut group = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); write_failing(&mut group, None); write_failing(&mut group, Some(0)); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let event = kio::wait(|waiter| consumer.poll_event(waiter)).await; @@ -4569,7 +4569,7 @@ mod tests { let mut malformed = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); write_failing(&mut malformed, None); let malformed_demand = malformed.demand(); - let _malformed = malformed.close().unwrap(); + let _malformed = malformed.finish().unwrap(); let mut later = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); write_failing(&mut later, Some(10_000)); @@ -4597,7 +4597,7 @@ mod tests { write_failing(&mut group, Some(10_000)); write_failing(&mut group, None); write_failing(&mut group, Some(20_000)); - group.close().unwrap(); + group.finish().unwrap(); let first = consumer.read_frame().await.unwrap().unwrap(); assert_eq!(first.timestamp, ts(0)); @@ -4608,7 +4608,7 @@ mod tests { .is_err() ); - slow.close().unwrap(); + slow.finish().unwrap(); let frame = consumer.read_frame().await.unwrap().unwrap(); assert_eq!(frame.timestamp, ts(10_000)); let read = kio::clock::timeout(Duration::from_millis(50), consumer.read()).await; @@ -4637,13 +4637,13 @@ mod tests { let mut later = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); write_failing(&mut later, None); - later.close().unwrap(); + later.finish().unwrap(); for expected in [10_000, 20_000] { let frame = consumer.read_frame().await.unwrap().unwrap(); assert_eq!(frame.timestamp, ts(expected)); } - current.close().unwrap(); + current.finish().unwrap(); let read = read_past_frames(&mut consumer).await; assert!(matches!(read, Err(crate::Error::UnknownFormat(_))), "{read:?}"); } @@ -4666,12 +4666,12 @@ mod tests { let mut malformed = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); write_failing(&mut malformed, Some(110_000)); malformed.write_frame(ts(110_000), Bytes::from_static(b"FAIL")).unwrap(); - malformed.close().unwrap(); + malformed.finish().unwrap(); // The transport only checks a group's first frame, so the rewind is its second. let mut rewound = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); write_failing(&mut rewound, Some(150_000)); write_failing(&mut rewound, Some(50_000)); - rewound.close().unwrap(); + rewound.finish().unwrap(); // The reader looks ahead into both while it waits on the open group. assert!( kio::clock::timeout(Duration::from_millis(50), consumer.read()) @@ -4679,7 +4679,7 @@ mod tests { .is_err() ); - current.close().unwrap(); + current.finish().unwrap(); let _track = track.finish().unwrap(); let read = read_past_frames(&mut consumer).await; assert!(matches!(read, Err(crate::Error::UnknownFormat(_))), "{read:?}"); @@ -4697,10 +4697,10 @@ mod tests { let mut old = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); write_failing(&mut old, None); - old.close().unwrap(); + old.finish().unwrap(); let mut newest = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); write_failing(&mut newest, Some(10_000)); - newest.close().unwrap(); + newest.finish().unwrap(); let _track = track.finish().unwrap(); let read = read_past_frames(&mut consumer).await; @@ -4736,7 +4736,7 @@ mod tests { let frame = consumer.read_frame().await.unwrap().unwrap(); assert_eq!(frame.timestamp, ts(10_000)); - current.close().unwrap(); + current.finish().unwrap(); let _track = track.finish().unwrap(); let read = read_past_frames(&mut consumer).await; assert!(matches!(read, Err(crate::Error::UnknownFormat(_))), "{read:?}"); @@ -4774,7 +4774,7 @@ mod tests { write_failing(&mut group, Some(0)); write_failing(&mut group, None); write_failing(&mut group, Some(10_000)); - let group = group.close().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)); @@ -4816,7 +4816,7 @@ mod tests { }], ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); @@ -4862,7 +4862,7 @@ mod tests { // Write group 2: recv_group fires, drops current buffer_until for group 1 write_group(&mut track, 2, &[ts(200_000)]); kio::clock::sleep(Duration::from_millis(20)).await; - group0.close().unwrap(); + group0.finish().unwrap(); let _track = track.finish().unwrap(); }); @@ -4953,7 +4953,7 @@ mod tests { let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(50)).await; - group0.close().unwrap(); + group0.finish().unwrap(); }); let frames = kio::clock::timeout(Duration::from_secs(2), async { @@ -5014,7 +5014,7 @@ mod tests { }], ) .unwrap(); - group7.close().unwrap(); + group7.finish().unwrap(); let _track = track.finish().unwrap(); }); @@ -5134,7 +5134,7 @@ mod tests { }], ) .unwrap(); - group0.close().unwrap(); + group0.finish().unwrap(); let frames = read_all(&mut consumer).await.unwrap(); let micros: Vec = frames.iter().map(|f| f.timestamp.as_micros().unwrap()).collect(); @@ -5365,7 +5365,7 @@ mod tests { let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(20)).await; - group0.close().unwrap(); + group0.finish().unwrap(); }); let frames = read_all(&mut consumer).await.unwrap(); @@ -5401,7 +5401,7 @@ mod tests { let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(20)).await; - group0.close().unwrap(); + group0.finish().unwrap(); }); let frames = read_all(&mut consumer).await.unwrap(); @@ -5443,7 +5443,7 @@ mod tests { let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(50)).await; - group0.close().unwrap(); + group0.finish().unwrap(); }); let frames = read_all(&mut consumer).await.unwrap(); @@ -5514,7 +5514,7 @@ mod tests { .write(&mut group0, &[frame]) .unwrap(); } - let group0 = group0.close().unwrap(); + let group0 = group0.finish().unwrap(); write_group(&mut track, 1, &[ts(30_000)]); let _track = track.finish().unwrap(); @@ -5602,7 +5602,7 @@ mod tests { let mut consumer = Consumer::new(consumer_track, Container::Legacy(crate::container::Kind::Data)); let group0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); - group0.close().unwrap(); + group0.finish().unwrap(); write_group(&mut track, 1, &[ts(30_000)]); let _track = track.finish().unwrap(); @@ -5636,7 +5636,7 @@ mod tests { .write(&mut group, &[frame]) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let mut frames = Vec::new(); @@ -5677,7 +5677,7 @@ mod tests { // Group 1: finished, starts exactly where group 0's frame ends. let mut group1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); write_duration_frame(&mut group1, ts(33_000), ts(33_000)); - group1.close().unwrap(); + group1.finish().unwrap(); let _track = track.finish().unwrap(); @@ -5704,10 +5704,10 @@ mod tests { ); let mut group0 = track.create_group(moq_net::group::Info { start: 1_000_000 }).unwrap(); write_duration_frame(&mut group0, ts(0), ts(33_000)); - group0.close().unwrap(); + group0.finish().unwrap(); let mut group1 = track.create_group(moq_net::group::Info { start: 1_090_000 }).unwrap(); write_duration_frame(&mut group1, ts(33_000), ts(33_000)); - group1.close().unwrap(); + group1.finish().unwrap(); let _track = track.finish().unwrap(); let frames = continuous_frames(&mut consumer).await; assert_eq!(frames.len(), 2); @@ -5733,7 +5733,7 @@ mod tests { // Group 1: finished at 33ms. let mut group1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); write_duration_frame(&mut group1, ts(33_000), ts(33_000)); - group1.close().unwrap(); + group1.finish().unwrap(); let _track = track.finish().unwrap(); // A second frame lands on group 0 and finishes it after the consumer has @@ -5741,7 +5741,7 @@ mod tests { let finisher = tokio::spawn(async move { kio::clock::sleep(Duration::from_millis(20)).await; write_duration_frame(&mut group0, ts(20_000), ts(10_000)); - group0.close().unwrap(); + group0.finish().unwrap(); }); let frames = kio::clock::timeout(Duration::from_secs(2), async { @@ -5922,7 +5922,7 @@ mod tests { }], ) .unwrap(); - markers.close().unwrap(); + markers.finish().unwrap(); // The markers fill the max buffer behind the stalled group, which moves the cursor on to them, // and the media past them still plays. @@ -5985,7 +5985,7 @@ mod tests { wire.push(0xAD); padded.write_frame(ts(timestamp as u64), wire).unwrap(); } - padded.close().unwrap(); + padded.finish().unwrap(); let mut reads = Vec::new(); while let Poll::Ready(read) = consumer.poll_read(&waiter) { @@ -6052,7 +6052,7 @@ mod tests { }], ) .unwrap(); - later.close().unwrap(); + later.finish().unwrap(); (stalled, between) } @@ -6092,7 +6092,7 @@ mod tests { let (_stalled, mut between) = fill_behind_a_stalled_group(&mut track, &mut consumer, &waiter); between.write_frame(ts(10_000), Bytes::new()).unwrap(); - between.close().unwrap(); + between.finish().unwrap(); let mut reads = Vec::new(); while let Poll::Ready(read) = consumer.poll_read(&waiter) { reads.push(match read.unwrap() { @@ -6126,11 +6126,11 @@ mod tests { }], ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut marker = track.create_group(moq_net::group::Info { start: 3 }).unwrap(); marker.write_frame(ts(20_000), Bytes::new()).unwrap(); - marker.close().unwrap(); + marker.finish().unwrap(); // The reader gets to the track only after the hole before group 3 has expired. tokio::time::advance(2 * max_delay).await; @@ -6155,7 +6155,7 @@ mod tests { let marker = |track: &mut moq_net::track::Producer, sequence: u64| { let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); group.write_frame(ts(sequence * 10_000), Bytes::new()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; write_group(&mut track, 0, &[ts(0)]); marker(&mut track, 5); @@ -6263,7 +6263,7 @@ mod tests { consumer.pending.iter().all(|group| group.is_empty()), "receipt must not decode payload" ); - group.close().unwrap(); + group.finish().unwrap(); assert!(consumer.poll_received(&kio::Waiter::noop()).is_ready()); let mut frames = Vec::new(); while let Some(frame) = consumer.read_frame().await.unwrap() { diff --git a/rs/moq-mux/src/container/fmp4/export_test.rs b/rs/moq-mux/src/container/fmp4/export_test.rs index 2ece4b923a0..900fefcea11 100644 --- a/rs/moq-mux/src/container/fmp4/export_test.rs +++ b/rs/moq-mux/src/container/fmp4/export_test.rs @@ -2215,7 +2215,7 @@ async fn cmaf_source_exports_at_the_frame_timestamp() { group .write_frame(moq_net::Timestamp::from_secs(10).unwrap(), fragment) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let catalog_stream = crate::catalog::Consumer::<()>::new(&consumer, crate::catalog::CatalogFormat::Hang) diff --git a/rs/moq-mux/src/container/fmp4/import.rs b/rs/moq-mux/src/container/fmp4/import.rs index e1d3202aeeb..f2aefd1ecb4 100644 --- a/rs/moq-mux/src/container/fmp4/import.rs +++ b/rs/moq-mux/src/container/fmp4/import.rs @@ -197,7 +197,7 @@ impl Passthrough { self.estimator.cut(None); self.publish_estimate()?; if let Some(group) = self.group.take() { - group.close()?; + group.finish()?; } Ok(()) } @@ -1622,7 +1622,7 @@ impl Passthrough { }; let group = if start_group { if let Some(prev) = self.group.take() { - prev.close()?; + prev.finish()?; } match (self.pending_start.take(), start) { (Some(start), _) => self.track.create_group(moq_net::group::Info { start })?, diff --git a/rs/moq-mux/src/container/group.rs b/rs/moq-mux/src/container/group.rs index 5757b366a76..e395f5eabe8 100644 --- a/rs/moq-mux/src/container/group.rs +++ b/rs/moq-mux/src/container/group.rs @@ -215,7 +215,7 @@ mod tests { assert_eq!(second.payload, b"delta".as_slice()); assert!(live.read().now_or_never().is_none(), "the open group has nothing more"); - group.close().unwrap(); + group.finish().unwrap(); assert!(live.read().await.unwrap().is_none()); } diff --git a/rs/moq-mux/src/container/producer.rs b/rs/moq-mux/src/container/producer.rs index 4936a67ddb2..d5180bed921 100644 --- a/rs/moq-mux/src/container/producer.rs +++ b/rs/moq-mux/src/container/producer.rs @@ -804,8 +804,8 @@ where } if let Some(group) = self.group.take() { match bound.and_then(|bound| crate::start::end(&self.inner, group.start, bound)) { - Some(end) => group.finish(end)?, - None => group.close()?, + Some(end) => group.finish_at(end)?, + None => group.finish()?, }; // Only a closed group reaches anything; a cut with none open names a point nothing reached. if let Some(end) = reached { @@ -964,7 +964,7 @@ where }], )?, } - group.close()?; + group.finish()?; Ok(()) } @@ -1068,16 +1068,10 @@ where let _ = self.inner.clone().abort(cause.reason()); return Err(cause); } + // The producer keeps its own clone, whose appends the end refuses. match err { - // The producer keeps its own clone, whose appends the end refuses. None => drop(self.inner.clone().finish()?), - Some(err) => { - let next = self - .inner - .largest() - .map_or(0, |largest| largest.group.saturating_add(1)); - self.inner.finish_at(moq_net::track::Position::group(next), Some(err))?; - } + Some(err) => drop(self.inner.clone().fail(err)?), } let published = self.publish_estimate(); // A track that ended before measuring declares what it saw, and no longer holds the join diff --git a/rs/moq-mux/src/container/source.rs b/rs/moq-mux/src/container/source.rs index b587746e209..f0402d66cb1 100644 --- a/rs/moq-mux/src/container/source.rs +++ b/rs/moq-mux/src/container/source.rs @@ -1256,7 +1256,7 @@ mod tests { let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); wire.write(&mut group, &[raw_frame(sequence * 24_000, b"audio", true)]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; let mut read = async || { kio::clock::timeout(Duration::from_millis(100), kio::wait(|waiter| export.poll_read(waiter))) @@ -1339,7 +1339,7 @@ mod tests { let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); wire.write(&mut group, &[raw_frame(sequence * 24_000, b"audio", true)]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } }; // About two seconds of it, so the budget's backlog reaches back about 450 ms. @@ -1482,10 +1482,10 @@ mod tests { group }; // Group 1 is missing whole; group 3 is cut short after its first frame. - group(0, 0).close().unwrap(); - group(2, 40_000).close().unwrap(); + group(0, 0).finish().unwrap(); + group(2, 40_000).finish().unwrap(); let cut = group(3, 60_000); - group(4, 80_000).close().unwrap(); + group(4, 80_000).finish().unwrap(); let _track = track.finish().unwrap(); let waiter = kio::Waiter::noop(); @@ -1512,7 +1512,7 @@ mod tests { for (sequence, timestamp, payload) in [(0, 0, b"audio".as_slice()), (2, 1_000_000, b"".as_slice())] { let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); wire.write(&mut group, &[raw_frame(timestamp, payload, true)]).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let _track = track.finish().unwrap(); let waiter = kio::Waiter::noop(); @@ -1563,7 +1563,7 @@ mod tests { ] { let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); wire.write(&mut group, &frames).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let _track = track.finish().unwrap(); let waiter = kio::Waiter::noop(); diff --git a/rs/moq-mux/src/container/ts/export_test.rs b/rs/moq-mux/src/container/ts/export_test.rs index 90493d18f9b..9afeb84d133 100644 --- a/rs/moq-mux/src/container/ts/export_test.rs +++ b/rs/moq-mux/src/container/ts/export_test.rs @@ -255,7 +255,7 @@ async fn a_follower_keeps_msf_after_catalog_eof() { let msf = moq_msf::Catalog::<()>::new(Vec::new()).to_json().unwrap(); let mut group = track.append_group(0).unwrap(); group.write_frame(moq_net::Timestamp::ZERO, msf).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); broadcast.announce().unwrap(); (broadcast, track) }; @@ -1026,7 +1026,7 @@ async fn export_trims_leading_pictures_after_each_delivery_break() { }) .collect(); format.write(&mut group, &frames).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let _track = track.finish().unwrap(); let mut export = open_export(crate::source::announced(&consumer).await, RECORDING_MAX_AGE) @@ -1331,7 +1331,7 @@ async fn export_declared(reorder: u8, groups: &[&[u64]]) -> (Export(format).await.unwrap(); let follow = Duration::from_secs(10); diff --git a/rs/moq-mux/src/container/ts/export_timing_test.rs b/rs/moq-mux/src/container/ts/export_timing_test.rs index f554d1a4d4f..c59dfb1520e 100644 --- a/rs/moq-mux/src/container/ts/export_timing_test.rs +++ b/rs/moq-mux/src/container/ts/export_timing_test.rs @@ -282,7 +282,7 @@ impl Live { match std::mem::take(&mut self.stalling) { true => self.stalled.push(group), false => { - group.close().unwrap(); + group.finish().unwrap(); } } } @@ -380,7 +380,7 @@ impl Live { /// End the media tracks while the catalog can still announce more. fn finish_media(&mut self) { if let Some(group) = self.group.take() { - group.close().unwrap(); + group.finish().unwrap(); } self.stalled.clear(); drop(self.video.clone().finish().unwrap()); @@ -520,7 +520,7 @@ async fn end_waits_for_catalog_and_media() { // Catalog EOF fixes the layout, but the named tracks can still publish media. live.run(3 * GOP, &mut [&mut leg], |_| false); // Close the groups so their tails flush, leaving both tracks open for more. - live.group.take().unwrap().close().unwrap(); + live.group.take().unwrap().finish().unwrap(); live.audio.cut(None).unwrap(); 3 * GOP as usize } else { @@ -980,14 +980,14 @@ async fn a_successor_settles_held_video_across_a_skip_or_restart() { live.run(8 * GOP + tail, &mut [&mut leg], |_| false); live.fall_silent(Duration::from_secs(3), &mut [&mut leg]); if restart { - live.group.take().unwrap().close().unwrap(); + live.group.take().unwrap().finish().unwrap(); // A microsecond before the keyframe that resumes: group starts strictly increase. let at = live.tick * VIDEO_US - 1; let mut marker = live.video.append_group(at).unwrap(); HangContainer::Legacy(crate::container::Kind::Video) .write(&mut marker, &[crate::container::test_util::raw_frame(at, b"", true)]) .unwrap(); - marker.close().unwrap(); + marker.finish().unwrap(); } else { // Leave the old group blocked so the successor makes the consumer skip it. live.stalling = true; @@ -1016,7 +1016,7 @@ async fn a_clean_group_end_settles_held_video_before_a_silence() { let mut leg = live.join(Duration::ZERO).await; let tail = if declared { 2 } else { 8 }; live.run(8 * GOP + tail, &mut [&mut leg], |_| false); - live.group.take().unwrap().close().unwrap(); + live.group.take().unwrap().finish().unwrap(); leg.poll_now(); live.fall_silent(Duration::from_secs(3), &mut [&mut leg]); live.run(live.tick + 8 * GOP, &mut [&mut leg], |_| false); diff --git a/rs/moq-mux/src/container/ts/recovery_test.rs b/rs/moq-mux/src/container/ts/recovery_test.rs index 2b21c45c31a..4b894349a5c 100644 --- a/rs/moq-mux/src/container/ts/recovery_test.rs +++ b/rs/moq-mux/src/container/ts/recovery_test.rs @@ -969,10 +969,10 @@ async fn run(recording: &Recording, arm: &Arm) -> Run { let group = open[t].take().unwrap(); match (kept[t] == frames.len(), ends[t][g]) { (true, Some(end)) => { - group.finish(end).unwrap(); + group.finish_at(end).unwrap(); } (true, None) => { - group.close().unwrap(); + group.finish().unwrap(); } (false, _) => group.abort(moq_net::Error::Old).unwrap(), } diff --git a/rs/moq-mux/src/container/ts/release_test.rs b/rs/moq-mux/src/container/ts/release_test.rs index 0190a4d22c4..9ad5c650e97 100644 --- a/rs/moq-mux/src/container/ts/release_test.rs +++ b/rs/moq-mux/src/container/ts/release_test.rs @@ -174,7 +174,7 @@ 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.close().unwrap(); + group.finish().unwrap(); } } } diff --git a/rs/moq-mux/src/container/ts/si.rs b/rs/moq-mux/src/container/ts/si.rs index 1b345d313da..faf40aeab86 100644 --- a/rs/moq-mux/src/container/ts/si.rs +++ b/rs/moq-mux/src/container/ts/si.rs @@ -454,7 +454,7 @@ impl Entry { for payload in frames { group.write_frame(pts, payload)?; } - group.close()?; + group.finish()?; self.last_cut = Some(now); Ok(()) } diff --git a/rs/moq-mux/src/linger.rs b/rs/moq-mux/src/linger.rs index 536144e6c7e..fb803e1e6ec 100644 --- a/rs/moq-mux/src/linger.rs +++ b/rs/moq-mux/src/linger.rs @@ -98,12 +98,14 @@ mod tests { let info = moq_net::track::Info::default().with_max_age(hang::container::MAX_AGE); let track = route.broadcast().create_track("video", info).unwrap(); for _ in 0..3 { - let key = track.largest().map_or(0, |largest| largest.group + 1); - let mut group = track.append_group(key).unwrap(); + let mut group = track.append_group(None).unwrap(); group - .write_frame(moq_net::Timestamp::unscaled(key), bytes::Bytes::from_static(b"frame")) + .write_frame( + moq_net::Timestamp::unscaled(group.start), + bytes::Bytes::from_static(b"frame"), + ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let track = track.finish().unwrap(); (route.broadcast().clone(), (route, track)) diff --git a/rs/moq-mux/tests/legacy_audio.rs b/rs/moq-mux/tests/legacy_audio.rs index 7a8c2ed4812..cbf14ed6b67 100644 --- a/rs/moq-mux/tests/legacy_audio.rs +++ b/rs/moq-mux/tests/legacy_audio.rs @@ -156,7 +156,7 @@ async fn a_dropped_run_waits_for_the_next_groups_first_packet() { duration: None, }; container.write(&mut group, &[packet]).unwrap(); - group.finish(start + 20_000).unwrap(); + group.finish_at(start + 20_000).unwrap(); let read = kio::clock::timeout(TIMEOUT, reader.read()) .await .unwrap_or_else(|_| panic!("{version}: packet {n} never read")) diff --git a/rs/moq-net-tests/tests/integration/ietf_conformance.rs b/rs/moq-net-tests/tests/integration/ietf_conformance.rs index a9e3d04130f..3ad35b361aa 100644 --- a/rs/moq-net-tests/tests/integration/ietf_conformance.rs +++ b/rs/moq-net-tests/tests/integration/ietf_conformance.rs @@ -75,7 +75,7 @@ async fn routing(version: &str, cluster: bool) { group .write_frame(moq_net::Timestamp::unscaled(0), &b"conformance"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let track = track.finish().unwrap(); let mut received = subscription.recv_group().await.unwrap().unwrap(); assert_eq!(received.start, 0); diff --git a/rs/moq-net-tests/tests/integration/restart.rs b/rs/moq-net-tests/tests/integration/restart.rs index e2615cff19f..0758138df34 100644 --- a/rs/moq-net-tests/tests/integration/restart.rs +++ b/rs/moq-net-tests/tests/integration/restart.rs @@ -8,7 +8,6 @@ //! instance's cached groups. use crate::support; -use support::AppendNext; use std::{cell::RefCell, rc::Rc, time::Duration}; @@ -98,10 +97,10 @@ async fn quiet(version: Version, announced: &mut origin::Routes) { /// Write the next group of one frame tagged `tag`, starting at its key in milliseconds. fn write(track: &track::Producer, tag: &str) { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); let start = Timestamp::from_millis(group.start).unwrap(); group.write_frame(start, tag.as_bytes().to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// The next frame a subscription delivers, as text. diff --git a/rs/moq-net-tests/tests/integration/serve.rs b/rs/moq-net-tests/tests/integration/serve.rs index 93517c30b37..4fcfadd1ae3 100644 --- a/rs/moq-net-tests/tests/integration/serve.rs +++ b/rs/moq-net-tests/tests/integration/serve.rs @@ -39,7 +39,7 @@ async fn first_subscribe(version: &str, publish: bool) { .unwrap(); let mut group = held_track.append_group(0).unwrap(); group.write_frame(Timestamp::ZERO, b"held".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let handler = async { if publish { let prepared = requests @@ -57,7 +57,7 @@ async fn first_subscribe(version: &str, publish: bool) { .unwrap(); let mut group = track.append_group(0).unwrap(); group.write_frame(Timestamp::ZERO, b"held".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); prepared.announce().unwrap(); Some((prepared, track)) } else { diff --git a/rs/moq-net-tests/tests/integration/snapshot.rs b/rs/moq-net-tests/tests/integration/snapshot.rs index 4c1119dce5f..0d97cffa54a 100644 --- a/rs/moq-net-tests/tests/integration/snapshot.rs +++ b/rs/moq-net-tests/tests/integration/snapshot.rs @@ -28,7 +28,7 @@ fn reads_skip_an_owed_hole() { serde_json::to_vec(&json!({ "n": start })).unwrap(), ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; put(0); diff --git a/rs/moq-net/benches/group.rs b/rs/moq-net/benches/group.rs index 91211f4e8f8..ea0cb503eb1 100644 --- a/rs/moq-net/benches/group.rs +++ b/rs/moq-net/benches/group.rs @@ -168,7 +168,7 @@ fn filled_group(n: usize, payload: &Bytes) -> (Ctx, group::Cons for _ in 0..n { group.write_frame(Timestamp::ZERO, payload.clone()).unwrap(); } - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let consumer = group.consume(); ( Ctx { @@ -264,7 +264,7 @@ fn filled_track(n: usize, payload: &Bytes) -> TrackCtx { for key in 0..n as u64 { let mut group = track.append_group(key).unwrap(); group.write_frame(at(key), payload.clone()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } TrackCtx { _broadcast: broadcast, @@ -341,7 +341,7 @@ fn bench_track_recv(c: &mut Criterion) { for key in (n..n + LIVE_BATCH).map(|key| key as u64) { let mut group = ctx.track.append_group(key).unwrap(); group.write_frame(at(key), payload.clone()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let group = subscriber.recv_group().now_or_never().unwrap().unwrap().unwrap(); black_box(group); } @@ -367,7 +367,7 @@ fn bench_roundtrip(c: &mut Criterion) { for _ in 0..n { ctx.group.write_frame(Timestamp::ZERO, payload.clone()).unwrap(); } - let group = ctx.group.close().unwrap(); + 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(); @@ -456,7 +456,7 @@ fn bench_stamp(c: &mut Criterion) { for key in n as u64..n as u64 + batch { let mut group = ctx.track.append_group(key).unwrap(); group.write_frame(at(key), payload.clone()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } total += start.elapsed(); left -= batch; @@ -518,7 +518,7 @@ fn bench_inflate(c: &mut Criterion) { for payload in &payloads { group.write_frame(at(key), payload.clone()).unwrap(); } - let group = group.close().unwrap(); + let group = group.finish().unwrap(); (0..readers).map(move |_| group.consume()).collect::>() }) .collect(); @@ -565,7 +565,7 @@ fn bench_compressed_updates(c: &mut Criterion) { group .write_frame(moq_net::Timestamp::unscaled(group.start), payload.clone()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); track }) .collect(); @@ -583,7 +583,7 @@ fn bench_compressed_updates(c: &mut Criterion) { groups.push(group); } for group in groups.drain(..) { - group.close().unwrap(); + group.finish().unwrap(); } } } @@ -800,7 +800,7 @@ fn contended( let rolled = track.append_group(key).unwrap(); *next.lock().unwrap() = rolled.consume(); let done = std::mem::replace(&mut group, rolled); - done.close().unwrap(); + done.finish().unwrap(); written = 0; } for _ in 0..burst { @@ -920,7 +920,7 @@ fn streaming(b: &mut criterion::Bencher, chunk: &Bytes, arrivals: usize, threads key += 1; let rolled = track.append_group(key).unwrap(); *next.lock().unwrap() = rolled.consume(); - group.close().unwrap(); + group.finish().unwrap(); frames = 0; rolled.create_frame(info(key)).unwrap() } else { @@ -1110,7 +1110,7 @@ fn replay_flights(ctx: &Flights, payloads: &[Bytes], readers: usize, apart: usiz *read += 1; } } - while let Poll::Ready(Ok(fill)) = ctx.requests.poll_requested_fill(&waiter) { + while let Poll::Ready(Ok(track::Fill::Groups(fill))) = ctx.requests.poll_requested_fill(&waiter) { let start = fill.start(); let group = fill.accept(start.group, None).unwrap(); let demand = group.demand(); diff --git a/rs/moq-net/benches/memory.rs b/rs/moq-net/benches/memory.rs index f3ddc709278..53612f5ae29 100644 --- a/rs/moq-net/benches/memory.rs +++ b/rs/moq-net/benches/memory.rs @@ -211,7 +211,7 @@ impl Link { for _ in 0..FRAMES { group.write_frame(timestamp, self.payload.clone()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } let mut bytes = 0; diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index 49514f7158b..283b261287e 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -1117,7 +1117,7 @@ fn bench_handoff(c: &mut Criterion) { let track = incumbent.broadcast().create_track("video", timed()).unwrap(); let mut first = track.append_group(0).unwrap(); first.write_frame(Timestamp::ZERO, b"one".as_ref()).unwrap(); - first.close().unwrap(); + first.finish().unwrap(); let resolved = consumer.request("room/live", None).await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -1130,7 +1130,7 @@ fn bench_handoff(c: &mut Criterion) { let track = standby.broadcast().create_track("video", timed()).unwrap(); let mut second = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); second.write_frame(at(1), b"two".as_ref()).unwrap(); - second.close().unwrap(); + second.finish().unwrap(); // Announcing is what makes the standby a route the front can take. standby.announce().unwrap(); let replaced = consumer.request("room/live", None).await.unwrap(); @@ -1238,7 +1238,7 @@ impl Watching { for track in &self.tracks[..self.subscriptions.len()] { let mut group = track.append_group(key).unwrap(); group.write_frame(at(key), b"frame".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } for subscription in &mut self.subscriptions { subscription.recv_group().await.unwrap().expect("track ended"); @@ -1366,7 +1366,7 @@ fn bench_relay(c: &mut Criterion) { for _ in 0..RELAY_FRAMES { group.write_frame(at(key), b"frame".as_ref()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } for subscription in &mut subscriptions { let mut group = subscription.recv_group().await.unwrap().expect("group"); @@ -1427,7 +1427,7 @@ fn bench_passthrough(c: &mut Criterion) { next += 1; let mut group = source.append_group(key).unwrap(); group.write_frame(at(key), b"frame".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); for (subscription, held) in subscriptions.iter_mut().zip(&mut held) { held.push(subscription.recv_group().await.unwrap().expect("group")); } @@ -1532,7 +1532,7 @@ impl Generation { let track = broadcast.broadcast().create_track(format!("{i}"), timed()).unwrap(); let mut written = track.append_group(0).unwrap(); written.write_frame(Timestamp::ZERO, b"f".as_ref()).unwrap(); - written.close().unwrap(); + written.finish().unwrap(); held.push(track); } Self { @@ -1737,7 +1737,7 @@ async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap { for key in order { let mut group = track.create_group(moq_net::group::Info { start: key as u64 }).unwrap(); group.write_frame(at(key as u64), b"f".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } broadcast.announce().unwrap(); (broadcast, track) diff --git a/rs/moq-net/benches/ranges.rs b/rs/moq-net/benches/ranges.rs index f2ea9e247e2..34b71a6e009 100644 --- a/rs/moq-net/benches/ranges.rs +++ b/rs/moq-net/benches/ranges.rs @@ -53,7 +53,7 @@ fn millis(millis: u64) -> Timestamp { fn land(track: &track::Producer, key: u64) { let mut group = track.create_group(group::Info { start: key }).unwrap(); group.write_frame(millis(key), Bytes::from_static(b"x")).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// The groups from the one containing `start` through the one containing `end`. @@ -140,7 +140,7 @@ impl TimeCap { let mut group = self.track.create_group(group::Info { start: self.next }).unwrap(); let mut handed = drain(&mut self.reader); group.write_frame(millis(self.next), Bytes::from_static(b"x")).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); handed += drain(&mut self.reader); self.next += 1; assert_eq!(handed, 1, "the group is in range"); @@ -280,7 +280,7 @@ impl TimeGaps { let mut group = self.track.create_group(group::Info { start: self.next }).unwrap(); let mut handed = drain(&mut self.reader); group.write_frame(millis(self.next), Bytes::from_static(b"x")).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); handed += drain(&mut self.reader); self.next += 1; assert_eq!(handed, 1, "the live group is in range"); diff --git a/rs/moq-net/benches/refresh.rs b/rs/moq-net/benches/refresh.rs index 80c499cbf40..92a3ba6fed2 100644 --- a/rs/moq-net/benches/refresh.rs +++ b/rs/moq-net/benches/refresh.rs @@ -29,7 +29,7 @@ fn refreshable(track: &track::Producer, key: u64) { group .write_frame(moq_net::Timestamp::unscaled(group.start), Bytes::from_static(b"delta")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } fn join(c: &mut Criterion) { diff --git a/rs/moq-net/benches/session/mod.rs b/rs/moq-net/benches/session/mod.rs index 491eefe409a..87df087c8dc 100644 --- a/rs/moq-net/benches/session/mod.rs +++ b/rs/moq-net/benches/session/mod.rs @@ -516,14 +516,6 @@ impl MeasurementClock { } } -/// Append the next group on a [`timed`] track, one millisecond past its largest start or at -/// 0 on an empty track, so groups keep the key order a counter would give them. -fn append_next(track: &track::Producer) -> group::Producer { - track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap() -} - /// Where a group on a [`timed`] track starts, as its frames' timestamp. fn at(group: &group::Producer) -> Timestamp { Timestamp::from_millis(group.start).unwrap() @@ -538,12 +530,12 @@ fn from(key: u64) -> track::Range { } fn write_group(track: &track::Producer, payload: &Bytes, frames: usize) -> u64 { - let mut group = append_next(track); + let mut group = track.append_group(None).unwrap(); let timestamp = at(&group); for _ in 0..frames { group.write_frame(timestamp, payload.clone()).unwrap(); } - let group = group.close().unwrap(); + let group = group.finish().unwrap(); group.start } @@ -1189,10 +1181,10 @@ impl Room { self.written += 1; for (writing, &broadcast) in self.writing.iter_mut().zip(&self.watched) { - let group = writing.get_or_insert_with(|| append_next(&self.cluster.tracks[broadcast])); + let group = writing.get_or_insert_with(|| self.cluster.tracks[broadcast].append_group(None).unwrap()); group.write_frame(at(group), self.payload.clone()).unwrap(); if last { - writing.take().expect("written above").close().unwrap(); + writing.take().expect("written above").finish().unwrap(); } } if last { @@ -1491,7 +1483,7 @@ fn join(c: &mut Criterion, name: &str, shapes: impl IntoIterator Durati for key in 0..iterations { let mut group = track.append_group(key).unwrap(); group.write_frame(at(key), payload.clone()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } }) }) @@ -1145,7 +1145,7 @@ fn bench_range_serving(c: &mut Criterion) { group .write_frame(moq_net::Timestamp::unscaled(group.start), Bytes::from_static(b"x")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let subscription = track::Subscription::default() .with_delay(track::Delay::default().with_max(AGED_BUDGET)) @@ -1261,7 +1261,7 @@ fn bench_parked_read(c: &mut Criterion) { let mut next = track.append_group(millis(micros)).unwrap(); next.write_frame(Timestamp::from_micros(micros).unwrap(), Bytes::from_static(b"x")) .unwrap(); - next.close().unwrap(); + next.finish().unwrap(); micros += MICROS_PER_GROUP; repoll(&mut reads); } @@ -1319,7 +1319,7 @@ impl Sparse { }; let mut group = self.track.create_group(moq_net::group::Info { start: key }).unwrap(); group.write_frame(timestamp, Bytes::from_static(b"x")).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let Poll::Ready(Ok(Some(read))) = self.sub.poll_recv_group(&kio::Waiter::noop()) else { panic!("the group is cached"); }; @@ -1548,7 +1548,7 @@ impl GapFlush { }; // Every odd key is missing. let handed: Vec<_> = (0..gaps).map(|gap| hand_out(gap * 2)).collect(); - hand_out(gaps * 2).close().unwrap(); + hand_out(gaps * 2).finish().unwrap(); for group in handed { group.abort(Error::Cancel).unwrap(); } @@ -1624,7 +1624,7 @@ impl EmptyRun { if frame { group.write_frame(at(key), Bytes::from_static(b"x")).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); }; append(0, true); for key in 1..=run { @@ -1711,7 +1711,7 @@ fn bench_range_widening(c: &mut Criterion) { group .write_frame(moq_net::Timestamp::unscaled(group.start), Bytes::from_static(b"x")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let narrow = track::Subscription::default() .with_delay(track::Delay::default().with_max(AGED_BUDGET)) @@ -1770,7 +1770,7 @@ impl BudgetWidening { for key in keys { let mut group = track.create_group(group::Info { start: 100 * key }).unwrap(); group.write_frame(at(100 * key), Bytes::from_static(b"x")).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } while let Poll::Ready(Ok(Some(group))) = reader.poll_recv_group(&waiter) { black_box(group); @@ -1846,7 +1846,7 @@ impl TimeEnd { let mut zero = track.create_group(group::Info { start: 0 }).unwrap(); zero.write_frame(Timestamp::from_millis(0).unwrap(), Bytes::from_static(b"x")) .unwrap(); - zero.close().unwrap(); + zero.finish().unwrap(); // Group 1 never arrives, and the budget outlasts the run, so the end never settles. let subscription = track::Subscription::default() .with_delay(track::Delay::default().with_max(AGED_BUDGET)) @@ -1874,7 +1874,7 @@ impl TimeEnd { group .write_frame(Timestamp::from_millis(key).unwrap(), Bytes::from_static(b"x")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); for reader in &mut self.readers { let mut handed = 0; while let Poll::Ready(Ok(Some(group))) = reader.poll_recv_group(&waiter) { @@ -1926,7 +1926,7 @@ impl Fills { group .write_frame(Timestamp::from_millis(start).unwrap(), Bytes::from_static(b"x")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); // One range per run, with a key between each that no reader asks for. let ranges = (0..runs).map(|run| span(run * 2, run * 2)).chain([from(start)]); let subscription = track::Subscription::default() @@ -1962,10 +1962,13 @@ impl Fills { // The lookups go out first, and the misses they leave behind them. for _ in 0..2 { while let Poll::Ready(Ok(fill)) = self.dynamic.poll_requested_fill(&waiter) { - assert_eq!(fill.priority(), 1, "the update reached the fill"); - match fill.time() { - Some(_) => lookups += 1, - None => { + match fill { + track::Fill::Lookup(lookup) => { + assert_eq!(lookup.priority(), 1, "the update reached the lookup"); + lookups += 1; + } + track::Fill::Groups(fill) => { + assert_eq!(fill.priority(), 1, "the update reached the fill"); fill.drop_groups(fill.start().group..fill.end()); fills += 1; } @@ -2031,7 +2034,7 @@ impl RangeFills { group .write_frame(Timestamp::from_millis(start).unwrap(), Bytes::from_static(b"x")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let subscription = track::Subscription::default() .with_delay(track::Delay::default().with_max(AGED_BUDGET)) .with_ranges((0..ranges).map(|i| { @@ -2061,13 +2064,16 @@ impl RangeFills { // The lookups go out first, and the misses they leave behind them. for _ in 0..2 { while let Poll::Ready(Ok(fill)) = self.dynamic.poll_requested_fill(&waiter) { - // A lookup wants no group, so it is dropped unanswered. + // A lookup is dropped unanswered. + let track::Fill::Groups(fill) = fill else { + continue; + }; while let Some(key) = fill.wanted() { let mut group = fill.accept(key, None).unwrap(); group .write_frame(Timestamp::from_millis(key).unwrap(), Bytes::from_static(b"x")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } } for (reader, filled) in self.readers.iter_mut().zip(&mut filled) { @@ -2121,7 +2127,7 @@ struct RefusedFill { _broadcast: broadcast::Producer, _track: track::Producer, _dynamic: track::Requests, - fill: track::Fill, + fill: track::FillGroups, readers: Vec, } @@ -2135,7 +2141,7 @@ impl RefusedFill { track.start_at(Self::START).unwrap(); let mut group = track.create_group(group::Info { start: Self::START }).unwrap(); group.write_frame(Timestamp::ZERO, Bytes::from_static(b"x")).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let waiter = kio::Waiter::noop(); let readers = (0..readers) .map(|_| { @@ -2152,7 +2158,7 @@ impl RefusedFill { reader }) .collect(); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(track::Fill::Groups(fill))) = dynamic.poll_requested_fill(&waiter) else { panic!("the miss below the start is asked"); }; assert!( diff --git a/rs/moq-net/benches/viewers.rs b/rs/moq-net/benches/viewers.rs index e9771ce59df..0e806c67d17 100644 --- a/rs/moq-net/benches/viewers.rs +++ b/rs/moq-net/benches/viewers.rs @@ -83,7 +83,7 @@ impl Room { let track = broadcast.broadcast().create_track("video", timed()).unwrap(); let mut group = track.append_group(0).unwrap(); group.write_frame(Timestamp::ZERO, b"frame".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); (broadcast, track) }) .collect(); diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index 39fb2b122e6..12cec34c0ab 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -132,7 +132,7 @@ pub fn object_group(frames: usize, properties: bool) -> (broadcast::Producer, tr ..Default::default() }; let track = broadcast.create_track("objects", info).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); let payload = Bytes::from_static(&[0; 64]); for id in 0..frames { let fields = properties.then(|| { @@ -163,7 +163,7 @@ pub fn object_group(frames: usize, properties: bool) -> (broadcast::Producer, tr frame.write(payload.clone()).unwrap(); group = frame.finish().unwrap(); } - (broadcast, track, group.close().unwrap()) + (broadcast, track, group.finish().unwrap()) } /// A private frame batch for the model's batch read and write benchmarks. @@ -2495,7 +2495,7 @@ impl FrameRecv { let streams = (0..streams) .map(|_| { - let group = track.append_next().unwrap(); + let group = track.append_group(None).unwrap(); // Each group starts at its own key, so the starts increase. let info = frame::Info { size: size as u64, @@ -2558,7 +2558,7 @@ impl FrameRecv { res.unwrap(); let stream = slot.take().unwrap(); let group = stream.frame.finish().unwrap(); - group.close().unwrap(); + group.finish().unwrap(); open -= 1; } } @@ -2661,7 +2661,7 @@ impl GroupRecv { /// 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)?.close() + self.group.take().ok_or(crate::Error::Closed)?.finish() } } diff --git a/rs/moq-net/src/fuzz/ingest.rs b/rs/moq-net/src/fuzz/ingest.rs index e499f4148c9..1c9d815f9b6 100644 --- a/rs/moq-net/src/fuzz/ingest.rs +++ b/rs/moq-net/src/fuzz/ingest.rs @@ -219,7 +219,7 @@ fn run(session: Session, info: &track::Info, body: &[u8], chunk: usize) -> Optio frame_start, } => { let mut reader = reader(Bytes::copy_from_slice(body), chunk, version); - let producer = track.append_next().ok()?; + let producer = track.append_group(None).ok()?; let consumer = producer.consume(); let mut viewer = stored(producer.consume(), info.compressed()); let mut group = crate::recv::Group::new(producer); diff --git a/rs/moq-net/src/fuzz/session.rs b/rs/moq-net/src/fuzz/session.rs index 9101b61c457..c2967dac838 100644 --- a/rs/moq-net/src/fuzz/session.rs +++ b/rs/moq-net/src/fuzz/session.rs @@ -479,7 +479,7 @@ impl Bystander { fn publish(&self) { let mut sent = self.sent.borrow_mut(); let key = sent.len() as u64; - let mut group = self.track.append_next().expect("the bystander's group"); + let mut group = self.track.append_group(None).expect("the bystander's group"); let mut frames = Vec::new(); for frame in 0..2u8 { let mut payload = key.to_be_bytes().repeat(8); @@ -489,7 +489,7 @@ impl Bystander { group.write_frame(key, payload.clone()).expect("the bystander's frame"); frames.push(payload); } - group.close().expect("the bystander's group finish"); + group.finish().expect("the bystander's group finish"); sent.push(frames); } @@ -778,10 +778,10 @@ fn record(version: Version, scenario: Scenario) -> Vec { route.announce().expect("the client's announce"); let subscribed = async { while let Ok(None) = track.subscription_changed().await {} }; let _ = kio::clock::timeout(timeout, subscribed).await; - let mut group = track.append_next().expect("the client's group"); + let mut group = track.append_group(None).expect("the client's group"); let key = crate::Timestamp::unscaled(group.start); group.write_frame(key, Bytes::from_static(b"frame")).expect("a frame"); - group.close().expect("the client's group finish"); + group.finish().expect("the client's group finish"); kio::clock::sleep(timeout).await; } Scenario::Subscribe => { diff --git a/rs/moq-net/src/ietf/object.rs b/rs/moq-net/src/ietf/object.rs index cfbf17cc278..650024d3458 100644 --- a/rs/moq-net/src/ietf/object.rs +++ b/rs/moq-net/src/ietf/object.rs @@ -801,7 +801,7 @@ mod compression_tests { crate::track::Info::default().with_compression(crate::track::Compression::Deflate), ) .unwrap(); - let group = track.append_next().unwrap(); + let group = track.append_group(None).unwrap(); let header = crate::frame::Header { info: crate::frame::Info { size: 1, diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index e62d9bcc764..0adf91c2ddf 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -8577,13 +8577,13 @@ mod group_priority_test { assert!(serve.poll(&kio::Waiter::noop()).is_pending()); let mut group = Some(group); if finished { - group.take().unwrap().close().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(); + track.finish_at(track::Position { group: 5, frame: 5 }).unwrap(); if let Some(group) = group { - group.close().unwrap(); + group.finish().unwrap(); } kio::wait(|waiter| serve.poll(waiter)).await.unwrap(); if let Some(end) = serve.end() { @@ -8631,9 +8631,9 @@ mod group_priority_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let mut old = track.append_next().unwrap(); + let mut old = track.append_group(None).unwrap(); old.write_frame(old.key_time(), b"old".as_slice()).unwrap(); - old.close().unwrap(); + old.finish().unwrap(); let group = subscriber.recv_group().await.unwrap().expect("old group"); // Set directly rather than through the track, which a later group expires. @@ -8673,10 +8673,10 @@ mod group_priority_test { assert!(!terminal.sent.load(Ordering::Relaxed), "not until acknowledged"); kio::clock::sim::advance(Duration::from_secs(1)).await; - let mut edge = track.append_next().unwrap(); + let mut edge = track.append_group(None).unwrap(); edge.write_frame(crate::Timestamp::from_millis(1000).unwrap(), b"edge".as_slice()) .unwrap(); - edge.close().unwrap(); + edge.finish().unwrap(); assert!(matches!(futures::poll!(serving.as_mut()), Poll::Ready(Err(Error::Old)))); assert!( !terminal.sent.load(Ordering::Relaxed), @@ -8714,7 +8714,7 @@ mod group_priority_test { group .write_frame(crate::Timestamp::from_millis(0).unwrap(), b"hello".as_slice()) .unwrap(); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let msg = ietf::GroupHeader { track_alias: 0, @@ -8859,7 +8859,7 @@ mod group_priority_test { group .write_frame(crate::Timestamp::from_millis(appended).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); appended += 1; } appended == GROUPS @@ -8904,7 +8904,7 @@ mod group_priority_test { group .write_frame(crate::Timestamp::from_millis(key).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let waiter = kio::Waiter::noop(); @@ -8953,7 +8953,7 @@ mod group_priority_test { .write_frame(crate::Timestamp::from_millis(millis).unwrap(), vec![0u8; PAYLOAD]) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let serve = TrackServe::new( crate::driver::Transport::new(session.clone()), subscriber, @@ -9005,7 +9005,7 @@ mod group_priority_test { later .write_frame(crate::Timestamp::unscaled(later.start), b"later".as_slice()) .unwrap(); - later.close().unwrap(); + later.finish().unwrap(); for _ in 0..8 { assert!(futures::poll!(kio::wait(|waiter| serve.poll(waiter))).is_pending()); kio::clock::sim::yield_now().await; @@ -9038,7 +9038,7 @@ mod group_priority_test { }) .unwrap(); frame.write(b"x".as_slice()).unwrap(); - frame.finish().unwrap().close().unwrap(); + frame.finish().unwrap().finish().unwrap(); let _finished = track.finish().unwrap(); kio::wait(|waiter| serve.poll(waiter)).await.unwrap(); @@ -9068,9 +9068,9 @@ mod group_priority_test { let track = track::Producer::new(std::sync::Arc::new(crate::broadcast::Info::default()), "test", info); let subscriber = track.subscribe(None); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"hello".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let mut serve = TrackServe::new( @@ -9142,11 +9142,11 @@ mod group_priority_test { for key in 0..groups { for (track, serve) in &mut serves { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(crate::Timestamp::from_millis(key).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle_serve(serve).await; } let held = serves.iter().map(|(_, serve)| serve.machines() as u64).sum::(); @@ -9184,7 +9184,7 @@ mod group_priority_test { Some(Timescale::MILLI), ); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); settle_serve(&mut serve).await; assert_eq!(serve.machines(), 1, "group 0 waits for credit"); @@ -9193,10 +9193,10 @@ mod group_priority_test { settle_serve(&mut serve).await; assert_eq!(serve.machines(), 0, "the evicted group leaves without credit"); - let mut next = track.append_next().unwrap(); + let mut next = track.append_group(None).unwrap(); next.write_frame(crate::Timestamp::from_millis(1).unwrap(), b"x".as_slice()) .unwrap(); - next.close().unwrap(); + next.finish().unwrap(); settle_serve(&mut serve).await; assert_eq!(serve.machines(), 1, "group 1 takes its place"); @@ -9298,9 +9298,9 @@ mod group_priority_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let mut old = track.append_next().unwrap(); + let mut old = track.append_group(None).unwrap(); old.write_frame(old.key_time(), b"old".as_slice()).unwrap(); - old.close().unwrap(); + old.finish().unwrap(); let group = subscriber.recv_group().await.unwrap().expect("old group"); let mut serve = GroupServe::new( @@ -9325,10 +9325,10 @@ mod group_priority_test { ); kio::clock::sim::advance(Duration::from_secs(1)).await; - let mut edge = track.append_next().unwrap(); + let mut edge = track.append_group(None).unwrap(); edge.write_frame(crate::Timestamp::from_millis(1000).unwrap(), b"edge".as_slice()) .unwrap(); - edge.close().unwrap(); + edge.finish().unwrap(); assert!(matches!(serving.await, Err(Error::Old))); } @@ -9371,7 +9371,7 @@ mod group_priority_test { let mut edge = track.create_group(group::Info { start: 1 }).unwrap(); edge.write_frame(crate::Timestamp::unscaled(edge.start), b"edge".as_slice()) .unwrap(); - edge.close().unwrap(); + edge.finish().unwrap(); assert!(matches!(serving.await, Err(Error::Old))); } @@ -9392,7 +9392,7 @@ mod group_priority_test { producer .write_frame(crate::Timestamp::ZERO, b"tail".as_slice()) .unwrap(); - producer.close().unwrap(); + producer.finish().unwrap(); let group = subscriber.recv_group().await.unwrap().expect("the group"); let mut serve = GroupServe::new( @@ -9427,9 +9427,9 @@ mod group_priority_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let mut old = track.append_next().unwrap(); + let mut old = track.append_group(None).unwrap(); old.write_frame(old.key_time(), b"old".as_slice()).unwrap(); - old.close().unwrap(); + old.finish().unwrap(); let group = subscriber.recv_group().await.unwrap().expect("old group"); let mut serve = GroupServe::new( @@ -9455,10 +9455,10 @@ mod group_priority_test { assert!(log.resets().is_empty()); kio::clock::sim::advance(Duration::from_secs(1)).await; - let mut edge = track.append_next().unwrap(); + let mut edge = track.append_group(None).unwrap(); edge.write_frame(crate::Timestamp::from_millis(1000).unwrap(), b"edge".as_slice()) .unwrap(); - edge.close().unwrap(); + edge.finish().unwrap(); assert!(matches!(futures::poll!(serving.as_mut()), Poll::Ready(Err(Error::Old)))); assert_eq!(log.resets(), vec![crate::StreamError::Cancel.to_code()]); @@ -9477,7 +9477,7 @@ mod group_priority_test { let mut group = track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"done".as_slice()).unwrap(); let consumer = group.consume(); - group.close().unwrap(); + group.finish().unwrap(); // Another subscription's group at 22 sits in the same queue, so each update // moves this stream across it. @@ -9526,7 +9526,7 @@ mod group_priority_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let old = track.append_next().unwrap(); + let old = track.append_group(None).unwrap(); let mut frame = old .create_frame(frame::Info { timestamp: crate::Timestamp::ZERO, @@ -9560,17 +9560,17 @@ mod group_priority_test { *open = false; drop(open); frame.write(b"b".as_slice()).unwrap(); - frame.finish().unwrap().close().unwrap(); + frame.finish().unwrap().finish().unwrap(); assert!( futures::poll!(serving.as_mut()).is_pending(), "the final byte is transport-blocked" ); kio::clock::sim::advance(Duration::from_secs(1)).await; - let mut edge = track.append_next().unwrap(); + let mut edge = track.append_group(None).unwrap(); edge.write_frame(crate::Timestamp::from_millis(1000).unwrap(), b"edge".as_slice()) .unwrap(); - edge.close().unwrap(); + edge.finish().unwrap(); assert!(matches!(serving.await, Err(Error::Old))); } @@ -9597,7 +9597,7 @@ mod subscribe_cursor_test { for key in 0..4 { let mut group = track.create_group(group::Info { start: key }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let subscriber = track.subscribe(None); @@ -9853,7 +9853,7 @@ mod serve_tests { if !super::super::request_stream::fin_cancels(version) { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"after FIN".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert!(futures::poll!(run.as_mut()).is_pending()); assert_eq!(occurrences(&h.log, b"after FIN"), 1, "{version}"); } @@ -10273,7 +10273,7 @@ mod serve_tests { }) .await; - group.close().unwrap(); + group.finish().unwrap(); h.track.finish_shared().unwrap(); kio::clock::timeout(std::time::Duration::from_secs(10), serve) .await @@ -10314,9 +10314,9 @@ mod serve_tests { // Frozen timestamps, so only the wall clock since group 1 arrived convicts group 0. let append = || { - let mut group = h.track.append_next().unwrap(); + let mut group = h.track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; let finished = || { data_streams(&h.log) @@ -10577,7 +10577,7 @@ mod serve_tests { group .write_frame(crate::Timestamp::unscaled(group.start), &b"bounded"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut datagrams = broadcast.create_datagrams("audio", Default::default()).unwrap(); let consumer = broadcast.consume().datagrams("audio").unwrap(); let session = ScriptedSession::new(Vec::new()).with_datagrams(1200); @@ -12152,7 +12152,7 @@ mod serve_tests { let mut h = serve(version); let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(stamp, b"stamped".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut msg = subscribe(Filter::Unfiltered, None); msg.properties_wanted = wanted; @@ -12452,13 +12452,13 @@ mod serve_tests { let mut h = serve(Version::Draft22); let mut earlier = h.track.create_group(group::Info { start: 0 }).unwrap(); earlier.write_frame(earlier.key_time(), b"earlier".as_slice()).unwrap(); - earlier.close().unwrap(); + earlier.finish().unwrap(); let mut group = h.track.create_group(group::Info { start: 1 }).unwrap(); for payload in [b"head-0", b"head-1", b"head-2"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); run_live( &mut h, @@ -12547,10 +12547,10 @@ mod serve_tests { }) .await; group.write_frame(group.key_time(), b"after-update".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut later = h.track.create_group(group::Info { start: 4 }).unwrap(); later.write_frame(later.key_time(), b"wanted".as_slice()).unwrap(); - later.close().unwrap(); + later.finish().unwrap(); h.track.finish_shared().unwrap(); serving.await.unwrap(); assert_eq!( @@ -12593,7 +12593,7 @@ mod serve_tests { let h = serve(version); let mut history = h.track.create_group(group::Info { start: 0 }).unwrap(); history.write_frame(history.key_time(), b"history".as_slice()).unwrap(); - history.close().unwrap(); + history.finish().unwrap(); let mut group = h.track.create_group(group::Info { start: 1 }).unwrap(); group .write_frame(group.key_time(), b"before-update".as_slice()) @@ -12649,7 +12649,7 @@ mod serve_tests { for payload in [b"after-1", b"after-2"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); h.track.finish_shared().unwrap(); serving.await.unwrap(); assert_eq!( @@ -12741,7 +12741,7 @@ mod serve_tests { }) .await; group.write_frame(group.key_time(), b"tail".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); serving.await.unwrap(); assert_eq!(occurrences(&h.log, b"tail"), 1, "the update's tail is served"); } @@ -12754,7 +12754,7 @@ mod serve_tests { let h = serve(version); let mut history = h.track.create_group(group::Info { start: 0 }).unwrap(); history.write_frame(history.key_time(), b"history".as_slice()).unwrap(); - history.close().unwrap(); + history.finish().unwrap(); let mut group = h.track.create_group(group::Info { start: 1 }).unwrap(); group.write_frame(group.key_time(), b"live".as_slice()).unwrap(); kio::clock::sim::yield_now().await; @@ -12798,7 +12798,7 @@ mod serve_tests { Wire::read(&h.log, version).sent(ietf::RequestOk::ID).is_some() }) .await; - group.close().unwrap(); + group.finish().unwrap(); h.track.finish_shared().unwrap(); serving.await.unwrap(); assert_eq!(occurrences(&h.log, b"history"), 0, "the historical fill is refused"); @@ -12865,11 +12865,11 @@ mod serve_tests { group .write_frame(group.key_time(), b"later-current".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); for (key, payload) in [(2, b"excluded".as_slice()), (4, b"wanted".as_slice())] { let mut group = h.track.create_group(group::Info { start: key }).unwrap(); group.write_frame(group.key_time(), payload).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } h.track.finish_shared().unwrap(); serving.await.unwrap(); @@ -12894,7 +12894,7 @@ mod serve_tests { for payload in [b"head-0", b"head-1", b"head-2"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); run_live(&mut h, subscribe(Filter::Relative(1), None)).await; @@ -12914,7 +12914,7 @@ mod serve_tests { for payload in [b"head-0", b"head-1", b"head-2"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); run_live(&mut h, subscribe(Filter::NextObject, None)).await; @@ -12942,7 +12942,7 @@ mod serve_tests { for (key, payload) in [(0, b"history"), (1, b"latest!")] { let mut group = h.track.create_group(group::Info { start: key }).unwrap(); group.write_frame(group.key_time(), payload.as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } run_live(&mut h, subscribe(filter, None)).await; @@ -12977,7 +12977,7 @@ mod serve_tests { for (key, payload) in [(0, b"history"), (1, b"latest!")] { let mut group = track.create_group(group::Info { start: key }).unwrap(); group.write_frame(group.key_time(), payload.as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let (relay, _sessions) = crate::lite::ietf::test_hop(&upstream, "room", [false, false]).await; @@ -13043,7 +13043,7 @@ mod serve_tests { for key in 0..2 { let mut group = h.track.create_group(group::Info { start: key }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } run_live( @@ -13136,7 +13136,7 @@ mod serve_tests { "a REQUEST_UPDATE moved it to the top" ); - group.close().unwrap(); + group.finish().unwrap(); fill.await; assert_eq!(occurrences(&h.log, b"fill"), 1); assert!(h.log.resets().is_empty(), "a served fill must not reset"); @@ -13267,7 +13267,7 @@ mod serve_tests { for key in 0..=latest { let mut group = h.track.create_group(group::Info { start: key }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } } @@ -13381,7 +13381,7 @@ mod serve_tests { if streamed { assert!(futures::poll!(serving.as_mut()).is_pending()); } - frame.finish().unwrap().close().unwrap(); + frame.finish().unwrap().finish().unwrap(); h.track.finish_shared().unwrap(); served(&h, serving.as_mut()).await; assert_eq!(occurrences(&h.log, payload), 1, "{version} streamed={streamed}"); @@ -13671,7 +13671,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 5 }).unwrap(); group.start_at(1).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), version) .await @@ -13827,7 +13827,7 @@ mod serve_tests { publish_groups(&mut h, 4); let mut group = h.track.create_group(group::Info { start: 5 }).unwrap(); group.write_frame(group.key_time(), b"the-head".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), version) @@ -13924,7 +13924,7 @@ mod serve_tests { .unwrap(); let mut group = track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let bi = kio::Producer::new(true); @@ -14297,7 +14297,7 @@ mod serve_tests { .write_frame(group.key_time(), format!("{key}-{object}").into_bytes()) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } } @@ -14318,7 +14318,7 @@ mod serve_tests { for _ in 0..256 { group.write_frame(group.key_time(), vec![7; 1024]).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); settle().await; let done = std::rc::Rc::new(std::cell::Cell::new(false)); @@ -14715,7 +14715,7 @@ mod serve_tests { let track = h._broadcast.broadcast().create_track("timed", info.clone()).unwrap(); let mut group = track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(stamp, b"stamped".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let range = fetch_range( @@ -14808,7 +14808,7 @@ mod serve_tests { ); let mut group = h.track.create_group(group::Info { start: 4 }).unwrap(); group.write_frame(group.key_time(), b"fill".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let ranking = Ranking { queue: h.publisher.priority.clone(), @@ -14876,7 +14876,7 @@ mod serve_tests { let h = serve_track(version, info.clone()); let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"a".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let range = fetch_range( version, @@ -15101,7 +15101,7 @@ mod serve_tests { } Largest::IdleEnded => { h.track.set_idle(); - h.track.finish_at(track::Position::group(10), None).unwrap(); + h.track.finish_at(track::Position::group(10)).unwrap(); None } Largest::IdleFinished => { @@ -15175,7 +15175,7 @@ mod serve_tests { let mut h = serve(version); publish_pairs(&mut h, 5, None); let empty = h.track.create_group(group::Info { start: 5 }).unwrap(); - empty.close().unwrap(); + empty.finish().unwrap(); settle().await; let buf = standalone_fetch( @@ -15245,7 +15245,7 @@ mod serve_tests { ) .unwrap(); } - fetched.close().unwrap(); + fetched.finish().unwrap(); fetching.await.unwrap(); let fetch_type = fetch_range( @@ -15454,7 +15454,7 @@ mod serve_tests { let finish = async { settle().await; older.write_frame(older.key_time(), b"4-1".to_vec()).unwrap(); - older.close().unwrap(); + older.finish().unwrap(); }; let (buf, ()) = futures::join!(fetch, finish); let (ok, objects) = fetch_answer(buf, version); @@ -15590,7 +15590,7 @@ mod serve_tests { .unwrap(); let mut group = track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"0-0".to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; // Request streams flow, but no uni stream credit is ever granted. @@ -15999,7 +15999,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), ANSWERED_HEAD.to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -16166,7 +16166,7 @@ mod serve_tests { Parked::Acking => { let mut group = track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } // An empty finished track: nothing to serve but the marker. _ => { @@ -16868,7 +16868,7 @@ mod serve_tests { for payload in [b"5-0", b"5-1", b"5-2", b"5-3"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); run_live(&mut h, subscribe(Filter::Unfiltered, None)).await; @@ -16962,7 +16962,7 @@ mod serve_tests { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } let consumer = group.consume(); - group.close().unwrap(); + group.finish().unwrap(); let mut serve = GroupServe::new( crate::driver::Transport::new(session.clone()), @@ -17018,11 +17018,11 @@ mod serve_tests { ); let subscriber = track.subscribe(None); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); for payload in [b"aa", b"bb", b"cc"] { group.write_frame(group.key_time(), payload.as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let range = ServeRange { @@ -17223,7 +17223,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -17424,7 +17424,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -17499,7 +17499,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -17554,7 +17554,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -17601,7 +17601,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -17648,7 +17648,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -17719,7 +17719,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), version) @@ -17788,7 +17788,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -17845,7 +17845,7 @@ mod serve_tests { ) { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let renewal = std::sync::Arc::new(std::sync::Mutex::new(None)); @@ -17918,7 +17918,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -17992,7 +17992,7 @@ mod serve_tests { let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -18097,7 +18097,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth, Vec::new()); let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -18151,7 +18151,7 @@ mod serve_tests { let h = serve_with_auth(VERSION, auth.clone(), Vec::new()); let mut group = h.track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); settle().await; let stream = Stream::open(&crate::driver::Transport::new(h.session.clone()), VERSION) @@ -18643,11 +18643,11 @@ mod tests { crate::track::Info::timed(), ); for millis in [0, 1000] { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(crate::Timestamp::from_millis(millis).unwrap(), b"frame".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let subscription = serving_subscription(128); @@ -21501,8 +21501,8 @@ mod range_tests { "video", crate::track::Info::timed(), ); - track.create_group(group::Info { start: 7 }).unwrap().close().unwrap(); - track.create_group(group::Info { start: 8 }).unwrap().close().unwrap(); + track.create_group(group::Info { start: 7 }).unwrap().finish().unwrap(); + track.create_group(group::Info { start: 8 }).unwrap().finish().unwrap(); // Next Group against a live edge of 8 asks for 9, which does not exist yet. let mut subscriber = track.subscribe(None); @@ -21513,7 +21513,7 @@ mod range_tests { ); // The group it asked for is what it gets once published. - track.create_group(group::Info { start: 9 }).unwrap().close().unwrap(); + track.create_group(group::Info { start: 9 }).unwrap().finish().unwrap(); let group = subscriber.recv_group().await.unwrap().expect("group 9"); assert_eq!(group.start, 9); } @@ -21743,7 +21743,7 @@ mod range_tests { .write_frame(crate::Timestamp::from_millis(key).unwrap(), b"frame".as_slice()) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } let _track = staged.commit(); assert_eq!(snapshot.join().unwrap(), Some(Location { group: 2, object: 1 })); @@ -21763,7 +21763,7 @@ mod range_tests { first .write_frame(crate::Timestamp::from_millis(0).unwrap(), b"frame".as_slice()) .unwrap(); - first.close().unwrap(); + first.finish().unwrap(); // Key 1 never exists; the newest group is empty. let _open = track.create_group(group::Info { start: 2 }).unwrap(); @@ -21789,7 +21789,7 @@ mod range_tests { .write_frame(crate::Timestamp::from_millis(0).unwrap(), b"frame".as_slice()) .unwrap(); } - first.close().unwrap(); + first.finish().unwrap(); let mut newest = track.create_group(group::Info { start: 1 }).unwrap(); newest.write_frame(newest.key_time(), b"frame".as_slice()).unwrap(); newest.abort(Error::Cancel).unwrap(); @@ -22103,11 +22103,11 @@ mod compression_tests { ); let subscriber = track.subscribe(None); let frames = [vec![b'a'; 1024], vec![b'b'; 1024], Vec::new()]; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); for payload in &frames { group.write_frame(group.key_time(), payload.clone()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); track.finish_shared().unwrap(); let response = ietf::SubscribeOk { track_alias: 0, diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index eb1ada63d65..ab3492e94ec 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -426,7 +426,7 @@ impl Fill { /// group: it starts at the group's first object and has no holes. fn release(&mut self) { if let Fill::Ready { producer, .. } = std::mem::replace(self, Fill::Done) { - let _ = producer.close(); + let _ = producer.finish(); } } @@ -513,7 +513,7 @@ enum GroupFetch { /// What FETCH_OK settled about a range FETCH, for the fetch stream writing its groups. struct RangeFetch { - fill: std::sync::Arc, + fill: std::sync::Arc, timescale: Option, /// The first group requested. first: u64, @@ -3686,7 +3686,7 @@ enum ServeEnd { Idle, Revoked, Done(Result, Error>), - Fill(track::Fill), + Fill(track::FillGroups), /// An update to send, and the bounds it asks for once its range changed. Update(RequestId, Update, WireBounds), Invalid(Error), @@ -4774,7 +4774,7 @@ impl SubscribeOnce { } live.poll_joining(waiter); // An error is the track closing, which the arms below report. - if let Poll::Ready(Ok(requested)) = live.dynamic.poll_requested_fill(waiter) { + if let Poll::Ready(Ok(requested)) = live.dynamic.poll_requested_groups(waiter) { return Poll::Ready(ServeEnd::Fill(requested)); } let _ = group_fetches.poll(waiter); @@ -5276,7 +5276,7 @@ struct Linger { /// What ended a wait while lingering. enum LingerStep { - Fill(track::Fill), + Fill(track::FillGroups), Subscribe, Expired, Revoked, @@ -5334,7 +5334,7 @@ impl Linger { LingerStep::Closed } else if gate.poll_denied(waiter).is_ready() { LingerStep::Revoked - } else if let Poll::Ready(Ok(fill)) = idle.dynamic.poll_requested_fill(waiter) { + } else if let Poll::Ready(Ok(fill)) = idle.dynamic.poll_requested_groups(waiter) { LingerStep::Fill(fill) } else { let _ = group_fetches.poll(waiter); @@ -5962,7 +5962,7 @@ impl LearnTrackStatus { Some(SetupResponse::Cancelled(Error::from_transport(err))) } else { // A fetch needs nothing from the status to go out, only to read its objects. - while let Poll::Ready(Ok(fill)) = asked.dynamic.poll_requested_fill(waiter) { + while let Poll::Ready(Ok(fill)) = asked.dynamic.poll_requested_groups(waiter) { group_fetches.push(ServeFill::new( this.clone(), broadcast_path.clone(), @@ -6191,7 +6191,7 @@ fn end_track(track: &mut track::Producer, end: track::Position, properties: bool } // Lower groups may still be on the wire, behind the one that carried the end: the // received copy holds readers at a hole for the grace. - if let Err(err) = track.finish_at(end, None) { + if let Err(err) = track.finish_at(end) { tracing::warn!(%err, ?end, "invalid END_OF_TRACK"); let _ = track.clone().abort(Error::ProtocolViolation); return Err(Error::ProtocolViolation); @@ -7153,7 +7153,13 @@ impl RunFill { impl Subscriber { /// Serve a whole fill with one FETCH, as [`ServeFill`] serves each run. #[cfg(test)] - async fn run_group_fetch(self, broadcast: Path, name: String, fill: track::Fill, timescale: Option) { + async fn run_group_fetch( + self, + broadcast: Path, + name: String, + fill: track::FillGroups, + timescale: Option, + ) { let run = fill.start().group..fill.end(); let mut fetch = FetchRun::new( self, @@ -7185,7 +7191,7 @@ struct ServeFill { _working: crate::session::Working, broadcast: Path, name: String, - fill: std::sync::Arc, + fill: std::sync::Arc, timescale: Later>, heading: Option, /// The run fetched last, which coming back means it went unanswered. @@ -7211,7 +7217,7 @@ impl ServeFill { this: Subscriber, broadcast: Path, name: String, - fill: track::Fill, + fill: track::FillGroups, timescale: Later>, heading: Option, ) -> Self { @@ -7312,7 +7318,7 @@ struct FetchRun { this: Subscriber, broadcast: Path, name: String, - fill: std::sync::Arc, + fill: std::sync::Arc, run: std::ops::Range, timescale: Later>, validity: crate::model::broadcast::RequestValidity, @@ -7362,7 +7368,7 @@ impl FetchRun { this: Subscriber, broadcast: Path, name: String, - fill: std::sync::Arc, + fill: std::sync::Arc, run: std::ops::Range, timescale: Later>, ) -> Self { @@ -10089,7 +10095,7 @@ mod tests { let dynamic = track.requests(); let mut pending = Box::pin(track.consume().fetch_group(0, None)); assert!(futures::poll!(pending.as_mut()).is_pending()); - let request = dynamic.requested_fill().await.expect("group request"); + let request = dynamic.requested_groups().await.expect("group request"); group = Some(pending); accepted = Some(track); Box::pin(subscriber.clone().run_group_fetch( @@ -16306,7 +16312,7 @@ mod stitch_tests { use futures::FutureExt; let mut h = Harness::new(Fill::Done, vec![tail_stream(KEY, 0, &[b"late"])]); - h.track.finish_at(track::Position::group(KEY), None).unwrap(); + h.track.finish_at(track::Position::group(KEY)).unwrap(); let mut stream = h.stream().await; let res = h.subscriber.clone().recv_group(&mut stream).await; @@ -16851,7 +16857,7 @@ mod stitch_tests { // Starts past the incoming group's first object, at `timestamp(0)`. let mut before = h.track.create_group((KEY - 1).into()).unwrap(); before.write_frame(timestamp(4000), b"before".as_slice()).unwrap(); - before.close().unwrap(); + before.finish().unwrap(); let mut consumer = h.track.subscribe(None); assert_eq!(read_group(&mut consumer).await.0, KEY - 1); @@ -17221,7 +17227,7 @@ mod stitch_tests { let dynamic = run.track.requests(); let consumer = run.track.consume(); run.track.start_at(last + 1).unwrap(); - run.track.create_group((last + 1).into()).unwrap().close().unwrap(); + run.track.create_group((last + 1).into()).unwrap().finish().unwrap(); // From group 0, which a time start names whatever is held, so the history below // the feed is asked as a miss rather than looked up. let mut reading = consumer @@ -17234,7 +17240,7 @@ mod stitch_tests { .await .unwrap(); assert!(futures::FutureExt::now_or_never(reading.recv_group()).is_none()); - let fill = dynamic.requested_fill().await.unwrap(); + let fill = dynamic.requested_groups().await.unwrap(); let bounded = consumer.fetch_group(last, None); let slot = kio::Producer::new(GroupFetch::Ready(RangeFetch { fill: std::sync::Arc::new(fill), @@ -17320,7 +17326,7 @@ mod stitch_tests { run.track.broadcast().pool.poll(now, &kio::Waiter::noop()); run.track.received(); run.track.start_at(3).unwrap(); - run.track.create_group(3u64.into()).unwrap().close().unwrap(); + run.track.create_group(3u64.into()).unwrap().finish().unwrap(); let requests = run.track.requests(); // From group 0, which a time start names whatever is held. let mut reader = run.track.subscribe( @@ -17331,7 +17337,7 @@ mod stitch_tests { let waiter = kio::Waiter::noop(); assert!(reader.poll_drop(&waiter).is_pending()); assert!(reader.poll_recv_group(&waiter).is_pending()); - let Poll::Ready(Ok(fill)) = requests.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = requests.poll_requested_groups(&waiter) else { panic!("{version}: missing history was not requested"); }; assert_eq!((fill.start().group, fill.end()), (0, 3)); @@ -17369,7 +17375,7 @@ mod stitch_tests { let dynamic = run.track.requests(); let consumer = run.track.consume(); run.track.start_at(7).unwrap(); - run.track.create_group(7u64.into()).unwrap().close().unwrap(); + run.track.create_group(7u64.into()).unwrap().finish().unwrap(); // From group 0, which a time start names whatever is held, so the history below // the feed is asked as a miss rather than looked up. let mut reading = consumer @@ -17382,7 +17388,7 @@ mod stitch_tests { .await .unwrap(); assert!(futures::FutureExt::now_or_never(reading.recv_group()).is_none()); - let fill = dynamic.requested_fill().await.unwrap(); + let fill = dynamic.requested_groups().await.unwrap(); assert_eq!( (fill.start().group, fill.end()), (0, 7), @@ -17582,7 +17588,7 @@ mod stitch_tests { let dynamic = self.track.requests(); let mut fetch = Box::pin(self.track.consume().fetch_group(KEY, None)); assert!(futures::poll!(fetch.as_mut()).is_pending()); - let fill = dynamic.requested_fill().await.expect("group request"); + let fill = dynamic.requested_groups().await.expect("group request"); let slot = kio::Producer::new(GroupFetch::Ready(RangeFetch { fill: std::sync::Arc::new(fill), timescale, @@ -18707,7 +18713,7 @@ mod joining_fetch_tests { let consumer = track.consume(); let mut fetch = Box::pin(consumer.fetch_group(GROUP, None)); assert!(futures::poll!(fetch.as_mut()).is_pending()); - let request = dynamic.requested_fill().await.expect("group request"); + let request = dynamic.requested_groups().await.expect("group request"); let outcome = request.joined(); let mut run = Box::pin(subscriber.clone().run_group_fetch( Path::from_static("broadcast"), @@ -18954,7 +18960,7 @@ mod joining_fetch_tests { let consumer = track.consume(); let mut fetch = std::pin::pin!(consumer.fetch_group(GROUP, None)); assert!(futures::poll!(fetch.as_mut()).is_pending()); - let request = dynamic.requested_fill().await.expect("no group requested"); + let request = dynamic.requested_groups().await.expect("no group requested"); subscriber .clone() @@ -19024,7 +19030,7 @@ mod joining_fetch_tests { } )); assert!(futures::poll!(fetch.as_mut()).is_pending()); - let request = dynamic.requested_fill().await.expect("no group requested"); + let request = dynamic.requested_groups().await.expect("no group requested"); subscriber .clone() @@ -19150,7 +19156,7 @@ mod joining_fetch_tests { } )); assert!(futures::poll!(fetch.as_mut()).is_pending()); - let request = dynamic.requested_fill().await.expect("no group requested"); + let request = dynamic.requested_groups().await.expect("no group requested"); let serving = kio::clock::sim::spawn(subscriber.clone().run_group_fetch( Path::from_static("broadcast"), diff --git a/rs/moq-net/src/lite/ietf.rs b/rs/moq-net/src/lite/ietf.rs index 85a1d4ad8ba..022aab80b47 100644 --- a/rs/moq-net/src/lite/ietf.rs +++ b/rs/moq-net/src/lite/ietf.rs @@ -951,7 +951,7 @@ mod hop_tests { properties: Properties::default(), }) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let frame = next(&mut received).await.unwrap(); assert_eq!(&frame.payload.contiguous(0)[..], b"b"); @@ -1108,7 +1108,7 @@ mod hop_tests { let info = kio::clock::timeout(TIMEOUT, copy.info()).await.unwrap().unwrap(); assert!(info.properties.is_none()); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(5), b"key".to_vec()).unwrap(); let mut received = recv(&mut subscriber).await; let frame = next(&mut received).await.unwrap(); @@ -1118,7 +1118,7 @@ mod hop_tests { ); assert!(frame.fields.is_none() && received.wire().is_none()); group.write_frame(ts(6), b"delta".to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let frame = next(&mut received).await.unwrap(); assert_eq!( (frame.timestamp, &frame.payload.contiguous(0)[..]), @@ -1146,7 +1146,7 @@ mod hop_tests { let track = broadcast.broadcast().create_track("video", info).unwrap(); let mut head = track.create_group(0u64.into()).unwrap(); head.write_frame(ts(100), b"frame".to_vec()).unwrap(); - head.close().unwrap(); + head.finish().unwrap(); let (downstream, sessions) = test_hop(&upstream, "room", offer).await; let broadcast = downstream.consume().request("room", None).await.unwrap(); // A listing carries no provenance, so it lists the track as native lite. @@ -1190,7 +1190,7 @@ mod hop_tests { let start = if negotiated { ts(50) } else { ts(150) }; let mut group = track.create_group(1u64.into()).unwrap(); group.write_frame(start, b"frame".to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut received = recv(&mut subscriber).await; assert_eq!(received.start, 1); let frame = next(&mut received).await.unwrap(); @@ -1216,10 +1216,10 @@ mod hop_tests { assert_eq!(subscriber.info().compression, crate::track::Compression::Deflate); let payload = |n: u8| vec![n; 300]; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(5), payload(1)).unwrap(); group.write_frame(ts(6), payload(2)).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut received = recv(&mut subscriber).await; for (millis, n) in [(5, 1), (6, 2)] { let frame = next(&mut received).await.unwrap(); diff --git a/rs/moq-net/src/lite/publisher.rs b/rs/moq-net/src/lite/publisher.rs index f60f510f90d..5d4b702d9f8 100644 --- a/rs/moq-net/src/lite/publisher.rs +++ b/rs/moq-net/src/lite/publisher.rs @@ -3356,11 +3356,11 @@ mod test { let producer = track_producer("test"); for second in 0..3 { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(Timestamp::from_millis(second * 1000).unwrap(), b"x".to_vec()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } // What run_subscribe hands the model for a peer that sent no budget at all. @@ -3420,7 +3420,7 @@ mod test { let write = |producer: &mut track::Producer, key: u64| { let mut group = producer.create_group(crate::group::Info { start: key }).unwrap(); group.write_frame(group.key_time(), b"x".to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; // Group 7 arrives first: run_track resolves the start there and raises @@ -3457,7 +3457,7 @@ mod test { let write = |producer: &mut track::Producer, key: u64| { let mut group = producer.create_group(crate::group::Info { start: key }).unwrap(); group.write_frame(group.key_time(), b"x".to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; write(&mut producer, 7); @@ -3482,9 +3482,9 @@ mod test { producer .create_group(group::Info { start: 5 }) .unwrap() - .close() + .finish() .unwrap(); - producer.finish_at(track::Position::group(7), None).unwrap(); + producer.finish_at(track::Position::group(7)).unwrap(); // Group 5 is delivered first. match recv_next(&mut subscriber, true).await.unwrap() { @@ -3504,7 +3504,7 @@ mod test { producer .create_group(group::Info { start: 6 }) .unwrap() - .close() + .finish() .unwrap(); match recv_next(&mut subscriber, false).await.unwrap() { Recv::Group(group) => assert_eq!(group.start, 6), @@ -3530,9 +3530,7 @@ mod test { true => subscriber.with_range(..3), false => subscriber, }; - producer - .finish_at(track::Position::group(7), Some(Error::App(7))) - .unwrap(); + producer.end_at(track::Position::group(7), Some(Error::App(7))).unwrap(); let next = |subscriber: &mut track::Subscriber| { kio::wait(|waiter| poll_recv_next(subscriber, Some(ALL), true, end_error, waiter)).now_or_never() }; @@ -3562,7 +3560,7 @@ mod test { producer .create_group(group::Info { start: 2 }) .unwrap() - .close() + .finish() .unwrap(); match recv_next(&mut subscriber, false).await.unwrap() { Recv::Group(group) => assert_eq!(group.start, 2), @@ -3573,7 +3571,7 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); match recv_next(&mut subscriber, false).now_or_never() { Some(Ok(Recv::Group(group))) => assert_eq!(group.start, 1), @@ -3583,7 +3581,7 @@ mod test { // Staleness is the max delay window's job, not arrival order's: the track // still finishes normally afterward. - producer.finish_at(track::Position::group(3), None).unwrap(); + producer.finish_at(track::Position::group(3)).unwrap(); match recv_next(&mut subscriber, false).await.unwrap() { Recv::Finished => {} _ => panic!("expected finished"), @@ -7057,7 +7055,7 @@ mod serve_group_test { for i in 0..4u8 { group.write_frame(group.key_time(), vec![i]).unwrap(); } - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let ending = |group, frame| Frames { last: Some((group, frame)), ..Frames::default() @@ -7177,9 +7175,9 @@ mod serve_group_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let mut old = track.append_next().unwrap(); + let mut old = track.append_group(None).unwrap(); old.write_frame(old.key_time(), b"old".as_slice()).unwrap(); - old.close().unwrap(); + old.finish().unwrap(); let group = subscriber.recv_group().await.unwrap().expect("old group"); let handle = subscription.priority.insert(Priority::new(0, 0, 0)); @@ -7190,10 +7188,10 @@ mod serve_group_test { ); kio::clock::sim::advance(Duration::from_secs(1)).await; - let mut edge = track.append_next().unwrap(); + let mut edge = track.append_group(None).unwrap(); edge.write_frame(Timestamp::from_millis(1000).unwrap(), b"edge".as_slice()) .unwrap(); - edge.close().unwrap(); + edge.finish().unwrap(); assert!(matches!(serve.await, Err(Error::Old))); assert_eq!(log.resets(), vec![crate::StreamError::Old.to_code()]); @@ -7248,7 +7246,7 @@ mod serve_group_test { for _ in 0..FRAMES { group.write_frame(Timestamp::ZERO, vec![b'x'; FRAME]).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let before = billed(); let meter = registry.publisher_meter(crate::Path::from_static("demo"), &crate::stats::Tier::default()); let consumer = subscriber @@ -7391,7 +7389,7 @@ mod serve_group_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let mut old = track.append_next().unwrap(); + let mut old = track.append_group(None).unwrap(); old.write_frame(old.key_time(), b"old".as_slice()).unwrap(); let group = subscriber.recv_group().await.unwrap().expect("old group"); @@ -7403,10 +7401,10 @@ mod serve_group_test { ); kio::clock::sim::advance(Duration::from_secs(1)).await; - let mut edge = track.append_next().unwrap(); + let mut edge = track.append_group(None).unwrap(); edge.write_frame(Timestamp::from_millis(1000).unwrap(), b"edge".as_slice()) .unwrap(); - edge.close().unwrap(); + edge.finish().unwrap(); assert!(matches!(serve.await, Err(Error::Old))); assert_eq!(log.resets(), vec![crate::StreamError::Old.to_code()]); @@ -7442,7 +7440,7 @@ mod serve_group_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let old = track.append_next().unwrap(); + let old = track.append_group(None).unwrap(); let mut frame = old .create_frame(frame::Info { timestamp: Timestamp::ZERO, @@ -7465,17 +7463,17 @@ mod serve_group_test { *open = false; drop(open); frame.write(b"b".as_slice()).unwrap(); - frame.finish().unwrap().close().unwrap(); + frame.finish().unwrap().finish().unwrap(); assert!( futures::poll!(serve.as_mut()).is_pending(), "the final byte is transport-blocked" ); kio::clock::sim::advance(Duration::from_secs(1)).await; - let mut edge = track.append_next().unwrap(); + let mut edge = track.append_group(None).unwrap(); edge.write_frame(Timestamp::from_millis(1000).unwrap(), b"edge".as_slice()) .unwrap(); - edge.close().unwrap(); + edge.finish().unwrap(); assert!(matches!(serve.await, Err(Error::Old))); assert_eq!(log.resets(), vec![crate::StreamError::Old.to_code()]); @@ -7510,9 +7508,9 @@ mod serve_group_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let mut old = track.append_next().unwrap(); + let mut old = track.append_group(None).unwrap(); old.write_frame(old.key_time(), b"old".as_slice()).unwrap(); - old.close().unwrap(); + old.finish().unwrap(); let group = subscriber.recv_group().await.unwrap().expect("old group"); let handle = subscription.priority.insert(Priority::new(0, 0, 0)); @@ -7523,10 +7521,10 @@ mod serve_group_test { ); kio::clock::sim::advance(Duration::from_secs(1)).await; - let mut edge = track.append_next().unwrap(); + let mut edge = track.append_group(None).unwrap(); edge.write_frame(Timestamp::from_millis(1000).unwrap(), b"edge".as_slice()) .unwrap(); - edge.close().unwrap(); + edge.finish().unwrap(); assert!(matches!(serve.await, Err(Error::Old))); } @@ -7690,7 +7688,7 @@ mod serve_group_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let mut producer = track.append_next().unwrap(); + let mut producer = track.append_group(None).unwrap(); producer.write_frame(Timestamp::ZERO, b"head".as_slice()).unwrap(); let group = subscriber.recv_group().await.unwrap().expect("group"); @@ -7767,7 +7765,7 @@ mod serve_group_test { .write_frame(Timestamp::from_millis(0).unwrap(), b"hello".as_slice()) .unwrap(); let consumer = group.consume(); - group.close().unwrap(); + group.finish().unwrap(); let handle = subscription.priority.insert(Priority::new(0, 0, 0)); subscription.serve_group(0, 0, handle, consumer).await.unwrap(); @@ -7813,9 +7811,9 @@ mod serve_group_test { crate::track::Info::timed(), ); let mut subscriber = track.subscribe(None); - let mut old = track.append_next().unwrap(); + let mut old = track.append_group(None).unwrap(); old.write_frame(old.key_time(), b"old".as_slice()).unwrap(); - old.close().unwrap(); + old.finish().unwrap(); let group = subscriber.recv_group().await.unwrap().expect("old group"); let handle = subscription.priority.insert(Priority::new(0, 0, 0)); @@ -7824,10 +7822,10 @@ mod serve_group_test { assert!(log.resets().is_empty()); kio::clock::sim::advance(Duration::from_secs(1)).await; - let mut edge = track.append_next().unwrap(); + let mut edge = track.append_group(None).unwrap(); edge.write_frame(Timestamp::from_millis(1000).unwrap(), b"edge".as_slice()) .unwrap(); - edge.close().unwrap(); + edge.finish().unwrap(); assert!(matches!(futures::poll!(serve.as_mut()), Poll::Ready(Err(Error::Old)))); assert_eq!(log.resets(), vec![crate::StreamError::Old.to_code()]); @@ -7864,7 +7862,7 @@ mod serve_group_test { let mut group = track.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(group.key_time(), b"hello".as_slice()).unwrap(); let consumer = group.consume(); - group.close().unwrap(); + group.finish().unwrap(); let handle = subscription.priority.insert(Priority::new(0, 0, 0)); let queue = subscription.priority.clone(); @@ -7960,14 +7958,14 @@ mod serve_group_test { ); let subscriber = track.subscribe(None); let (mut run, _, _) = lite_run(Version::Lite07, SinkSession::new(Log::default()), subscriber); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"key"[..]) .unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"more"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let update = |wanted_group| lite::SubscribeUpdate { wanted_group, priority: 0, @@ -7981,11 +7979,11 @@ mod serve_group_test { assert_eq!(track.demand().wanted(), Some(0), "stale request is not a join"); run.replace(update(Some(1))); assert_eq!(track.demand().wanted(), Some(1)); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"key"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); run.replace(update(Some(1))); assert_eq!(track.demand().wanted(), Some(1), "answered request stays answered"); run.replace(update(Some(2))); @@ -7997,7 +7995,7 @@ mod serve_group_test { group .write_frame(Timestamp::from_millis(millis).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// A datagram sender for subscription 0 on `session`, stamping in milliseconds. @@ -8180,7 +8178,7 @@ mod serve_group_test { .write_frame(Timestamp::from_millis(millis).unwrap(), vec![0u8; PAYLOAD]) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let mut tasks: kio::Tasks = kio::Tasks::new(); let turns = Arc::new(AtomicU64::new(0)); @@ -9147,7 +9145,7 @@ mod serve_group_test { }); } while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} - track.finish_at(track::Position::group(3), None).unwrap(); + track.finish_at(track::Position::group(3)).unwrap(); while run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready() {} assert_eq!( drop_updates(&mut writer, &log, Version::Lite07).await, @@ -9247,7 +9245,7 @@ mod serve_group_test { let (mut run, mut writer, log) = lite_run(version, SinkSession::new(Log::default()), subscriber); { let mut run = std::pin::pin!(kio::wait(|waiter| run.poll(&mut writer, waiter))); - track.finish_at(track::Position::group(4), None).unwrap(); + track.finish_at(track::Position::group(4)).unwrap(); write_group(&mut track, 0, 0); assert!(futures::poll!(run.as_mut()).is_pending()); write_group(&mut track, 2, 2); @@ -9280,7 +9278,7 @@ mod serve_group_test { assert!(run.poll_step(&mut writer, &kio::Waiter::noop()).is_ready()); assert_eq!(drops(&mut writer, &log, version).await, [(1, 1)], "{version:?}"); - track.finish_at(track::Position::group(2), None).unwrap(); + track.finish_at(track::Position::group(2)).unwrap(); drop(track); let Poll::Ready(result) = run.poll(&mut writer, &kio::Waiter::noop()) else { panic!("run did not finish"); @@ -9312,7 +9310,7 @@ mod serve_group_test { assert_eq!(drops(&mut writer, &log, version).await, [(1, 1)]); write_group(&mut track, 2, 2); - track.finish_at(track::Position::group(3), None).unwrap(); + track.finish_at(track::Position::group(3)).unwrap(); drop(track); kio::wait(|waiter| run.poll(&mut writer, waiter)).await.unwrap(); assert_eq!(drops(&mut writer, &log, version).await, [(1, 1)]); @@ -9440,7 +9438,7 @@ mod serve_group_test { // before this run looks. track.drop_groups(1..2, crate::StreamError::NotFound); write_group(&mut track, 1, 1); - track.finish_at(track::Position::group(2), None).unwrap(); + track.finish_at(track::Position::group(2)).unwrap(); drop(track); kio::wait(|waiter| run.poll(&mut writer, waiter)).await.unwrap(); assert_eq!(drops(&mut writer, &log, version).await, []); @@ -9471,7 +9469,7 @@ mod serve_group_test { write_group(&mut track, 1, 1); write_group(&mut track, 2, 2); - track.finish_at(track::Position::group(3), None).unwrap(); + track.finish_at(track::Position::group(3)).unwrap(); drop(track); kio::wait(|waiter| run.poll(&mut writer, waiter)).await.unwrap(); assert_eq!(drops(&mut writer, &log, version).await, [(1, 1)]); @@ -9828,7 +9826,7 @@ mod serve_group_test { let (mut run, mut writer, log) = lite_run(version, SinkSession::new(Log::default()), subscriber); write_group(&mut track, 2, 2); write_group(&mut track, 5, 5); - track.finish_at(track::Position::group(7), None).unwrap(); + track.finish_at(track::Position::group(7)).unwrap(); // Serve group 5, which resolves SUBSCRIBE_START. while run.start.resolved().is_none() { let step = run.poll_step(&mut writer, &kio::Waiter::noop()); @@ -9895,7 +9893,7 @@ mod serve_group_test { write_group(&mut track, 4, 4); write_group(&mut track, 2, 2); assert!(futures::poll!(run.as_mut()).is_pending()); - track.finish_at(track::Position::group(6), None).unwrap(); + track.finish_at(track::Position::group(6)).unwrap(); drop(track); run.await.unwrap(); } @@ -9944,7 +9942,7 @@ mod serve_group_test { kio::clock::sim::advance(Duration::from_millis(900)).await; run.replace(update(2)); kio::clock::sim::advance(Duration::from_millis(200)).await; - track.finish_at(track::Position::group(6), None).unwrap(); + track.finish_at(track::Position::group(6)).unwrap(); drop(track); kio::wait(|waiter| run.poll(&mut writer, waiter)).await.unwrap(); // The feed gives up on 2..5 once its grace passes, a miss nothing fills. Group 1 lies @@ -9989,7 +9987,7 @@ mod serve_group_test { for key in 1..5 { write_group(&mut track, key, key); } - track.finish_at(track::Position::group(5), None).unwrap(); + track.finish_at(track::Position::group(5)).unwrap(); drop(track); kio::wait(|waiter| run.poll(&mut writer, waiter)).await.unwrap(); assert_eq!(drops(&mut writer, &log, version).await, []); @@ -10075,7 +10073,7 @@ mod serve_group_test { sent }; - track.finish_at(track::Position::group(273), None).unwrap(); + track.finish_at(track::Position::group(273)).unwrap(); step(&mut run, &mut writer); kio::wait(|waiter| writer.poll_flush(waiter)).await.unwrap(); assert_eq!( @@ -10156,7 +10154,7 @@ mod serve_group_test { kio::clock::sim::advance(Duration::from_secs(2)).await; write_group(&mut track, 4, 4); assert!(futures::poll!(run.as_mut()).is_pending()); - track.finish_at(track::Position::group(5), None).unwrap(); + track.finish_at(track::Position::group(5)).unwrap(); drop(track); run.await.unwrap(); } @@ -10372,7 +10370,7 @@ mod serve_group_test { headless .write_frame(Timestamp::from_millis(5).unwrap(), b"x".as_slice()) .unwrap(); - headless.close().unwrap(); + headless.finish().unwrap(); write_group(&mut track, 6, 6); relay.settle(); @@ -10400,7 +10398,7 @@ mod serve_group_test { headless .write_frame(Timestamp::from_millis(5).unwrap(), b"x".as_slice()) .unwrap(); - headless.close().unwrap(); + headless.finish().unwrap(); write_group(&mut track, 6, 6); relay.settle(); @@ -11685,7 +11683,7 @@ mod tests { for &key in keys { let mut group = track.create_group(group::Info { start: key }).unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } } @@ -11937,7 +11935,7 @@ mod tests { for frame in [&b"key"[..], b"abc", b"d"] { group.write_frame(group.key_time(), frame).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); assert!(!drive(&mut serve).await, "the subscription ended"); let RequestState::Serve(SubscribeServe::Run(run)) = &serve.state else { panic!("the subscription is not running"); @@ -11951,7 +11949,7 @@ mod tests { for frame in [&b"key"[..], b"abc", b"d"] { group.write_frame(group.key_time(), frame).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); session.push(&update(Some(2), 5).encode_bytes(version).unwrap()); assert!(!drive(&mut serve).await, "the subscription ended"); let RequestState::Serve(SubscribeServe::Run(run)) = &serve.state else { @@ -12105,7 +12103,7 @@ mod tests { group .write_frame(crate::Timestamp::from_millis(appended).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); appended += 1; } if appended == GROUPS { @@ -12317,7 +12315,7 @@ mod tests { for _ in 0..FRAMES { group.write_frame(crate::Timestamp::ZERO, b"x".to_vec()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); peer_setup.set(crate::lite::Setup::default()).unwrap(); @@ -12396,7 +12394,7 @@ mod tests { .create_track("video", track::Info::timed()) .unwrap(); broadcast.announce().unwrap(); - let mut open = track.append_next().unwrap(); + let mut open = track.append_group(None).unwrap(); open.write_frame(open.key_time(), b"a".to_vec()).unwrap(); let peer_setup = crate::lite::PeerSetup::new(false, crate::transport::Address::Setup); @@ -12446,11 +12444,11 @@ mod tests { // The track runs a full second past the group's successor. for ms in [1000, 2000] { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(crate::Timestamp::from_millis(ms).unwrap(), b"x".to_vec()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } assert!(drive(&mut serve).await, "the budget ends the response"); assert_eq!(session.log.resets(), vec![crate::StreamError::Old.to_code()]); @@ -12906,7 +12904,7 @@ mod tests { let mut bench = PausedBench::new(1); let run = &mut bench.coverage.run; let empty = bench.coverage.track.create_group(group::Info { start: 200 }).unwrap(); - let empty = empty.close().unwrap(); + let empty = empty.finish().unwrap(); run.pause(Paused { group: empty.consume(), frame_start: 0, diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index 2dcfa8c5857..a3ef5ffac95 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -3770,14 +3770,14 @@ mod tests { const VERSION: Version = Version::Lite05; /// A pre-lite-05 relay's track, untimed, with a fetch of `key` queued on it. - fn feed_fetch(key: u64) -> (track::Producer, kio::Pending, track::Fill) { + fn feed_fetch(key: u64) -> (track::Producer, kio::Pending, track::FillGroups) { let info = track::Info::default().with_timescale(None).with_max_age(None); let track = track::Producer::new(std::sync::Arc::new(crate::broadcast::Info::default()), "video", info); // The relay's copy of the upstream feed, whose groups may land out of order. track.received(); let dynamic = track.requests(); let fetching = track.consume().fetch_group(key, None); - let req = dynamic.requested_fill().now_or_never().expect("queued").unwrap(); + let req = dynamic.requested_groups().now_or_never().expect("queued").unwrap(); (track, fetching, req) } @@ -3820,7 +3820,7 @@ mod tests { group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let Ok(mut ledger) = tail.write() else { panic!("ledger closed") }; @@ -3939,7 +3939,7 @@ mod tests { group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } kio::clock::sleep(crate::tail::GRACE * 2).await; @@ -4001,7 +4001,7 @@ mod tests { group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); fetches.poll(&sub, now, &kio::Waiter::noop()); let group = fetching .now_or_never() @@ -4014,7 +4014,11 @@ mod tests { /// Many group fetches on one track share model state, but never share readiness. fn feed_batch( keys: impl IntoIterator, - ) -> (track::Producer, Vec>, Vec) { + ) -> ( + track::Producer, + Vec>, + Vec, + ) { let info = track::Info::default().with_timescale(None).with_max_age(None); let track = track::Producer::new(Arc::new(crate::broadcast::Info::default()), "video", info); // The relay's copy of the upstream feed, whose groups may land out of order. @@ -4024,7 +4028,7 @@ mod tests { let mut requests = Vec::new(); for key in keys { callers.push(track.consume().fetch_group(key, None)); - requests.push(dynamic.requested_fill().now_or_never().expect("queued").unwrap()); + requests.push(dynamic.requested_groups().now_or_never().expect("queued").unwrap()); } (track, callers, requests) } @@ -4147,7 +4151,7 @@ mod tests { assert_eq!(fetches.polled - polled, 1); assert!(!fetches.held.contains_key(&1)); let polled = fetches.polled; - track.finish_at(Position::group(5), None).unwrap(); + track.finish_at(Position::group(5)).unwrap(); fetches.poll(&sub, start, &waiter); assert_eq!(fetches.polled - polled, 2); assert_eq!(fetches.held.len(), 1); @@ -4206,7 +4210,7 @@ mod tests { let waiter = kio::Waiter::noop(); // Reading judges the reader's misses. let _ = reader.poll_recv_group(&waiter); - let fill = dynamic.requested_fill().now_or_never().expect("queued").unwrap(); + let fill = dynamic.requested_groups().now_or_never().expect("queued").unwrap(); assert_eq!((fill.start().group, fill.end()), (0, WIDE)); let mut fetches = FeedFetches::new(&clock); @@ -4216,7 +4220,7 @@ mod tests { assert_eq!(fetches.polled, 1); assert!(reader.poll_recv_group(&waiter).is_pending()); assert!( - dynamic.requested_fill().now_or_never().is_none(), + dynamic.requested_groups().now_or_never().is_none(), "a refusal is not asked again" ); } @@ -4241,7 +4245,7 @@ mod tests { let mut joined: Vec<_> = (1..=3).map(|key| track.consume().fetch_group(key, None)).collect(); assert!( - dynamic.requested_fill().now_or_never().is_none(), + dynamic.requested_groups().now_or_never().is_none(), "joins existing fills" ); drop(callers); @@ -4254,7 +4258,7 @@ mod tests { assert!(fetches.held.is_empty(), "the last reader leaving releases every fill"); assert!(fetches.ready.read().is_empty()); assert_eq!(fetches.fold.deadline(), None); - assert!(dynamic.requested_fill().now_or_never().is_none()); + assert!(dynamic.requested_groups().now_or_never().is_none()); } #[kio::test] @@ -4271,7 +4275,7 @@ mod tests { drop(caller); let next = track.consume().fetch_group(1, None); let req = dynamic - .requested_fill() + .requested_groups() .now_or_never() .expect("replacement queued") .unwrap(); @@ -5105,7 +5109,7 @@ mod tests { "video", crate::track::Info::timed(), ); - track.finish_at(Position::group(3), None).unwrap(); + track.finish_at(Position::group(3)).unwrap(); let res = serve_group(version, 3, &track).await; match version { Version::Lite05 => { @@ -5385,7 +5389,7 @@ mod tests { before .write_frame(Timestamp::from_millis(1000).unwrap(), &b"before"[..]) .unwrap(); - before.close().unwrap(); + before.finish().unwrap(); subscriber.subscribes.lock().insert( 7, TrackEntry::accepted( @@ -5468,7 +5472,7 @@ mod tests { ); let mut cached = track.create_group(group::Info { start: 0 }).unwrap(); cached.write_frame(cached.key_time(), &b"0"[..]).unwrap(); - cached.close().unwrap(); + cached.finish().unwrap(); track.set_idle(); let mut entry = TrackEntry::accepted(track.clone(), Default::default(), Default::default()); @@ -5486,7 +5490,7 @@ mod tests { newest .write_frame(Timestamp::from_millis(300).unwrap(), &b"3"[..]) .unwrap(); - newest.close().unwrap(); + newest.finish().unwrap(); assert!(track.is_live(), "header first: {header_first}"); let subscription = crate::track::Subscription::default() @@ -5540,7 +5544,7 @@ mod tests { ); let mut cached = track.create_group(group::Info { start: 3 }).unwrap(); cached.write_frame(cached.key_time(), &b"x"[..]).unwrap(); - cached.close().unwrap(); + cached.finish().unwrap(); let tail = kio::Producer::new(Tail::default()); subscriber.subscribes.lock().insert( 7, @@ -5653,7 +5657,7 @@ mod tests { let frame = original.read_frame().await.unwrap().unwrap(); assert_eq!(&frame.payload[..], b"first"); if !first_fails { - first.close().unwrap(); + first.finish().unwrap(); let res = kio::wait(|waiter| duplicate.poll_serve(waiter)).await; assert!(matches!(res, Err(Error::Duplicate)), "{res:?}"); assert!(original.read_frame().await.unwrap().is_none()); @@ -6221,7 +6225,7 @@ mod tests { let serving = ServeLoop::new(&serve, request, crate::track::Info::timed()); let mut group = serving.serving.create_group(group::Info { start: 2 }).unwrap(); group.write_frame(group.key_time(), b"2".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut reader = broadcast .consume() .track("video") @@ -6513,7 +6517,7 @@ mod tests { group .write_frame(crate::Timestamp::from_millis(key * 1000).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } // From group 0, which a time start names whatever is held, so the reader asks the // missing groups straight away rather than looking up where its start falls. @@ -6528,7 +6532,7 @@ mod tests { ) .ordered(); assert!(reader.poll_next_group(&waiter).is_pending(), "groups 0..4 are owed"); - let Poll::Ready(Ok(fill)) = requests.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = requests.poll_requested_groups(&waiter) else { panic!("groups 0..4 are a miss"); }; let mut fills = fills::RangeFills::default(); @@ -6664,7 +6668,7 @@ mod tests { }; let frame = |mut group: crate::group::Producer| { group.write_frame(group.key_time(), &b"x"[..])?; - group.close().map(drop) + group.finish().map(drop) }; let arrive = |serving: &mut ServeLoop, key| { let group = serving.serving.create_group(crate::group::Info { start: key }).unwrap(); @@ -6878,7 +6882,7 @@ mod tests { group .write_frame(crate::Timestamp::from_millis(5).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); serving .apply_response(&serve, drop(1, 2, &crate::StreamError::App(5))) @@ -8805,13 +8809,13 @@ 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 = Some(serving.serving.append_next().unwrap()); + let mut group = Some(serving.serving.append_group(None).unwrap()); if let Some(finished) = ended { if finished { - group.take().unwrap().close().unwrap(); + group.take().unwrap().finish().unwrap(); } if version.has_track_stream() { - serving.serving.finish_at(Position::group(1), None).unwrap(); + serving.serving.finish_at(Position::group(1)).unwrap(); } // Nothing says which groups are owed, so only the grace settles it, which has not passed. serving.mode = ServeMode::Tail { @@ -9229,7 +9233,7 @@ mod tests { .write_frame(crate::Timestamp::unscaled(group.start), frame) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); }; let wanted = |h: &Harness| { let wire = h.wire(); @@ -9805,9 +9809,9 @@ mod tests { .broadcast() .create_track("video", crate::track::Info::timed()) .unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"local".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); // The peer's own subscription, excluding the hop the server minted for // it, is served from the local front before anything is announced back. @@ -9866,9 +9870,9 @@ mod tests { "the reflected announce must not replace the local front" ); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"still".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = sub.recv_group().await.expect("recv group").expect("track ended early"); assert_eq!( &group.read_frame().await.expect("read frame").expect("frame").payload[..], @@ -12623,7 +12627,7 @@ impl FinishedServe { let Some(serving) = &self.serving else { return Poll::Ready(()); }; - match self.dynamic.poll_requested_fill(waiter) { + match self.dynamic.poll_requested_groups(waiter) { Poll::Ready(Ok(fill)) => { let info = FetchInfo::Known(serving.info().clone()); self.fetches.push(FillServeRun::new(serve.clone(), fill, info)); @@ -12958,7 +12962,7 @@ impl TrackServeRun { .. } => { // A fetch needs nothing from TRACK_INFO to go out, only to read its answer. - while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(waiter) { + while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(waiter) { fetches.push(FillServeRun::new(self.serve.clone(), fill, known.later())); } // Abandonment was checked at the top of this poll, arming its wait. @@ -13410,7 +13414,7 @@ struct FeedFetches { } struct HeldFetch { - fill: track::Fill, + fill: track::FillGroups, waiter: kio::Waiter, /// Not judged yet: what the feed already gave up on is settled at once. fresh: bool, @@ -13443,7 +13447,7 @@ impl FeedFetches { } /// Hold `fill` for the live feed. - fn push(&mut self, fill: track::Fill, feed: &track::Consumer) { + fn push(&mut self, fill: track::FillGroups, feed: &track::Consumer) { let Some(arrivals) = feed.arrivals() else { fill.drop_groups(fill.start().group..fill.end()); return; @@ -13457,7 +13461,7 @@ impl FeedFetches { } /// Wait on the next group `fill` still owes, if any. - fn hold(&mut self, fill: track::Fill, fresh: bool) { + fn hold(&mut self, fill: track::FillGroups, fresh: bool) { let mut next = Some((fill, fresh)); while let Some((fill, fresh)) = next.take() { let Some(key) = fill.wanted() else { @@ -13741,7 +13745,7 @@ impl ServeLoop { // finish the track. Later drafts made it exclusive, so // the publisher contradicted its own end. let error = end.error.clone().map(Error::from); - if let Err(err) = self.serving.finish_at(Position::group(end.group), error) { + if let Err(err) = self.serving.end_at(Position::group(end.group), error) { match serve.subscriber.version { Version::Lite05 => { tracing::warn!(track = %serve.name, group = end.group, %err, "invalid subscribe end") @@ -14194,14 +14198,13 @@ impl ServeLoop { // A fill is bounded and serves readers already waiting, so serve it ahead of // subscription churn. - match self.dynamic.poll_requested_fill(waiter) { + match self.dynamic.poll_requested_groups(waiter) { Poll::Ready(Ok(fill)) => { // Lite-07 asks for more than one group through the subscription. One - // group, or a slice of one, is what FETCH carries, and a time lookup - // names no group yet. + // group, or a slice of one, is what FETCH carries. let last = fill.end().saturating_sub(1); let groups = fill.start().frame == 0 - && fill.time().is_none() && fill.start().group < last + && fill.start().group < last && fill.group(last).frame_end().is_none(); if serve.subscriber.version.has_ranges() && groups { self.range_fills.push(fill); @@ -14398,7 +14401,7 @@ fn info_failed(info: &FetchInfo) -> Option { /// own [`FetchServeRun`], until it is answered or nobody waits on it. struct FillServeRun { serve: TrackServe, - fill: track::Fill, + fill: track::FillGroups, info: FetchInfo, run: Option<(u64, FetchServeRun)>, /// The group the last run answered. @@ -14416,7 +14419,7 @@ impl Drop for FillServeRun { } impl FillServeRun { - fn new(serve: TrackServe, fill: track::Fill, info: FetchInfo) -> Self { + fn new(serve: TrackServe, fill: track::FillGroups, info: FetchInfo) -> Self { Self { serve, fill, diff --git a/rs/moq-net/src/lite/subscriber/fills.rs b/rs/moq-net/src/lite/subscriber/fills.rs index 3b1d481e8a5..61fea0638dd 100644 --- a/rs/moq-net/src/lite/subscriber/fills.rs +++ b/rs/moq-net/src/lite/subscriber/fills.rs @@ -44,7 +44,7 @@ impl FillAsk { } /// Count `fill`'s preferences in. - fn add(&mut self, fill: &track::Fill) { + fn add(&mut self, fill: &track::FillGroups) { self.priority = self.priority.max(fill.priority()); self.max_delay = match (self.max_delay, fill.max_delay()) { (Some(ours), Some(theirs)) => Some(ours.max(theirs)), @@ -100,7 +100,7 @@ impl FillAsk { /// stream still arriving would reset it. #[derive(Default)] pub(super) struct RangeFills { - held: Vec, + held: Vec, /// What the upstream subscription asks for the fills now. pub ask: FillAsk, /// Asked groups no fill owes any more whose stream is still being read. @@ -128,7 +128,7 @@ impl RangeFills { self.held.is_empty() && self.ask.is_empty() && self.recoveries.is_empty() } - pub fn push(&mut self, fill: track::Fill) { + pub fn push(&mut self, fill: track::FillGroups) { self.held.push(fill); } @@ -477,7 +477,7 @@ impl Refusal { /// Answer `groups` of `fill`: a lost group is named dropped, as a FETCH's miss is, and /// anything else is refused for now, recorded nowhere. - fn answer(&self, fill: &track::Fill, groups: Range) { + fn answer(&self, fill: &track::FillGroups, groups: Range) { match &self.err { StreamError::NotFound if self.lost => fill.drop_groups(groups), StreamError::NotFound => fill.refuse_groups(groups, Error::NotFound), @@ -801,7 +801,7 @@ mod tests { /// A track whose cache evicted groups 0..3, with a reader of them whose fill is the next /// request. - fn missed() -> (track::Producer, track::Requests, track::Ordered, track::Fill) { + fn missed() -> (track::Producer, track::Requests, track::Ordered, track::FillGroups) { let producer = track::Producer::new( std::sync::Arc::new(crate::broadcast::Info::default()), "test", @@ -815,7 +815,7 @@ mod tests { group .write_frame(crate::Timestamp::from_millis(key * 1000).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } // From group 0, which a time start names whatever is held, so the reader asks the // missing groups straight away rather than looking up where its start falls. @@ -827,7 +827,7 @@ mod tests { } /// A reader of groups 0..3, and the fill it asks for. - fn ask(producer: &track::Producer, requests: &track::Requests) -> (track::Ordered, track::Fill) { + fn ask(producer: &track::Producer, requests: &track::Requests) -> (track::Ordered, track::FillGroups) { let waiter = kio::Waiter::noop(); let mut reader = producer .subscribe( @@ -837,7 +837,7 @@ mod tests { ) .ordered(); assert!(reader.poll_next_group(&waiter).is_pending(), "groups 0..3 are owed"); - let Poll::Ready(Ok(fill)) = requests.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = requests.poll_requested_groups(&waiter) else { panic!("groups 0..3 are a miss"); }; (reader, fill) @@ -864,7 +864,7 @@ mod tests { group .write_frame(crate::Timestamp::from_millis(key * 1000).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } for key in 0..3 { let Poll::Ready(Ok(Some(group))) = reader.poll_next_group(&waiter) else { @@ -886,7 +886,7 @@ mod tests { .ordered(); let _ = reader.poll_next_group(&waiter); assert!( - requests.poll_requested_fill(&waiter).is_pending(), + requests.poll_requested_groups(&waiter).is_pending(), "a lost group is not asked again" ); } diff --git a/rs/moq-net/src/model/broadcast.rs b/rs/moq-net/src/model/broadcast.rs index 5d5b5f0565b..4201203ea98 100644 --- a/rs/moq-net/src/model/broadcast.rs +++ b/rs/moq-net/src/model/broadcast.rs @@ -1570,7 +1570,7 @@ mod test { let producer = Info::new().produce(); let consumer = producer.consume(); let track = producer.create_track("a", crate::track::Info::timed()).unwrap(); - let _open = track.append_next().unwrap(); + let _open = track.append_group(None).unwrap(); let handle = consumer.track("a").unwrap(); assert_eq!(handle.latest_key(), Some(0)); drop(track); @@ -1584,7 +1584,7 @@ mod test { let producer = Info::new().produce(); let consumer = producer.consume(); let track = producer.create_track("a", crate::track::Info::default()).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"a"[..]) .unwrap(); @@ -1606,7 +1606,7 @@ mod test { let producer = Info::new().produce(); let consumer = producer.consume(); let track = producer.create_track("a", crate::track::Info::timed()).unwrap(); - let _open = track.append_next().unwrap(); + let _open = track.append_group(None).unwrap(); let handle = consumer.track("a").unwrap(); producer.close(); drop(track); @@ -1800,7 +1800,7 @@ mod test { let mut demand = producer.demand(); let waiter = kio::Waiter::noop(); let mut subscriber = video.subscribe(None); - let mut writing = video.append_next().unwrap(); + let mut writing = video.append_group(None).unwrap(); writing.write_frame(crate::Timestamp::ZERO, &b"key"[..]).unwrap(); assert_eq!(wanted_changed(&mut demand, &waiter), Some(true)); @@ -1842,7 +1842,7 @@ mod test { // Create the track before any consumer exists. let track1 = producer.assert_create_track("track1", crate::track::Info::timed()); - track1.append_next().unwrap().close().unwrap(); + track1.append_group(None).unwrap().finish().unwrap(); let consumer = producer.consume(); @@ -1856,7 +1856,7 @@ mod test { let mut track2_consumer = consumer2.track("track2").unwrap().subscribe(None).await.unwrap(); track2_consumer.assert_no_group(); - track2.append_next().unwrap().close().unwrap(); + track2.append_group(None).unwrap().finish().unwrap(); track2_consumer.assert_group(); } @@ -1944,7 +1944,7 @@ mod test { track3.subscribe(None).assert_is_clone(&track1); // Append a group and make sure they all get it. - track3.append_next().unwrap().close().unwrap(); + track3.append_group(None).unwrap().finish().unwrap(); track1.assert_group(); track2.assert_group(); @@ -1970,7 +1970,7 @@ mod test { let mut track1 = track1_fut.await.unwrap(); // Close the producer (simulating publisher disconnect). - producer1.append_next().unwrap().close().unwrap(); + producer1.append_group(None).unwrap().finish().unwrap(); let producer1 = producer1.finish().unwrap(); drop(producer1); @@ -1988,7 +1988,7 @@ mod test { producer2 .create_group(crate::group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); track2.assert_group(); } @@ -2007,19 +2007,19 @@ mod test { let first = dynamic.assert_request().accept(crate::track::Info::timed()); let mut group = first.create_group(crate::group::Info { start: 8 }).unwrap(); group.write_frame(at(1000), b"a".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let first = first.finish().unwrap(); drop((first, track)); let track = consumer.track("media").unwrap().subscribe(None); let second = dynamic.assert_request().accept(crate::track::Info::timed()); - let mut group = second.append_next().unwrap(); + let mut group = second.append_group(None).unwrap(); assert_eq!(group.start, 0); group.write_frame(at(500), b"b".as_slice()).unwrap(); drop((group, second, track)); let mut third = producer.create_track("media", crate::track::Info::timed()).unwrap(); - third.finish_at(crate::track::Position::group(0), None).unwrap(); + third.finish_at(crate::track::Position::group(0)).unwrap(); } /// Names that are gone leave nothing behind, served or not, so churning distinct names @@ -2032,7 +2032,7 @@ mod test { for i in 0..1000 { let track = consumer.track(&format!("requested/{i}")).unwrap().subscribe(None); let served = dynamic.assert_request().accept(crate::track::Info::timed()); - served.append_next().unwrap().close().unwrap(); + served.append_group(None).unwrap().finish().unwrap(); drop((served, track)); let track = consumer.track(&format!("refused/{i}")).unwrap().subscribe(None); @@ -2041,7 +2041,7 @@ mod test { let created = producer .create_track(format!("created/{i}"), crate::track::Info::timed()) .unwrap(); - created.append_next().unwrap().close().unwrap(); + created.append_group(None).unwrap().finish().unwrap(); } let state = producer.state.lock(); assert!(state.tracks.len() < 16, "{} names retained", state.tracks.len()); @@ -2116,7 +2116,7 @@ mod test { let mut sub = subscribing.await.expect("fulfilled by create_track"); // The fulfilled subscription is live against this very producer. - track.append_next().unwrap().close().unwrap(); + track.append_group(None).unwrap().finish().unwrap(); sub.recv_group().await.expect("recv").expect("group"); // The handler never sees the request; a fresh subscribe reuses the track. @@ -2241,7 +2241,7 @@ mod test { assert!(matches!(queued.await, Err(Error::Unroutable))); assert!(matches!(consumer.track("later"), Err(Error::Unroutable))); - served.append_next().unwrap().close().unwrap(); + served.append_group(None).unwrap().finish().unwrap(); accepted.assert_group(); } @@ -2309,7 +2309,7 @@ mod test { let pending_fetch = track.fetch_group(0, None); let fetch = dynamic.requested_fill_group().await.unwrap(); let group = fetch.accept(crate::track::Info::timed()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); pending_fetch.await.unwrap(); let mut subscriber = track.subscribe(None).await.unwrap(); @@ -2317,7 +2317,7 @@ mod test { assert!(matches!(subscriber.recv_group().await, Err(Error::Unroutable))); let stale = request.accept(crate::track::Info::timed()); - assert!(stale.append_next().is_err()); + assert!(stale.append_group(None).is_err()); } /// A staged track resolves no subscriber until it commits, and then with what was @@ -2365,7 +2365,7 @@ mod test { let producer = Info::new().produce(); let request = producer.reserve_track("track1").unwrap(); let staged = request.stage(crate::track::Info::timed()); - let mut group = staged.append_next().unwrap(); + let mut group = staged.append_group(None).unwrap(); drop(staged); let write = group.write_frame(crate::Timestamp::ZERO, b"x".as_slice()); assert!(matches!(write, Err(Error::Dropped)), "{write:?}"); @@ -2385,7 +2385,7 @@ mod test { producer.close(); assert!(matches!(consumer.track("track1"), Err(Error::Unroutable))); - track.append_next().unwrap().close().unwrap(); + track.append_group(None).unwrap().finish().unwrap(); subscriber.assert_group(); let _track = track.finish().unwrap(); } @@ -2406,7 +2406,7 @@ mod test { assert!(matches!(pending.await, Err(Error::Unroutable))); let track = request.accept(crate::track::Info::timed()); - assert!(track.append_next().is_err()); + assert!(track.append_group(None).is_err()); let mut subscriber = track.subscribe(None); assert!(matches!(subscriber.recv_group().await, Err(Error::Unroutable))); assert!(consumer.track("track1").is_err()); @@ -2470,7 +2470,7 @@ mod test { assert!(!track.is_closed()); let mut subscriber = viewer.await.unwrap(); subscriber.assert_no_group(); - track.append_next().unwrap().close().unwrap(); + track.append_group(None).unwrap().finish().unwrap(); assert!(subscriber.recv_group().await.unwrap().is_some()); // Once the viewer really leaves, the same teardown commits, and the lookup diff --git a/rs/moq-net/src/model/group.rs b/rs/moq-net/src/model/group.rs index e36ae7a2362..41382592437 100644 --- a/rs/moq-net/src/model/group.rs +++ b/rs/moq-net/src/model/group.rs @@ -291,7 +291,7 @@ pub(super) enum Outcome { #[default] Open, /// Finished with this many frames, and where it ends in its track's timescale when its - /// producer said it is whole: `None` when it only closed (see [`Producer::close`]). + /// producer said it is whole: `None` when it finished without an end (see [`Producer::finish`]). Finished(usize, Option), /// Finished with this many frames, then aborted to free its cache: a reader that took /// every frame got the whole group, and one short of it gets the error. @@ -2263,7 +2263,7 @@ impl Producer { /// [`track::Info::max_age`]). An `end` at or before the group's start is /// [`Error::TimestampMismatch`]. Fails with the abort error if the group was already /// aborted. - pub fn finish(self, end: u64) -> Result { + pub fn finish_at(self, end: u64) -> Result { if end <= self.start { return Err(Error::TimestampMismatch); } @@ -2271,12 +2271,13 @@ impl Producer { } /// End the group without saying where it ends, returning the [`Finished`] group: every - /// frame written still reaches its readers, but they can't tell the group is whole. + /// frame written still reaches its readers, but they can't tell the group is whole, since + /// only [`Self::finish_at`] declares the end a media reader checks against. /// /// What a producer that doesn't know its group's end calls, and how a relay ends a /// group that expired or arrived partial. Fails with the abort error if the group was /// already aborted. - pub fn close(self) -> Result { + pub fn finish(self) -> Result { self.end(None) } @@ -2408,7 +2409,7 @@ impl Producer { } /// Watch reader demand without keeping the group alive, such as for a paced flight to see - /// its riders leave. [`track::Fill::poll_unwanted`] resolves as soon as readers take the group. + /// its riders leave. [`track::FillGroups::poll_unwanted`] resolves as soon as readers take the group. pub fn demand(&self) -> Demand { self.handle.demand() } @@ -2970,7 +2971,7 @@ impl Handle { } /// Where the group ends in its track's timescale, once its producer finished it whole - /// (see [`Producer::finish`]). + /// (see [`Producer::finish_at`]). pub(crate) fn end(&self) -> Option { match self.state.read().outcome { Outcome::Finished(_, end) => end, @@ -4253,7 +4254,7 @@ impl Consumer { } /// Where the group ends in its track's timescale, once its producer finished it whole - /// with [`Producer::finish`]: `None` while it is open, or when it only closed. + /// with [`Producer::finish_at`]: `None` while it is open, or when it finished without an end. pub fn end(&self) -> Option { match self.cursor.state.read().outcome { Outcome::Finished(_, end) => end, @@ -5148,7 +5149,7 @@ mod test { } assert_eq!(group.handle.timestamp(), Some(timestamps[0]), "mode {mode}"); assert_eq!(group.handle.latest(), Some(timestamps[1]), "mode {mode}"); - group.close().unwrap(); + group.finish().unwrap(); } } @@ -5182,7 +5183,7 @@ mod test { Timestamp::from_millis(tail.unwrap_or(0).max(80)).unwrap(), "tail {tail:?}" ); - group.close().unwrap(); + group.finish().unwrap(); } } @@ -5197,14 +5198,14 @@ mod test { .write_frame(Timestamp::from_micros(0).unwrap(), Bytes::new()) .unwrap(); assert_eq!(timed.handle.latest(), Some(Timestamp::from_micros(0).unwrap())); - timed.close().unwrap(); + timed.finish().unwrap(); let mut untimed = Info { start: 0 }.produce_untimed(); assert_eq!(untimed.handle.latest(), None); untimed .write_frame(crate::Timestamp::unscaled(untimed.start), Bytes::new()) .unwrap(); assert_eq!(untimed.handle.latest(), None); - untimed.close().unwrap(); + untimed.finish().unwrap(); } /// Fields sit beside the frames only from the first fielded one, so every read path @@ -5242,7 +5243,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(group.start), Bytes::from_static(b"p")) .unwrap(); } - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let expected = |index: u64| (1..=10).contains(&index).then_some(index * 10); let mut objects = group.consume(); @@ -5298,7 +5299,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))); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let consumer = group.consume(); group.abort(Error::Cancel).unwrap(); assert_eq!(consumer.end_object().unwrap().id, 4); @@ -5424,7 +5425,7 @@ mod test { producer .write_frame(Timestamp::ZERO, Bytes::from_static(b"frame1")) .unwrap(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); let f0 = consumer.next_frame().now_or_never().unwrap().unwrap().unwrap(); @@ -5441,7 +5442,7 @@ mod test { let mut producer = Info { start: 0 }.produce(); let timestamp = Timestamp::from_micros(20_000).unwrap(); producer.write_frame(timestamp, Bytes::from_static(b"hello")).unwrap(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); let frame = consumer.read_frame().now_or_never().unwrap().unwrap().unwrap(); @@ -5464,7 +5465,7 @@ mod test { producer .write_frame(crate::Timestamp::unscaled(producer.start), Bytes::from_static(b"hello")) .unwrap(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); assert!(producer.handle.poll_started(&waiter).is_ready()); assert_eq!(producer.handle.timestamp(), None); @@ -5496,7 +5497,7 @@ mod test { assert_eq!(frames.len(), 2, "a refused tail leaves the whole batch intact"); assert_eq!(group.frame_count(), 0, "a refused tail publishes no prefix"); assert!(!group.is_aborted(), "a bad timestamp does not fail the group"); - group.close().unwrap(); + group.finish().unwrap(); } let mut untimed = Info { start: 0 }.produce_untimed(); @@ -5537,7 +5538,7 @@ mod test { frame.write(Bytes::from_static(b"hello")).unwrap(); frame.write(Bytes::from_static(b"world")).unwrap(); let producer = frame.finish().unwrap(); - let producer = producer.close().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. @@ -5579,7 +5580,7 @@ mod test { #[cfg(feature = "async")] fn group_finish_returns_none() { let producer = Info { start: 0 }.produce(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); let end = consumer.next_frame().now_or_never().unwrap().unwrap(); @@ -5600,7 +5601,7 @@ mod test { .map(|key| { let mut group = track.create_group(Info { start: key }).unwrap(); group.write_frame(group.key_time(), b"f".as_ref()).unwrap(); - group.close().unwrap() + group.finish().unwrap() }) .collect(); subscriber.set_range(..0); @@ -5885,7 +5886,7 @@ mod test { ); tail.write_frame(crate::Timestamp::unscaled(tail.start), Bytes::from_static(b"c")) .unwrap(); - let tail = tail.close().unwrap(); + let tail = tail.finish().unwrap(); let waiter = kio::Waiter::noop(); let mut whole = tail.consume(); @@ -5972,7 +5973,7 @@ mod test { producer .write_frame(Timestamp::ZERO, Bytes::from_static(b"data")) .unwrap(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); drop(producer); @@ -5994,7 +5995,7 @@ mod test { producer .write_frame(Timestamp::ZERO, Bytes::from_static(b"data")) .unwrap(); - producer.close().unwrap(); + producer.finish().unwrap(); let frame = consumer.next_frame().now_or_never().unwrap().unwrap().unwrap(); assert_eq!(frame.size, 4); @@ -6052,7 +6053,7 @@ mod test { Err(Error::Evicted) )); - producer.close().unwrap(); + producer.finish().unwrap(); assert!(live.read_frame().now_or_never().unwrap().unwrap().is_none()); } @@ -6106,7 +6107,7 @@ mod test { for _ in 0..10_000 { producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"x")).unwrap(); } - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let state = producer.handle.state.read(); assert_eq!(state.offset, 0); @@ -6129,7 +6130,7 @@ mod test { assert!(freed >= 3 * 1024, "freed {freed}"); assert_eq!(producer.handle.state.read().held(), 3); - let producer = producer.close().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); @@ -6149,7 +6150,7 @@ mod test { let mut c2 = c1.clone(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"b")).unwrap(); - producer.close().unwrap(); + producer.finish().unwrap(); // c2 should get the second frame (inherited index) let f = c2.next_frame().now_or_never().unwrap().unwrap().unwrap(); @@ -6166,7 +6167,7 @@ mod test { let mut producer = Producer::new(Info { start: 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(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); consumer.read_frame().now_or_never().unwrap().unwrap().unwrap(); @@ -6258,7 +6259,7 @@ mod test { .write_frame(Timestamp::ZERO, Bytes::from(vec![i as u8; 4])) .unwrap(); } - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); for i in 0..n { @@ -6278,7 +6279,7 @@ mod test { producer .write_frame(Timestamp::ZERO, Bytes::from_static(b"hello")) .unwrap(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut drained = producer.consume(); let mut behind = producer.consume(); @@ -6304,7 +6305,7 @@ mod test { let mut producer = Info { start: 0 }.produce(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"a")).unwrap(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"b")).unwrap(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut drained = producer.consume(); let mut behind = producer.consume(); @@ -6351,7 +6352,7 @@ mod test { for i in 0..5u8 { producer.write_frame(Timestamp::ZERO, Bytes::from(vec![i; 1])).unwrap(); } - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); // The first whole-frame read prefetches all five frames into the batch. @@ -6397,7 +6398,7 @@ mod test { for _ in 0..Prefetch::CAP { producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"x")).unwrap(); } - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); // Take one frame so the batch is filled but only partially drained. @@ -6466,7 +6467,7 @@ mod test { .push(Frame::new(Timestamp::ZERO, Bytes::from_static(b"e"))) .unwrap(); producer.write_frames(&mut batch).unwrap(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; let mut consumer = producer.consume(); @@ -6497,8 +6498,8 @@ mod test { assert_eq!(group.arrived(), start); assert_eq!(group.clone().arrived(), start, "a clone keeps it"); - alone.close().unwrap(); - live.close().unwrap(); + alone.finish().unwrap(); + live.finish().unwrap(); } /// A frame whose timestamp is at a different scale is converted to the group's @@ -6529,7 +6530,7 @@ mod test { let mut producer = Info { start: 0 }.produce(); producer.start_at(3).unwrap(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"d")).unwrap(); - let producer = producer.close().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); @@ -6557,7 +6558,7 @@ mod test { let mut producer = Info { start: 0 }.produce(); producer.start_at(3).unwrap(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"d")).unwrap(); - let producer = producer.close().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"); @@ -6576,7 +6577,7 @@ mod test { for i in 0..4u8 { producer.write_frame(Timestamp::ZERO, Bytes::from(vec![i])).unwrap(); } - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); consumer = consumer.with_range(..2); @@ -6607,7 +6608,7 @@ mod test { for i in 0..4u8 { producer.write_frame(Timestamp::ZERO, Bytes::from(vec![i])).unwrap(); } - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); consumer = consumer.with_range(1..=1); assert_eq!( @@ -6635,7 +6636,7 @@ mod test { fn end_at_zero_is_empty() { let mut producer = Info { start: 0 }.produce(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"x")).unwrap(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let mut consumer = producer.consume(); consumer = consumer.with_range(..0); @@ -6742,7 +6743,7 @@ mod test { frame.write(Bytes::from_static(b"b")).unwrap(); let producer = frame.finish().unwrap(); - producer.close().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")); assert_eq!(read().unwrap().payload, Bytes::from_static(b"b")); @@ -6776,7 +6777,7 @@ mod test { assert!(demand.poll_closed(&waiter).is_pending()); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"a")).unwrap(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); assert!(matches!(handle.poll_closed(&waiter), Poll::Ready(Ok(())))); assert!(matches!(demand.poll_closed(&waiter), Poll::Ready(Ok(())))); assert!( @@ -6801,7 +6802,7 @@ mod test { let mut producer = Info { start: 0 }.produce(); producer.write_frame(Timestamp::ZERO, Bytes::from_static(b"a")).unwrap(); let mut consumer = producer.consume(); - drop(producer.close().unwrap()); + drop(producer.finish().unwrap()); let waiter = kio::Waiter::noop(); assert!(consumer.poll_aborted(&waiter).is_pending()); @@ -6867,7 +6868,7 @@ mod test { first.write(Bytes::from(vec![0u8; 1023])).unwrap(); let a = first.finish().unwrap(); - a.close().unwrap(); + a.finish().unwrap(); let a = group(2); let mut third = a.create_frame(sized(1024)).unwrap(); @@ -6923,7 +6924,7 @@ mod test { } group = frame.finish().unwrap(); } - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let mut whole = group.consume(); for (i, payload) in payloads.iter().enumerate() { @@ -7085,7 +7086,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(group.start), frame.clone()) .unwrap(); } - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let mut plain = group.consume(); for _ in 0..8 { assert_eq!(read_plain(&mut plain).unwrap().unwrap(), frame); @@ -7121,7 +7122,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(group.start), frame.clone()) .unwrap(); } - let group = group.close().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) { @@ -7165,7 +7166,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), verbose(2)) .unwrap(); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let plain: usize = (0..3).map(|index| verbose(index).len()).sum(); let stored = pool.used(); @@ -7180,7 +7181,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(reference.start), verbose(index)) .unwrap(); } - let _reference = reference.close().unwrap(); + let _reference = reference.finish().unwrap(); assert!( stored - flate::ENCODER_HEAP + (plain as u64) / 2 < uncompressed.used(), "slices are stored: {stored} against {}", @@ -7263,7 +7264,7 @@ mod test { let head = fail(&mut compressed_group(&pool)); let group = successor(); group.handle.adopt_head(&head); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let mut reader = group.consume(); for index in 0..2 { assert_eq!( @@ -7307,7 +7308,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(group.start), verbose(index)) .unwrap(); } - group.close().unwrap() + group.finish().unwrap() }; let group = write(); @@ -7350,7 +7351,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(released.start), verbose(index)) .unwrap(); } - let released = released.close().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); @@ -7359,7 +7360,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(survivor.start), verbose(index)) .unwrap(); } - let survivor = survivor.close().unwrap(); + let survivor = survivor.finish().unwrap(); let late = take_slices(&released.handle, 1); released.handle().abort(Error::Evicted).unwrap(); let used = pool.used(); @@ -7410,7 +7411,7 @@ mod test { frame.write(Bytes::copy_from_slice(chunk)).unwrap(); } group = frame.finish().unwrap(); - let group = group.close().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) @@ -7445,7 +7446,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"); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); assert_eq!( group.handle.cache_size(), stored + inflated, @@ -7463,7 +7464,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), verbose(1)) .unwrap(); - let group = group.close().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); @@ -7477,7 +7478,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(group.start), verbose(1)) .unwrap(); let job = take_slices(&group.handle, 1); - let group = group.close().unwrap(); + 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"); @@ -7493,7 +7494,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), verbose(1)) .unwrap(); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let mut consumer = group.consume().with_range(1..); assert!(matches!(read_plain(&mut consumer), Err(Error::Lagged))); @@ -7551,7 +7552,7 @@ mod test { let mut frame = group.create_object(header).unwrap(); frame.write(slice).unwrap(); let group = frame.finish().unwrap(); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); assert!(matches!(read_plain(&mut group.consume()), Err(Error::WrongSize))); } @@ -7754,7 +7755,7 @@ mod test { .write_frame(crate::Timestamp::ZERO, Bytes::from_static(payload)) .unwrap(); } - producer.close().unwrap(); + producer.finish().unwrap(); reader.skip_to(4); let waiter = kio::Waiter::noop(); let res = reader.poll_read_frame(&waiter); @@ -7771,7 +7772,7 @@ mod test { producer .write_frame(crate::Timestamp::ZERO, Bytes::from_static(b"a")) .unwrap(); - let producer = producer.close().unwrap(); + let producer = producer.finish().unwrap(); let expired = Switch::default(); let mut group = producer.consume().with_expiry(Arc::new(expired.clone())); @@ -7796,7 +7797,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), verbose(0)) .unwrap(); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let job = take_slices(&group.handle, 0); let retained = job.release.clone(); group.abort(Error::Evicted).unwrap(); diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index eda22ae8a92..5b59a6bdbca 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -9025,9 +9025,9 @@ mod tests { // The query is already in flight when metadata and the abort arrive together. let track = track.accept(track::Info::timed()); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"history".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); track.abort(Error::App(7)).unwrap(); driver.poll(now, &waiter).unwrap(); let Poll::Ready(Ok(mut subscriber)) = subscribing.poll_ok(&waiter) else { @@ -9056,7 +9056,7 @@ mod tests { let source = track::Producer::new(broadcast.clone(), "catalog.json", crate::track::Info::timed()); let mut group = source.create_group(7u64.into()).unwrap(); group.write_frame(group.key_time(), b"snapshot".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let source = source.finish().unwrap(); let routes = crate::model::resume::Producer::new(); @@ -9819,9 +9819,9 @@ mod tests { .await .unwrap(); let mut metered = broadcast.track("video").unwrap().subscribe(None).await.unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"frame".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut read = unmetered.recv_group().await.unwrap().expect("a group"); assert_eq!( @@ -9871,7 +9871,7 @@ mod tests { let mut group = track.append_group(0).unwrap(); group.write_frame(crate::Timestamp::ZERO, b"dropped".as_ref()).unwrap(); group.write_frame(crate::Timestamp::ZERO, b"sent".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut read = subscriber.recv_group().await.unwrap().expect("a group"); let mut chunked = read.clone(); @@ -9924,7 +9924,7 @@ mod tests { let mut live = track.create_group(crate::group::Info { start: 1 }).unwrap(); live.write_frame(crate::Timestamp::from_millis(1).unwrap(), b"live".as_ref()) .unwrap(); - live.close().unwrap(); + live.finish().unwrap(); assert_eq!(ingress(), 4); let fetch = track.consume().fetch_group(0, None); @@ -9933,7 +9933,7 @@ mod tests { fetched .write_frame(crate::Timestamp::ZERO, b"fetched".as_ref()) .unwrap(); - fetched.close().unwrap(); + fetched.finish().unwrap(); fetch.await.unwrap(); assert_eq!(ingress(), 4 + 7, "the fetched group counts as well"); @@ -11581,9 +11581,9 @@ mod tests { .await; let source = request.accept(crate::track::Info::timed()); - let mut group = source.append_next().unwrap(); + let mut group = source.append_group(None).unwrap(); group.write_frame(group.key_time(), b"late".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let source = source.finish().unwrap(); let mut subscription = subscribing.await.expect("subscribe survives the retraction"); @@ -11629,7 +11629,7 @@ mod tests { let source = request.request_start(None).accept(crate::track::Info::timed()); let mut group = source.create_group(0u64.into()).unwrap(); group.write_frame(group.key_time(), b"snapshot".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let source = source.finish().unwrap(); let mut subscription = subscribing.await.unwrap().expect("subscribe"); assert_eq!( @@ -11679,7 +11679,7 @@ mod tests { .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); - let mut group = source.append_next().unwrap(); + let mut group = source.append_group(None).unwrap(); group.write_frame(group.key_time(), b"live".as_ref()).unwrap(); let counts = || { @@ -11758,7 +11758,7 @@ mod tests { .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); - let mut group = source.append_next().unwrap(); + let mut group = source.append_group(None).unwrap(); group.write_frame(group.key_time(), b"live".as_ref()).unwrap(); let fronts = || producer.shared.lock().fronts.len(); @@ -11891,7 +11891,7 @@ mod tests { .unwrap(); let upstream = broadcast::Info::new().produce(); let source = upstream.create_track("video", crate::track::Info::timed()).unwrap(); - let mut group = source.append_next().unwrap(); + let mut group = source.append_group(None).unwrap(); group.write_frame(group.key_time(), b"live".as_ref()).unwrap(); let fronts = || producer.shared.lock().fronts.len(); @@ -12118,7 +12118,7 @@ mod tests { if let Some((_, group)) = &mut joined { assert_eq!(read(group).await, b"d"); } - next_group.close().unwrap(); + next_group.finish().unwrap(); drop(( joined, reading, @@ -12150,9 +12150,9 @@ mod tests { .expect("the front asked the source") .expect("request"); let source = request.accept(crate::track::Info::timed()); - let mut group = source.append_next().unwrap(); + let mut group = source.append_group(None).unwrap(); group.write_frame(group.key_time(), b"cached".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut subscription = subscribing.await.unwrap().expect("subscribe"); subscription.recv_group().await.unwrap().expect("the cached group"); drop(subscription); @@ -12178,7 +12178,7 @@ mod tests { let source = request.accept(crate::track::Info::timed()); let mut group = source.create_group(1u64.into()).unwrap(); group.write_frame(group.key_time(), b"late".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _source = source.finish().unwrap(); let mut subscription = subscribing.await.unwrap().expect("subscribe survives the retraction"); @@ -13857,9 +13857,9 @@ mod tests { let source = broadcast::Info::new().produce(); for name in ["a", "b"] { let track = source.create_track(name, crate::track::Info::timed()).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), name.as_bytes()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); // The producer stays alive: the track is open, like a live SI track. std::mem::forget(track); } @@ -14190,9 +14190,9 @@ mod tests { let request = queued(&server).await; let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); request.serve(&source); let resolved = pending.await.expect("resolves"); @@ -14245,14 +14245,14 @@ mod tests { let track = replacement.create_track("video", crate::track::Info::timed()).unwrap(); // The same content: group 0 was already delivered through the old route, // so the track resumes at group 1. - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); request.serve(&replacement); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"resumed".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = rig .subscription @@ -14382,9 +14382,9 @@ mod tests { /// Write one single-frame group and read it back through `subscription`. #[cfg(feature = "async")] async fn deliver(track: &track::Producer, subscription: &mut track::Subscriber, payload: &'static [u8]) { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), payload).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = next_group(subscription).await.unwrap().expect("track ended early"); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], payload); } @@ -14776,9 +14776,9 @@ mod tests { let request = queued(&standby_server).await; let successor = broadcast::Info::new().produce(); let track = successor.create_track("video", replacement).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); request.serve(&successor); rig.incumbent_track.clone().abort(Error::Dropped).unwrap(); @@ -14827,7 +14827,7 @@ mod tests { .create_group(crate::group::Info { start: 5 }) .unwrap(); group.write_frame(group.key_time(), b"five".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(rig.subscription.recv_group().await.unwrap().unwrap().start, 5); let standby = rig.standby(&[10, 20]); drop(incumbent); @@ -14856,9 +14856,9 @@ mod tests { let standby = rig.standby(&[10, 20]); server.update(RouteInfo::new().with_hops(hops(&[11]))).unwrap(); - let mut group = rig.incumbent_track.append_next().unwrap(); + let mut group = rig.incumbent_track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"after".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = next_group(&mut rig.subscription) .await .expect("the subscription survives the update") @@ -14905,9 +14905,9 @@ mod tests { let request = queued(&incumbent).await; let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); request.serve(&source); let resolved = pending.await.expect("resolves through the incumbent"); @@ -14933,13 +14933,13 @@ mod tests { let request = queued(&echo).await; let replacement = broadcast::Info::new().produce(); let track = replacement.create_track("video", crate::track::Info::timed()).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); request.serve(&replacement); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"resumed".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = next_group(&mut subscription).await.unwrap().expect("resumed group"); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"resumed"); @@ -14971,9 +14971,9 @@ mod tests { let request = queued(&server_a).await; let source_a = broadcast::Info::new().produce(); let track_a = source_a.create_track("video", crate::track::Info::timed()).unwrap(); - let mut group = track_a.append_next().unwrap(); + let mut group = track_a.append_group(None).unwrap(); group.write_frame(group.key_time(), b"from-a".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); request.serve(&source_a); let resolved_a = pending.await.expect("resolves"); @@ -15023,9 +15023,9 @@ mod tests { let request = queued(&server_b).await; let source_b = broadcast::Info::new().produce(); let track_b = source_b.create_track("video", crate::track::Info::timed()).unwrap(); - let mut group = track_b.append_next().unwrap(); + let mut group = track_b.append_group(None).unwrap(); group.write_frame(group.key_time(), b"from-b".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); request.serve(&source_b); let resolved_b = pending.await.expect("B's front is served immediately"); @@ -15063,9 +15063,9 @@ mod tests { .unwrap(); let track = source.create_track("audio", crate::track::Info::timed()).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"steady".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut audio = rig .resolved @@ -15214,9 +15214,9 @@ mod tests { .await .expect("subscribe"); // A textbook clean end, innermost first: the group, the track, the broadcast. - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"tail".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let track = track.finish().unwrap(); drop(track); broadcast.broadcast().close(); @@ -15268,9 +15268,9 @@ mod tests { source.close(); drop(server); settle(|| resolved.is_closed()).await; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"tail".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let track = track.finish().unwrap(); drop(track); @@ -15324,9 +15324,9 @@ mod tests { .broadcast() .create_track("video", crate::track::Info::timed()) .unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"cached".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved @@ -15367,9 +15367,9 @@ mod tests { .expect("returning reader re-splices the source") .expect("source closed"); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"live".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = kio::clock::timeout(Duration::from_secs(1), again.recv_group()) .await .expect("groups past the cached edge come from the re-splice") @@ -15395,7 +15395,7 @@ mod tests { let resolved = pending.await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); - let mut writing = track.append_next().unwrap(); + let mut writing = track.append_group(None).unwrap(); writing.write_frame(writing.key_time(), b"head".as_ref()).unwrap(); let mut reading = subscription.recv_group().await.unwrap().unwrap(); assert_eq!(&reading.read_frame().await.unwrap().unwrap().payload[..], b"head"); @@ -15403,7 +15403,7 @@ mod tests { drop(subscription); kio::clock::sleep(Duration::from_millis(10)).await; writing.write_frame(writing.key_time(), b"tail".as_ref()).unwrap(); - writing.close().unwrap(); + writing.finish().unwrap(); let tail = kio::clock::timeout(Duration::from_secs(1), reading.read_frame()) .await @@ -15434,7 +15434,7 @@ mod tests { let resolved = producer.consume().request("live", None).await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); - let mut aborted = track.append_next().unwrap(); + let mut aborted = track.append_group(None).unwrap(); aborted.write_frame(aborted.key_time(), b"head".as_ref()).unwrap(); let mut reading = subscription.recv_group().await.unwrap().unwrap(); assert_eq!(&reading.read_frame().await.unwrap().unwrap().payload[..], b"head"); @@ -15444,9 +15444,9 @@ mod tests { assert!(matches!(end, Ok(Err(_))), "the group should fail: {end:?}"); // The track carries on. - let mut next = track.append_next().unwrap(); + let mut next = track.append_group(None).unwrap(); next.write_frame(next.key_time(), b"next".as_ref()).unwrap(); - next.close().unwrap(); + next.finish().unwrap(); let mut group = kio::clock::timeout(Duration::from_secs(1), subscription.recv_group()) .await .expect("the next group") @@ -15469,9 +15469,9 @@ mod tests { .broadcast() .create_track("video", crate::track::Info::timed()) .unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"cached".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); // The leaf's front view, which the next front serves from. let leaf_front = leaf_consumer.request("room/alice", None).await.expect("resolves"); @@ -15517,9 +15517,9 @@ mod tests { .await .expect("resubscribe should reach the leaf") .expect("source open"); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"live".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = subscription.recv_group().await.unwrap().unwrap(); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"cached"); drop(group); @@ -15535,9 +15535,9 @@ mod tests { // A group the leaf produced while every front was parked: the fetch re-splices // each hop to reach the leaf. - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"fetched".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let fetch = edge_resolved.track("video").unwrap().fetch_group(2, None); let mut fetch = std::pin::pin!(fetch); assert!(futures::poll!(fetch.as_mut()).is_pending(), "fetch should re-splice"); @@ -15575,9 +15575,9 @@ mod tests { .subscribe(None) .await .expect("subscribe"); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = subscription.recv_group().await.unwrap().unwrap(); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); @@ -15594,9 +15594,9 @@ mod tests { } // Still spliced to the incumbent, still delivering. - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"still".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = subscription.recv_group().await.unwrap().unwrap(); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"still"); @@ -15623,9 +15623,9 @@ mod tests { queued(&server).await.serve(&upstream); let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); - let mut group = old.append_next().unwrap(); + let mut group = old.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = next_group(&mut subscription).await.unwrap().expect("first group"); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); (producer, server, upstream, old, subscription) @@ -15681,9 +15681,9 @@ mod tests { kio::clock::sim::yield_now().await; } - let mut group = old.append_next().unwrap(); + let mut group = old.append_group(None).unwrap(); group.write_frame(group.key_time(), b"still".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = next_group(&mut subscription) .await .expect("the incumbent keeps serving") @@ -15724,9 +15724,9 @@ mod tests { queued(&server).await.serve(&upstream); let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); - let mut group = old.append_next().unwrap(); + let mut group = old.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = next_group(&mut subscription).await.unwrap().expect("first group"); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); @@ -15747,9 +15747,9 @@ mod tests { kio::clock::sim::yield_now().await; } - let mut group = old.append_next().unwrap(); + let mut group = old.append_group(None).unwrap(); group.write_frame(group.key_time(), b"last".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = next_group(&mut subscription) .await .expect("the incumbent keeps serving") @@ -15789,9 +15789,9 @@ mod tests { kio::clock::sim::yield_now().await; } - let mut group = old.append_next().unwrap(); + let mut group = old.append_group(None).unwrap(); group.write_frame(group.key_time(), b"still".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = next_group(&mut subscription) .await .expect("the incumbent keeps serving") @@ -15823,9 +15823,9 @@ mod tests { for _ in 0..10 { kio::clock::sim::yield_now().await; } - let mut group = old.append_next().unwrap(); + let mut group = old.append_group(None).unwrap(); group.write_frame(group.key_time(), b"last".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _old = old.finish().unwrap(); replacement.abort(Error::App(7)).unwrap(); @@ -15846,9 +15846,9 @@ mod tests { let (producer, _server, _upstream, old, _subscription) = remote_front().await; let resolved = producer.consume().request("room/alice", None).await.unwrap(); let video = resolved.track("video").unwrap(); - let mut group = old.append_next().unwrap(); + let mut group = old.append_group(None).unwrap(); group.write_frame(group.key_time(), b"last".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut later = video .subscribe(crate::track::Subscription { ranges: vec![crate::track::Range { @@ -16019,9 +16019,9 @@ mod tests { for _ in 0..10 { kio::clock::sim::yield_now().await; } - let mut group = old.append_next().unwrap(); + let mut group = old.append_group(None).unwrap(); group.write_frame(group.key_time(), b"draining".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = next_group(&mut subscription).await.unwrap().expect("draining group"); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"draining"); drop(group); @@ -16040,9 +16040,9 @@ mod tests { } let mut again = resolved.track("video").unwrap().subscribe(None).await.unwrap(); - let mut group = old.append_next().unwrap(); + let mut group = old.append_group(None).unwrap(); group.write_frame(group.key_time(), b"after".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let outcome = kio::clock::timeout(Duration::from_secs(5), async { loop { match again.recv_group().await { @@ -16069,7 +16069,7 @@ mod tests { async fn a_parked_track_serves_whole_groups_from_its_copy() { let (producer, _server, _upstream, old, subscription) = remote_front().await; let resolved = producer.consume().request("room/alice", None).await.unwrap(); - let mut open = old.append_next().unwrap(); + let mut open = old.append_group(None).unwrap(); open.write_frame(open.key_time(), b"open".as_ref()).unwrap(); drop(subscription); kio::clock::timeout(Duration::from_secs(1), old.demand().until(|wanted| wanted.is_none())) @@ -16090,7 +16090,7 @@ mod tests { (&mut fetching).now_or_never().is_none(), "an open group needs the route" ); - open.close().unwrap(); + open.finish().unwrap(); let mut group = fetching.await.unwrap(); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"open"); } @@ -16143,9 +16143,9 @@ mod tests { .unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = subscription.recv_group().await.unwrap().unwrap(); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); @@ -16187,9 +16187,9 @@ mod tests { .unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = subscription.recv_group().await.unwrap().unwrap(); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); drop(group); @@ -16209,13 +16209,13 @@ mod tests { second.withdraw(); settle(|| resolved.is_closed()).await; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"still".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); for payload in [b"wrong0".as_ref(), b"wrong1".as_ref()] { - let mut group = incompatible.append_next().unwrap(); + let mut group = incompatible.append_group(None).unwrap(); group.write_frame(group.key_time(), payload).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut group = next_group(&mut subscription) @@ -16247,9 +16247,9 @@ mod tests { .unwrap(); let resolved = consumer.request("room/alice", None).await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"before".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = subscription.recv_group().await.unwrap().unwrap(); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"before"); drop(group); @@ -16268,9 +16268,9 @@ mod tests { second.withdraw(); settle(|| resolved.is_closed()).await; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.key_time(), b"still".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); request.reject(Error::NotFound); let mut group = next_group(&mut subscription) @@ -16962,9 +16962,9 @@ mod tests { .broadcast() .create_track("video", crate::track::Info::timed()) .unwrap(); - let mut written = track.append_next().unwrap(); + let mut written = track.append_group(None).unwrap(); written.write_frame(written.key_time(), b"frame".as_ref()).unwrap(); - written.close().unwrap(); + written.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(); @@ -17051,12 +17051,12 @@ mod tests { .create_track("video", crate::track::Info::timed()) .unwrap(); - let mut stalled = track.append_next().unwrap(); + let mut stalled = track.append_group(None).unwrap(); stalled.write_frame(stalled.key_time(), b"x".as_slice()).unwrap(); // A successor, so the stalled group is not the protected live edge. Its // timestamp is inside the max age, so the stalled group stays fresh and // subscription expiry never skips it: only reclamation can bound it. - let _successor = track.append_next().unwrap(); + let _successor = track.append_group(None).unwrap(); let mut reading = stalled.consume(); assert!(reading.read_frame().await.unwrap().is_some()); @@ -17087,9 +17087,9 @@ mod tests { .create_track("video", crate::track::Info::timed()) .unwrap(); - let mut stalled = track.append_next().unwrap(); + let mut stalled = track.append_group(None).unwrap(); stalled.write_frame(stalled.key_time(), b"x".as_slice()).unwrap(); - let _successor = track.append_next().unwrap(); + let _successor = track.append_group(None).unwrap(); let mut reading = stalled.consume(); assert!(reading.read_frame().await.unwrap().is_some()); diff --git a/rs/moq-net/src/model/resume.rs b/rs/moq-net/src/model/resume.rs index 666c7a21c09..778941a6659 100644 --- a/rs/moq-net/src/model/resume.rs +++ b/rs/moq-net/src/model/resume.rs @@ -2823,7 +2823,7 @@ mod test { let mut sub = subscribe(if routed { &logical } else { &source }, HOUR); let mut history = source.create_group(group::Info { start: 0 }).unwrap(); history.write_frame(ts(0), b"history".as_ref()).unwrap(); - history.close().unwrap(); + history.finish().unwrap(); let mut finished = recv(&mut sub); let mut live = source.create_group(group::Info { start: 1 }).unwrap(); live.write_frame(ts(1), b"live".as_ref()).unwrap(); @@ -2882,7 +2882,7 @@ mod test { let dynamic = b.requests(); let mut newer = b.create_group(group::Info { start: 1 }).unwrap(); newer.write_frame(ts(1), b"newer".as_ref()).unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); routes.serve(b.consume()); open.abort(Error::Stream(StreamError::Session(SessionError::Cancel))) .unwrap(); @@ -2902,7 +2902,7 @@ mod test { let mut late = b.create_group(group::Info { start: 0 }).unwrap(); late.write_frame(ts(0), b"first".as_ref()).unwrap(); late.write_frame(ts(1), b"continued".as_ref()).unwrap(); - late.close().unwrap(); + late.finish().unwrap(); assert_eq!(read(&mut held), Some(b"continued".to_vec())); assert_eq!(read(&mut held), None); } else { @@ -2942,7 +2942,7 @@ mod test { let dynamic = b.requests(); let mut newer = b.create_group(group::Info { start: 1 }).unwrap(); newer.write_frame(ts(1), b"newer".as_ref()).unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); routes.serve(b.consume()); open.abort(Error::Stream(StreamError::Session(SessionError::Cancel))) .unwrap(); @@ -2977,7 +2977,7 @@ mod test { let mut late = b.create_group(group::Info { start: 0 }).unwrap(); late.write_frame(ts(0), b"first".as_ref()).unwrap(); late.write_frame(ts(1), b"continued".as_ref()).unwrap(); - late.close().unwrap(); + late.finish().unwrap(); assert_eq!( read(&mut patient_held), Some(b"continued".to_vec()), @@ -2995,7 +2995,7 @@ mod test { let mut sub = subscribe(&logical, Duration::ZERO); assert!(sub.poll_finished(&kio::Waiter::noop()).is_pending()); let end = Position { group: 5, frame: 5 }; - source.finish_at(end, None).unwrap(); + source.finish_at(end).unwrap(); assert_eq!( sub.poll_finished(&kio::Waiter::noop()).map(|result| result.unwrap()), Poll::Ready(end) @@ -3017,7 +3017,7 @@ mod test { assert!(sub.poll_finished(&waiter).is_pending()); let mut b = copy(); routes.serve(b.consume()); - b.finish_at(Position::group(3), None).unwrap(); + b.finish_at(Position::group(3)).unwrap(); assert_eq!( sub.poll_finished(&waiter).map(Result::unwrap), Poll::Ready(Position::group(3)) @@ -3057,10 +3057,10 @@ mod test { let mut whole = source.create_group(group::Info { start: 0 }).unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); let mut last = source.create_group(group::Info { start: 2 }).unwrap(); last.write_frame(ts(2), b"c".as_ref()).unwrap(); - source.finish_at(Position { group: 2, frame: 1 }, None).unwrap(); + source.finish_at(Position { group: 2, frame: 1 }).unwrap(); let mut first = recv(&mut sub); assert_eq!(read(&mut first), Some(b"a".to_vec())); assert_eq!(read(&mut first), Some(b"b".to_vec())); @@ -3078,7 +3078,7 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); let end = Position { group: 4, frame: 3 }; - a.finish_at(end, None).unwrap(); + a.finish_at(end).unwrap(); let b = copy(); routes.serve(b.consume()); assert_eq!( @@ -3097,11 +3097,11 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); write(&a, 0); - a.finish_at(Position::group(1), Some(Error::App(7))).unwrap(); + a.end_at(Position::group(1), Some(Error::App(7))).unwrap(); let mut b = copy(); routes.serve(b.consume()); write(&b, 0); - b.finish_at(Position::group(1), None).unwrap(); + b.finish_at(Position::group(1)).unwrap(); assert_eq!( sub.poll_finished(&kio::Waiter::noop()).map(Result::unwrap), Poll::Ready(Position::group(1)) @@ -3137,9 +3137,9 @@ mod test { let mut sub = subscribe(&logical, HOUR); write(&a, first.group - 1); assert_eq!(recv(&mut sub).start, first.group - 1); - a.finish_at(first, None).unwrap(); + a.finish_at(first).unwrap(); let mut b = copy(); - b.finish_at(next, None).unwrap(); + b.finish_at(next).unwrap(); routes.serve(b.consume()); assert_eq!( sub.poll_finished(&kio::Waiter::noop()).map(Result::unwrap), @@ -3161,11 +3161,11 @@ mod test { routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); match boundary { - false => a.finish_at(end, Some(Error::App(7))).unwrap(), + false => a.end_at(end, Some(Error::App(7))).unwrap(), true => { - a.finish_at(end, None).unwrap(); + a.finish_at(end).unwrap(); let mut b = copy(); - b.finish_at(Position::group(5), Some(Error::App(7))).unwrap(); + b.end_at(Position::group(5), Some(Error::App(7))).unwrap(); routes.serve(b.consume()); } } @@ -3192,7 +3192,7 @@ mod test { let wake = Arc::new(Wake::default()); let waiter = kio::Waiter::new(wake.clone().into()); assert!(sub.poll_finished(&waiter).is_pending()); - a.finish_at(Position::group(3), None).unwrap(); + a.finish_at(Position::group(3)).unwrap(); assert!(wake.0.load(std::sync::atomic::Ordering::Relaxed)); assert_eq!( sub.poll_finished(&waiter).map(Result::unwrap), @@ -3208,7 +3208,7 @@ mod test { let inner = logical(&inner_routes); let mut x = copy(); inner_routes.serve(x.consume()); - x.finish_at(Position::group(3), None).unwrap(); + x.finish_at(Position::group(3)).unwrap(); let outer_routes = Producer::new(); let outer = logical(&outer_routes); outer_routes.serve(inner.consume()); @@ -3232,9 +3232,9 @@ mod test { let mut sub = subscribe(&logical, HOUR); write(&a, 4); assert_eq!(recv(&mut sub).start, 4); - a.finish_at(Position::group(5), None).unwrap(); + a.finish_at(Position::group(5)).unwrap(); let mut b = copy(); - b.finish_at(Position::group(6), Some(Error::App(7))).unwrap(); + b.end_at(Position::group(6), Some(Error::App(7))).unwrap(); routes.serve(b.consume()); assert_eq!( sub.poll_finished(&kio::Waiter::noop()).map(Result::unwrap), @@ -3251,7 +3251,7 @@ mod test { let mut a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); - a.finish_at(Position::group(5), None).unwrap(); + a.finish_at(Position::group(5)).unwrap(); let b = copy(); routes.serve(b.consume()); write(&b, 4); @@ -3274,7 +3274,7 @@ mod test { let mut a = copy(); routes.serve(a.consume()); let mut sub = subscribe(&logical, HOUR); - a.finish_at(Position { group: 4, frame: 2 }, None).unwrap(); + a.finish_at(Position { group: 4, frame: 2 }).unwrap(); let b = copy(); routes.serve(b.consume()); let mut group = b.create_group(group::Info { start: 4 }).unwrap(); @@ -3284,7 +3284,7 @@ mod test { for frame in 1..4 { group.write_frame(ts(frame), b"x".as_ref()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(read(&mut reading), Some(b"x".to_vec())); assert_eq!(read(&mut reading), Some(b"x".to_vec())); assert_eq!(read(&mut reading), None); @@ -3529,7 +3529,7 @@ mod test { let mut warm = source.create_group(group::Info { start: 2 }).unwrap(); warm.write_frame(crate::Timestamp::from_millis(0).unwrap(), b"2-0".as_ref()) .unwrap(); - warm.close().unwrap(); + warm.finish().unwrap(); routes.serve(source.consume()); assert!(resumed.is_live(), "a serving live copy is live"); @@ -3554,7 +3554,7 @@ mod test { let mut group = a.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(ts(0), b"a".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(b"a".to_vec())); @@ -3638,7 +3638,7 @@ mod test { for second in 0..4 { let mut group = a.create_group(group::Info { start: second * 1000 }).unwrap(); group.write_frame(ts(second * 1000), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } assert_eq!(drain(&mut sub, true), [2000, 3000], "routed={routed}"); assert_eq!(sub.take_stale().groups, 2, "routed={routed}"); @@ -3671,7 +3671,7 @@ mod test { routes.serve(b.consume()); assert_eq!(read(&mut reading), Some(b"c".to_vec())); - whole.close().unwrap(); + whole.finish().unwrap(); assert_eq!(read(&mut reading), None); assert!( sub.recv_group().now_or_never().is_none(), @@ -3700,7 +3700,7 @@ mod test { open.write_frame(ts(1), b"b".as_ref()).unwrap(); assert_eq!(read(&mut reading), Some(b"b".to_vec())); - open.close().unwrap(); + open.finish().unwrap(); assert_eq!(read(&mut reading), None); } @@ -3738,7 +3738,7 @@ mod test { assert_eq!((request.key(), request.frame_start()), (0, 2)); let mut rest = request.accept(None).unwrap(); rest.write_frame(ts(2), frames[2].clone()).unwrap(); - rest.close().unwrap(); + rest.finish().unwrap(); assert_eq!(read(&mut reading).as_ref(), Some(&frames[2])); assert_eq!(read(&mut reading), None); assert_eq!(read_cached(&b.consume(), 0), frames); @@ -3773,7 +3773,7 @@ mod test { let mut corrupt = group.create_object(header).unwrap(); corrupt.write(slice).unwrap(); let group = corrupt.finish().unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut reading = recv(&mut sub); assert_eq!(read(&mut reading), Some(frame().to_vec())); @@ -3819,14 +3819,14 @@ mod test { // Shrink the pool so the next write reclaims the held head. let other = track::Producer::new(broadcast, "other", crate::track::Info::timed()); pool.resize(pool.used().saturating_sub(1)); - let mut filler = other.append_next().unwrap(); + let mut filler = other.append_group(None).unwrap(); filler.write_frame(ts(0), frame()).unwrap(); - filler.close().unwrap(); + filler.finish().unwrap(); assert!(handoff.head().is_none(), "the shrink reclaimed the head"); let mut rest = request.accept(None).unwrap(); rest.write_frame(ts(1), frame()).unwrap(); - rest.close().unwrap(); + rest.finish().unwrap(); let res = reading.read_frame().now_or_never().expect("fails instead of spinning"); assert!(matches!(res, Err(Error::Dropped)), "{res:?}"); } @@ -3894,7 +3894,7 @@ mod test { let dynamic = b.requests(); routes.serve(b.consume()); assert!(reading.read_frame().now_or_never().is_none(), "fails={fails}"); - let _pending = dynamic.requested_fill().now_or_never().unwrap().unwrap(); + let _pending = dynamic.requested_groups().now_or_never().unwrap().unwrap(); if abort { b.abort(Error::Stream(StreamError::App(5))).unwrap(); @@ -4028,7 +4028,7 @@ mod test { assert_eq!((request.key(), request.frame_start()), (0, 1)); let mut rest = request.accept(None).unwrap(); rest.write_frame(ts(1), b"b".as_ref()).unwrap(); - rest.close().unwrap(); + rest.finish().unwrap(); a.abort(Error::Stream(StreamError::App(5))).unwrap(); assert_eq!(read(&mut reading), Some(b"b".to_vec())); @@ -4057,7 +4057,7 @@ mod test { let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); routes.serve(b.consume()); assert_eq!(read(&mut reading), Some(b"b".to_vec())); assert_eq!(read(&mut reading), None); @@ -4115,7 +4115,7 @@ mod test { let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); routes.serve(b.consume()); assert_eq!(read(&mut reading), Some(b"b".to_vec())); } @@ -4171,7 +4171,7 @@ mod test { let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); routes.serve(b.consume()); assert_eq!(read(&mut reading), Some(b"b".to_vec()), "fetched={fetched}"); assert_eq!(read(&mut reading), None, "fetched={fetched}"); @@ -4204,7 +4204,7 @@ mod test { assert!(fetched.read_frame().now_or_never().is_none()); let mut rest = pending.accept(None).unwrap(); rest.write_frame(ts(1), b"b".as_ref()).unwrap(); - rest.close().unwrap(); + rest.finish().unwrap(); assert_eq!(read(&mut fetched), Some(b"b".to_vec())); assert_eq!(read(&mut fetched), None); } @@ -4233,7 +4233,7 @@ mod test { let mut fetching = logical.consume().fetch_group(0, None); assert!((&mut fetching).now_or_never().is_none()); let fill = dynamic - .requested_fill() + .requested_groups() .now_or_never() .expect("the fetch reached the staged copy") .unwrap(); @@ -4241,7 +4241,7 @@ mod test { let copy = request.accept(crate::track::Info::timed()); let mut group = fill.accept(0, crate::track::Info::timed()).unwrap(); group.write_frame(ts(0), b"early".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert!( (&mut fetching).now_or_never().is_none(), "a group is never handed out before its copy's info passes" @@ -4264,11 +4264,11 @@ mod test { let staged = routes.stage(refused.consume()); let mut fetching = logical.consume().fetch_group(0, None); assert!((&mut fetching).now_or_never().is_none()); - let fill = refused_dynamic.requested_fill().now_or_never().unwrap().unwrap(); + let fill = refused_dynamic.requested_groups().now_or_never().unwrap().unwrap(); let wrong = refused.accept(crate::track::Info::timed()); let mut group = fill.accept(0, crate::track::Info::timed()).unwrap(); group.write_frame(ts(0), b"wrong".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); drop(staged); drop(wrong); @@ -4276,14 +4276,14 @@ mod test { let staged = routes.stage(request.consume()); assert!((&mut fetching).now_or_never().is_none()); let fill = dynamic - .requested_fill() + .requested_groups() .now_or_never() .expect("asked again of the next route") .unwrap(); let copy = request.accept(crate::track::Info::timed()); let mut group = fill.accept(0, crate::track::Info::timed()).unwrap(); group.write_frame(ts(0), b"right".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _logical = logical.accept(crate::track::Info::timed()); routes.splice(copy.consume(), staged); let mut fetched = fetching.now_or_never().expect("spliced").unwrap(); @@ -4302,7 +4302,7 @@ mod test { let mut fetching = logical.consume().fetch_group(0, None); assert!((&mut fetching).now_or_never().is_none()); assert!( - dynamic.requested_fill().now_or_never().is_none(), + dynamic.requested_groups().now_or_never().is_none(), "the withdrawn copy is not asked" ); @@ -4324,7 +4324,7 @@ mod test { let mut fetching = logical.consume().fetch_group(0, None); assert!((&mut fetching).now_or_never().is_none()); assert!( - dynamic.requested_fill().now_or_never().is_some(), + dynamic.requested_groups().now_or_never().is_some(), "splice={splice}: the newer stage is asked" ); } @@ -4358,7 +4358,7 @@ mod test { let mut fetching = logical.consume().fetch_group(0, None); let waiter = kio::Waiter::noop(); assert!(kio::Task::poll(&mut *fetching, &waiter).is_pending()); - let fill = dynamic.requested_fill().now_or_never().unwrap().unwrap(); + let fill = dynamic.requested_groups().now_or_never().unwrap().unwrap(); if refused { fill.refuse_groups(0..1, Error::Unauthorized); assert!( @@ -4387,11 +4387,11 @@ mod test { let _staged = routes.stage(request.consume()); let mut fetching = logical.consume().fetch_group(0, None); assert!((&mut fetching).now_or_never().is_none()); - let fill = dynamic.requested_fill().now_or_never().unwrap().unwrap(); + let fill = dynamic.requested_groups().now_or_never().unwrap().unwrap(); let _staged_copy = request.accept(crate::track::Info::timed()); let mut group = fill.accept(0, crate::track::Info::timed()).unwrap(); group.write_frame(ts(0), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert!((&mut fetching).now_or_never().is_none()); let _logical = logical.accept(crate::track::Info::timed()); @@ -4403,13 +4403,13 @@ mod test { "the stage's answer is not handed out" ); let fill = b_dynamic - .requested_fill() + .requested_groups() .now_or_never() .expect("asked of the serving copy") .unwrap(); let mut group = fill.accept(0, crate::track::Info::timed()).unwrap(); group.write_frame(ts(0), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut fetched = fetching.now_or_never().expect("answered").unwrap(); assert_eq!(read(&mut fetched), Some(b"x".to_vec())); } @@ -4426,7 +4426,7 @@ mod test { let logical = logical(&routes); let mut fetching = logical.consume().fetch_group(0, None); assert!((&mut fetching).now_or_never().is_none()); - let fill = dynamic.requested_fill().now_or_never().unwrap().unwrap(); + let fill = dynamic.requested_groups().now_or_never().unwrap().unwrap(); fill.refuse_groups(0..1, Error::Dropped); assert!((&mut fetching).now_or_never().is_none(), "the next route is asked"); @@ -4796,7 +4796,7 @@ mod test { assert_eq!((request.key(), request.frame_start()), (0, 2)); let mut rest = request.accept(None).unwrap(); rest.write_frame(ts(2), b"c".as_ref()).unwrap(); - rest.close().unwrap(); + rest.finish().unwrap(); assert_eq!(read(&mut reading), Some(b"c".to_vec())); assert_eq!(read(&mut reading), None); @@ -4832,7 +4832,7 @@ mod test { assert_eq!(request.frame_start(), 1); let mut rest = request.accept(None).unwrap(); rest.write_frame(ts(1), b"b".as_ref()).unwrap(); - rest.close().unwrap(); + rest.finish().unwrap(); assert_eq!(read(&mut reading), Some(b"b".to_vec())); assert_eq!(read(&mut reading), None); @@ -4865,7 +4865,7 @@ mod test { assert_eq!(request.frame_start(), 1); let mut rest = request.accept(None).unwrap(); rest.write_frame(ts(1), b"b".as_ref()).unwrap(); - rest.close().unwrap(); + rest.finish().unwrap(); assert_eq!(read(&mut fetched), Some(b"b".to_vec())); assert_eq!(read(&mut fetched), None); let _whole = b.consume().fetch_group(0, None); @@ -4944,7 +4944,7 @@ mod test { let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); routes.serve(b.consume()); assert!( sub.poll_recv_group(&kio::Waiter::noop()).is_pending(), @@ -4983,7 +4983,7 @@ mod test { for key in keys { let mut group = track.create_group(group::Info { start: key }).unwrap(); group.write_frame(ts(key), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } } @@ -5198,7 +5198,7 @@ mod test { fn write(track: &track::Producer, key: u64) { let mut group = track.create_group(group::Info { start: key }).unwrap(); group.write_frame(ts(key), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// The group a peek reserves, to take later. @@ -5256,7 +5256,7 @@ mod test { let mut a = copy(); routes.serve(a.consume()); write(&a, 407); - a.finish_at(Position::group(408), None).unwrap(); + a.finish_at(Position::group(408)).unwrap(); let history = Subscription::default() .with_delay(Delay::default().with_max(HOUR)) .with_ranges([track::Range { @@ -5681,7 +5681,7 @@ mod test { let mut sub = subscribe(if nested { &outer } else { &inner }, HOUR); let mut one = a.create_group(group::Info { start: 1 }).unwrap(); one.write_frame(ts(1), b"x".as_ref()).unwrap(); - let one = one.close().unwrap(); + let one = one.finish().unwrap(); write(&a, 3); let reserved = peek(&mut sub, ordered); assert_eq!(reserved.key(), 1); @@ -5720,7 +5720,7 @@ mod test { drain(&mut sub, ordered); let mut two = a.create_group(group::Info { start: 2 }).unwrap(); two.write_frame(ts(2), b"x".as_ref()).unwrap(); - let two = two.close().unwrap(); + let two = two.finish().unwrap(); let reserved = peek(&mut sub, ordered); assert_eq!(reserved.key(), 2, "{case}"); two.abort(Error::Evicted).unwrap(); @@ -5964,7 +5964,7 @@ mod test { let mut whole = a.create_group(group::Info { start: 1 }).unwrap(); whole.write_frame(ts(1), b"a".as_ref()).unwrap(); whole.write_frame(ts(2), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); failing .abort(Error::Stream(StreamError::Session(SessionError::Cancel))) .unwrap(); @@ -6008,7 +6008,7 @@ mod test { let mut whole = b.create_group(group::Info { start: 1 }).unwrap(); whole.write_frame(ts(1), b"a".as_ref()).unwrap(); whole.write_frame(ts(2), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); failing .abort(Error::Stream(StreamError::Session(SessionError::Cancel))) .unwrap(); @@ -6192,7 +6192,7 @@ mod test { let mut whole = b.create_group(group::Info { start: 0 }).unwrap(); whole.write_frame(ts(0), b"a".as_ref()).unwrap(); whole.write_frame(ts(1), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); routes.serve(b.consume()); assert_eq!(read(&mut reading), Some(b"b".to_vec())); assert_eq!(read(&mut reading), None); @@ -6219,7 +6219,7 @@ mod test { let mut whole = a.create_group(group::Info { start: 1 }).unwrap(); whole.write_frame(ts(1), b"a".as_ref()).unwrap(); whole.write_frame(ts(2), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); let mut partial = b.create_group(group::Info { start: 1 }).unwrap(); partial.write_frame(ts(1), b"a".as_ref()).unwrap(); b.clone().abort(Error::Dropped).unwrap(); @@ -6259,7 +6259,7 @@ mod test { let mut whole = a.create_group(group::Info { start: 1 }).unwrap(); whole.write_frame(ts(1), b"a".as_ref()).unwrap(); whole.write_frame(ts(2), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); let mut failing = b.create_group(group::Info { start: 1 }).unwrap(); failing.write_frame(ts(1), b"a".as_ref()).unwrap(); let mut failing = Some(failing); @@ -6311,7 +6311,7 @@ mod test { let mut whole = a.create_group(group::Info { start: 1 }).unwrap(); whole.write_frame(ts(1), b"a".as_ref()).unwrap(); whole.write_frame(ts(2), b"b".as_ref()).unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); let mut failing = b.create_group(group::Info { start: 1 }).unwrap(); failing.write_frame(ts(1), b"a".as_ref()).unwrap(); let res = match ordered { @@ -6378,7 +6378,7 @@ mod test { rest.write_frame(ts(9), b"b".as_ref()).unwrap(); rest.write_frame(ts(10), b"c".as_ref()).unwrap(); - rest.close().unwrap(); + rest.finish().unwrap(); assert_eq!(read(&mut reading), Some(b"b".to_vec()), "ordered={ordered}"); assert_eq!(read(&mut reading), Some(b"c".to_vec())); assert_eq!(read(&mut reading), None); @@ -6634,7 +6634,7 @@ mod test { assert_eq!(drain(&mut sub, false), Vec::::new()); // The replaced copy ends with the held group, declaring no end: another route continues the track. - held.close().unwrap(); + held.finish().unwrap(); a.clone().abort(Error::Dropped).unwrap(); drop(reading); assert_eq!(drain(&mut sub, false), Vec::::new()); @@ -6692,7 +6692,7 @@ mod test { let mut sub = subscribe(&logical, Duration::from_secs(10)); let mut group = a.create_group(group::Info { start: 5 }).unwrap(); group.write_frame(ts(5), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(recv(&mut sub).start, 5); let b = copy(); @@ -6702,7 +6702,7 @@ mod test { for key in [2, 6] { let mut group = b.create_group(group::Info { start: key }).unwrap(); group.write_frame(ts(key), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } sub.set_range(..); @@ -6738,7 +6738,7 @@ mod test { for key in 0..13 { let mut group = a.create_group(group::Info { start: key * 1000 }).unwrap(); group.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } assert_eq!(recv(&mut sub).start, 0); @@ -6752,7 +6752,7 @@ mod test { for key in 0..13 { let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); group.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } while let Some(Ok(Some(group))) = sub.recv_group().now_or_never() { rest.push(group.start); @@ -6842,7 +6842,7 @@ mod test { for key in 0..7 { let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); group.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut rest = Vec::new(); while let Some(Ok(Some(group))) = sub.recv_group().now_or_never() { @@ -6979,7 +6979,7 @@ mod test { for key in 0..13 { let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); group.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } while let Some(Ok(Some(_))) = sub.recv_group().now_or_never() {} @@ -7096,7 +7096,7 @@ mod test { for key in 1..4 { let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); group.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } // Asked before b held any group, the relative start resolves at its first. let group = sub.recv_group().now_or_never().unwrap().unwrap().unwrap(); @@ -7142,7 +7142,7 @@ mod test { routes.serve(a.consume()); let mut first = a.create_group(group::Info { start: 3000 }).unwrap(); first.write_frame(ts(3000), b"x".as_ref()).unwrap(); - first.close().unwrap(); + first.finish().unwrap(); let range = track::Range { start: track::Anchor::Time(3000), end: Some(track::Anchor::Time(3500)), @@ -7248,7 +7248,7 @@ mod test { for (track, payload) in [(&a, b"a1"), (&b, b"b1")] { let mut group = track.create_group(group::Info { start: 1 }).unwrap(); group.write_frame(ts(1), payload.as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut next = recv(&mut sub); assert_eq!(next.start, 1); @@ -7275,7 +7275,7 @@ mod test { for key in 1..=2 { let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); group.write_frame(ts(key * 1000), b"b".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } assert!(reading.read_frame().now_or_never().is_none(), "not stale yet"); @@ -7318,7 +7318,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), b"b".as_ref()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; if warm { (1..=3).for_each(write); @@ -7516,7 +7516,7 @@ mod test { for (key, ms) in [(0, 0), (1, 1000)] { let mut group = a.create_group(group::Info { start: key }).unwrap(); group.write_frame(ts(ms), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } assert_eq!(recv(&mut sub).start, 0); assert_eq!(recv(&mut sub).start, 1); @@ -7692,7 +7692,7 @@ mod test { for key in 1..=4 { let mut group = b.create_group(group::Info { start: key }).unwrap(); group.write_frame(ts(key * 10_000), b"new".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } assert!(matches!(chunks.read_chunk().now_or_never(), Some(Err(Error::Old)))); continue; @@ -7747,7 +7747,7 @@ mod test { for key in 1..=4 { let mut next = b.create_group(group::Info { start: key }).unwrap(); next.write_frame(ts(key * 1000), b"x".as_ref()).unwrap(); - next.close().unwrap(); + next.finish().unwrap(); } if partial { assert!(matches!(chunks.read_chunk().now_or_never(), Some(Err(Error::Old)))); @@ -7774,7 +7774,7 @@ mod test { let b = copy(); let mut group = b.create_group(group::Info { start: 0 }).unwrap(); group.write_frame(ts(0), b"b".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); routes.serve(b.consume()); assert!(wake.0.load(std::sync::atomic::Ordering::Relaxed)); assert!(matches!(kio::Task::poll(&mut *fetching, &waiter), Poll::Ready(Ok(_)))); @@ -7803,7 +7803,7 @@ mod test { for frame in 0..4u8 { group.write_frame(ts(0), vec![frame]).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let Poll::Ready(Ok(mut group)) = kio::Task::poll(&mut *fetching, &waiter) else { panic!("the fill did not resolve the fetch"); }; @@ -7831,7 +7831,7 @@ mod test { for key in 1..=4 { let mut group = b.create_group(group::Info { start: key * 1000 }).unwrap(); group.write_frame(ts(key * 1000), b"b".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } assert!(matches!(reading.read_frame().now_or_never(), Some(Err(Error::Old)))); } @@ -7985,7 +7985,7 @@ mod test { frame.write(bytes::Bytes::from_static(payload)).unwrap(); group = frame.finish().unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); b } @@ -8118,7 +8118,7 @@ mod test { assert_eq!((request.key(), request.frame_start()), (0, 1)); let mut rest = request.accept(None).unwrap(); rest.write_frame(ts(1), b"b".as_ref()).unwrap(); - rest.close().unwrap(); + rest.finish().unwrap(); assert_eq!(read(&mut fetched), Some(b"b".to_vec())); assert_eq!(read(&mut fetched), None); } @@ -8246,7 +8246,7 @@ mod test { let request = dynamic.requested_fill_group().now_or_never().unwrap().unwrap(); let mut rest = request.accept(None).unwrap(); rest.write_frame(ts(1), b"b".as_ref()).unwrap(); - rest.close().unwrap(); + rest.finish().unwrap(); assert_eq!(read(&mut reading), Some(b"b".to_vec()), "{code:?}"); assert_eq!(read(&mut reading), None, "{code:?}"); } @@ -8306,7 +8306,7 @@ mod test { for (key, ms) in [(1, 1000), (2, 2000)] { let mut group = b.create_group(group::Info { start: key }).unwrap(); group.write_frame(ts(ms), b"x".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } assert!(matches!(fetched.read_frame().now_or_never(), Some(Err(Error::Old)))); } @@ -8653,7 +8653,7 @@ mod test { for key in 1..=4 { let mut next = source.create_group(group::Info { start: key }).unwrap(); next.write_frame(ts(key * 1000), b"next".as_ref()).unwrap(); - next.close().unwrap(); + next.finish().unwrap(); } let result = reading.poll(&waiter); if widen { @@ -8763,7 +8763,7 @@ mod test { writer.write_frame(ts(0), b"first".as_ref()).unwrap(); } writer.write_frame(ts(1), b"second".as_ref()).unwrap(); - writer.close().unwrap(); + writer.finish().unwrap(); } Event::Update => control .update( diff --git a/rs/moq-net/src/model/resume_model.rs b/rs/moq-net/src/model/resume_model.rs index dc20efe6c7d..0c336414412 100644 --- a/rs/moq-net/src/model/resume_model.rs +++ b/rs/moq-net/src/model/resume_model.rs @@ -525,7 +525,7 @@ impl Model { part.written += 1; } if part.written == frames(group) { - part.writer.take().unwrap().close().unwrap(); + part.writer.take().unwrap().finish().unwrap(); publisher.complete.insert(group); } let most = publisher.written.entry(group).or_default(); @@ -541,7 +541,7 @@ impl Model { for slot in 0..SLOTS { while let Some(Poll::Ready(Ok(fill))) = self.instances[instance].routes[slot] .as_ref() - .map(|copy| copy.fills.poll_requested_fill(&kio::Waiter::noop())) + .map(|copy| copy.fills.poll_requested_groups(&kio::Waiter::noop())) { filled = true; let (start, end) = (fill.start().group, fill.end()); diff --git a/rs/moq-net/src/model/subscription.rs b/rs/moq-net/src/model/subscription.rs index 984a08420bf..084f7b89fe8 100644 --- a/rs/moq-net/src/model/subscription.rs +++ b/rs/moq-net/src/model/subscription.rs @@ -198,7 +198,7 @@ pub enum Anchor { /// /// Resolved from the starts of the groups the serving hop holds. When none starts at /// or before it, a hop whose [`Requests`](crate::track::Requests) handler serves its - /// history looks the start up there (see [`Fill::time`](crate::track::Fill::time)), + /// history looks the start up there (see [`FillLookup`](crate::track::FillLookup)), /// reading nothing until it answers; otherwise, or when the handler can't tell, a start /// reaches back to the oldest group. While no group is held at all it waits for one, /// reading nothing of its range meanwhile. An end includes every group starting at or diff --git a/rs/moq-net/src/model/track.rs b/rs/moq-net/src/model/track.rs index eeda631ad97..bc5b8e63eea 100644 --- a/rs/moq-net/src/model/track.rs +++ b/rs/moq-net/src/model/track.rs @@ -35,8 +35,8 @@ mod fill; mod hole; mod miss; pub(super) use fill::Asking; -pub use fill::Fill; use fill::FillState; +pub use fill::{Fill, FillGroups, FillLookup}; pub(crate) use hole::Hole; #[cfg_attr(not(feature = "async"), allow(unused_imports, reason = "async-only"))] @@ -1994,7 +1994,7 @@ impl TrackState { } /// Where group `key` ends, once its producer finished it whole: what bounds its reach - /// without a successor (see [`group::Producer::finish`]). + /// without a successor (see [`group::Producer::finish_at`]). fn own_end(&self, key: u64) -> Option { self.presented(self.lookup.get(&key)?.group.end()?) } @@ -2648,16 +2648,10 @@ impl TrackState { Deferred(std::mem::take(&mut self.deferred)) } - /// One past every key this track holds, short of the reserved `u64::MAX`. - #[cfg(any(test, feature = "fuzz"))] - fn next_key(&self) -> Result { - match self.max_key { - Some(max) => max - .checked_add(1) - .filter(|next| *next != u64::MAX) - .ok_or(coding::BoundsExceeded.into()), - None => Ok(0), - } + /// One past every key this track holds, or 0 on an empty track. No key exceeds the reserved + /// `u64::MAX`, so it never overflows. + fn next_key(&self) -> u64 { + self.max_key.map_or(0, |max| max + 1) } /// Reject a key that is still cached; a dead (aborted or evicted) @@ -4324,7 +4318,8 @@ impl Producer { } /// Create the next group, starting at `start` in the track's timescale: after every - /// group this track holds. + /// group this track holds. `None` starts it one past the largest start the track holds, + /// or at 0 on an empty track, for a track whose groups carry no media time. /// /// Appending says the producer will not go back, so it skips every start below the new /// group that it never produced, from just past its previous append (before the first, @@ -4339,12 +4334,16 @@ impl Producer { /// forward, as its media time does, or uses a new track name or instance. Reusing a start /// only corrupts this broadcast for its readers. Datagram sequences name no cached content /// and are exempt. - pub fn append_group(&self, start: u64) -> Result { + pub fn append_group(&self, start: impl Into>) -> Result { + let mut state = self.modify()?; + let start = match start.into() { + Some(start) => start, + None => state.next_key(), + }; // Reserved, so every group fits an exclusive range. if start == u64::MAX { return Err(coding::BoundsExceeded.into()); } - let mut state = self.modify()?; if state.max_key.is_some_and(|max| start <= max) { return Err(Error::TimestampMismatch); } @@ -4371,19 +4370,11 @@ impl Producer { Ok(group) } - /// [`Self::append_group`] one past every group this track holds, or at 0 on an empty - /// track: for tests that count groups rather than time them. - #[cfg(any(test, feature = "fuzz"))] - pub(crate) fn append_next(&self) -> Result { - let start = self.modify()?.next_key()?; - self.append_group(start) - } - /// Append a group holding one frame at `timestamp`, which is where the group starts. /// /// The timestamp is converted into the track's timescale. On a scale-less track it is - /// [`Timestamp::unscaled`] at the group's key. The group closes after its frame, since - /// nothing says where it ends (see [`group::Producer::close`]). + /// [`Timestamp::unscaled`] at the group's key. The group finishes after its frame, + /// since nothing says where it ends (see [`group::Producer::finish`]). pub fn write_frame(&mut self, timestamp: Timestamp, frame: B) -> Result<()> { let frame = crate::IntoBytes::into_bytes(frame); if frame.len() as u64 > group::MAX_CACHE_BYTES { @@ -4397,7 +4388,7 @@ impl Producer { let _ = group.abort(err.clone()); return Err(err); } - group.close()?; + group.finish()?; Ok(()) } @@ -4420,7 +4411,7 @@ impl Producer { /// the end that never arrived is not coming, as with sparse starts it never existed. pub(crate) fn finish_shared(&self) -> Result<()> { let mut state = self.modify()?; - let end = Position::group(state.max_key.map_or(0, |max| max + 1)); + let end = Position::group(state.next_key()); if let Outcome::Ending(declared) = &state.outcome && declared.at == end && declared.error.is_none() @@ -4433,6 +4424,20 @@ impl Producer { state.set_end(end, None) } + /// End the track with `err` after its highest group, returning the [`Finished`] track: the + /// errored counterpart of [`Self::finish`]. + /// + /// Unlike [`Self::abort`], the track keeps its history: readers and fills still get every + /// group below the end, and a reader reaching the end gets `err` instead of the end of + /// stream. Fails as [`Self::finish`] does. + pub fn fail(self, err: Error) -> Result { + let mut state = self.modify()?; + let end = Position::group(state.next_key()); + state.set_end(end, Some(err))?; + drop(state); + Ok(Finished { producer: self }) + } + /// Declare the track's exclusive end, possibly ahead of the live edge. /// /// `end` is the first position that will never be produced. [`Position::group`] @@ -4456,11 +4461,15 @@ impl Producer { /// readers wait for a missing one until a grace passes, the subscription's max delay /// or one second without one, before ending at the boundary. /// - /// With an `error`, the track ended that way rather than cleanly, yet keeps its history, - /// unlike [`Self::abort`]: readers and fills still get every group below the end, and a - /// reader reaching the end gets the error instead of the end of stream. A repeated or - /// refined end must carry the same error code. - pub fn finish_at(&mut self, end: Position, error: Option) -> Result<()> { + /// The end is clean; [`Self::fail`] ends the track with an error. + pub fn finish_at(&mut self, end: Position) -> Result<()> { + self.end_at(end, None) + } + + /// [`Self::finish_at`], ending with `error` when there is one, as [`Self::fail`] does: how + /// a session forwards the end its publisher declared, which may lie ahead of the live edge. + /// A repeated or refined end must carry the same error code. + pub(crate) fn end_at(&mut self, end: Position, error: Option) -> Result<()> { let mut state = self.modify()?; let code = |err: Option<&Error>| err.map(|err| StreamError::from(err).to_code()); // A received copy's readers wait out a grace for groups still in flight below its end. @@ -5206,7 +5215,7 @@ impl Producer { /// /// ```compile_fail,E0599 /// # fn cannot_append(track: moq_net::track::Finished) { -/// let _ = track.append_next(); +/// let _ = track.append_group(None); /// # } /// ``` #[must_use = "dropping the last handle releases the track, which new readers can then no longer find"] @@ -5323,8 +5332,8 @@ impl Requests { &self.name } - /// The next run of groups readers miss, as a [`Fill`] to serve via [`Fill::accept`] - /// and [`Fill::drop_groups`]. + /// The next [`Fill`] readers ask: a run of groups they miss, to serve via + /// [`FillGroups::accept`] and [`FillGroups::drop_groups`], or a time to look up. /// /// A relay fetches the run upstream; an origin serves the groups its cache evicted /// from its own store, as `moq-archive` does. Errors once the track is aborted. @@ -5333,11 +5342,23 @@ impl Requests { fill::poll_requested(&self.state, &self.fills, waiter) } + /// [`Self::poll_requested_fill`] for a handler that can't resolve times: each lookup is + /// dropped unanswered, so its reader falls back to the groups held. + #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] + #[cfg_attr(feature = "async", kio::wrapper)] + pub(crate) fn poll_requested_groups(&self, waiter: &kio::Waiter) -> Poll> { + loop { + if let Fill::Groups(fill) = ready!(self.poll_requested_fill(waiter))? { + return Poll::Ready(Ok(fill)); + } + } + } + /// The next fill, which a test expects to name a single group. #[cfg(test)] #[cfg_attr(feature = "async", kio::wrapper)] pub(crate) fn poll_requested_fill_group(&self, waiter: &kio::Waiter) -> Poll> { - self.poll_requested_fill(waiter).map_ok(|fill| { + self.poll_requested_groups(waiter).map_ok(|fill| { assert_eq!(fill.end() - fill.start().group, 1, "a one-group fill"); fill.group(fill.start().group) }) @@ -11254,7 +11275,7 @@ mod test { producer .create_group(group::Info { start: 0 }) .unwrap() - .close() + .finish() .unwrap(); let open = producer.create_group(group::Info { start: 1 }).unwrap(); producer.drop_groups(0..2, StreamError::Cancel); @@ -11287,7 +11308,7 @@ mod test { head.write_frame(head.key_time(), bytes::Bytes::from_static(payload)) .unwrap(); } - head.close().unwrap(); + head.finish().unwrap(); fetch.await.unwrap(); lives.push(live); } @@ -11375,7 +11396,7 @@ mod test { async fn a_finished_live_copy_wins_over_a_final_drop_a_head_waits_on() { let producer = track_producer("test", Info::timed()); let (live, head) = arriving_head(&producer).await; - let live = live.close().unwrap(); + let live = live.finish().unwrap(); producer.drop_groups(0..1, StreamError::Old); head.abort(Error::Cancel).unwrap(); @@ -11396,7 +11417,7 @@ mod test { producer.drop_groups(0..1, StreamError::Old); head.write_frame(head.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); - let head = head.close().unwrap(); + let head = head.finish().unwrap(); { let state = producer.state.read(); assert!(state.drops.iter().next().is_none()); @@ -11428,7 +11449,7 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); assert!(feed.poll_group(0, &waiter).is_pending()); assert!(feed.poll_group(u64::MAX, &waiter).is_pending()); @@ -11480,7 +11501,7 @@ mod test { let mut subscriber = producer.subscribe(replay()); assert_eq!(producer.largest(), None); - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); assert_eq!( subscriber.largest().await, Some(Position::group(0)), @@ -11504,7 +11525,7 @@ mod test { .unwrap(); assert_eq!(subscriber.largest().await, Some(Position { group: 0, frame: 2 })); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); let producer = producer.finish().unwrap(); drop(group); drop(producer); @@ -11521,13 +11542,13 @@ mod test { framed .write_frame(crate::Timestamp::unscaled(framed.start), &b"a"[..]) .unwrap(); - framed.close().unwrap(); + framed.finish().unwrap(); producer .create_group(group::Info { start: 5 }) .unwrap() - .close() + .finish() .unwrap(); - producer.finish_at(Position::group(6), None).unwrap(); + producer.finish_at(Position::group(6)).unwrap(); let mut reader = producer.consume(); assert_eq!(reader.poll_largest(&noop), Poll::Ready(Some(Position::group(5)))); @@ -11553,7 +11574,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(first.start), &b"a"[..]) .unwrap(); first.abort(Error::Cancel).unwrap(); - producer.finish_at(Position::group(1), None).unwrap(); + producer.finish_at(Position::group(1)).unwrap(); let mut reader = producer.consume(); assert_eq!(reader.poll_largest(&noop), Poll::Ready(Some(Position::group(0)))); @@ -11572,7 +11593,7 @@ mod test { reader.poll_largest(&noop), Poll::Ready(Some(Position { group: 0, frame: 1 })) ); - again.close().unwrap(); + again.finish().unwrap(); assert_eq!(reader.poll_largest(&noop), Poll::Ready(None)); } @@ -11587,7 +11608,7 @@ mod test { let mut first = producer.create_group(group::Info { start: 0 }).unwrap(); first.write_frame(first.key_time(), &b"a"[..]).unwrap(); first.abort(Error::Cancel).unwrap(); - producer.finish_at(Position::group(1), None).unwrap(); + producer.finish_at(Position::group(1)).unwrap(); let mut reader = producer.consume(); assert_eq!(reader.poll_largest(&noop), Poll::Ready(Some(Position::group(0)))); @@ -11605,7 +11626,7 @@ mod test { .accept(Info::timed()) .unwrap(); bounded.write_frame(bounded.key_time(), &b"a"[..]).unwrap(); - bounded.close().unwrap(); + bounded.finish().unwrap(); fetch.await.unwrap(); assert!( reader.poll_largest(&noop).is_pending(), @@ -11619,12 +11640,12 @@ mod test { fn a_live_edge_reader_starts_on_an_empty_largest_group() { let producer = track_producer("test", None); let noop = kio::Waiter::noop(); - let mut first = producer.append_next().unwrap(); + let mut first = producer.append_group(None).unwrap(); first .write_frame(crate::Timestamp::unscaled(first.start), &b"a"[..]) .unwrap(); - first.close().unwrap(); - let empty = producer.append_next().unwrap(); + first.finish().unwrap(); + let empty = producer.append_group(None).unwrap(); let mut reader = producer.subscribe(replay()); let Poll::Ready(Some(edge)) = reader.poll_largest(&noop) else { @@ -11633,8 +11654,8 @@ mod test { assert_eq!(edge, Position::group(1)); reader.set_range(edge.group..); - empty.close().unwrap(); - let mut next = producer.append_next().unwrap(); + empty.finish().unwrap(); + let mut next = producer.append_group(None).unwrap(); next.write_frame(crate::Timestamp::unscaled(next.start), &b"b"[..]) .unwrap(); @@ -11664,7 +11685,7 @@ mod test { let producer = track_producer("test", Info::default()); let mut subscriber = producer.subscribe(replay()); - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"a"[..]) .unwrap(); @@ -11690,7 +11711,7 @@ mod test { let flag = Arc::new(Flag(AtomicBool::new(false))); let waiter = kio::Waiter::new(futures::task::waker(flag.clone())); assert!(subscriber.poll_largest(&waiter).is_pending()); - group.close().unwrap(); + group.finish().unwrap(); assert!( flag.0.load(Ordering::SeqCst), "finishing the last group woke the reader" @@ -11750,7 +11771,7 @@ mod test { for ordered in [false, true] { let producer = track_producer("test", Info::default()); let first = framed(&producer, 0, 1); - first.close().unwrap(); + first.finish().unwrap(); let mut reader = producer.subscribe(replay()); let mut read = |waiter: &kio::Waiter| match ordered { true => reader.poll_group(true, waiter), @@ -11765,7 +11786,7 @@ mod test { let (other, moved) = Flag::waiter(); assert!(read(&moved).is_pending()); let next = framed(&producer, 1, 1); - next.close().unwrap(); + next.finish().unwrap(); assert!(other.take(), "the next group wakes the task that polled last"); assert!(matches!(read(&moved), Poll::Ready(Ok(Some(_))))); } @@ -11810,7 +11831,7 @@ mod test { #[test] fn a_range_reads_only_its_groups() { let producer = track_producer("test", None); - let _groups: Vec<_> = (3..8).map(|key| framed(&producer, key, 8).close().unwrap()).collect(); + let _groups: Vec<_> = (3..8).map(|key| framed(&producer, key, 8).finish().unwrap()).collect(); let _wide = producer.subscribe(replay()); let range = Range { start: Anchor::Time(4), @@ -11837,7 +11858,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(headless.start), &b"x"[..]) .unwrap(); } - headless.close().unwrap(); + headless.finish().unwrap(); let noop = kio::Waiter::noop(); let start = Anchor::Time(4); @@ -11942,7 +11963,7 @@ mod test { #[test] fn largest_stays_ended_when_the_bounds_widen() { let producer = track_producer("test", Info::default()); - framed(&producer, 5, 1).close().unwrap(); + framed(&producer, 5, 1).finish().unwrap(); let producer = producer.finish().unwrap(); let noop = kio::Waiter::noop(); @@ -12015,7 +12036,7 @@ mod test { let mut producer = track_producer("test", Info::default()); let noop = kio::Waiter::noop(); let _groups: Vec<_> = (0..3).map(|key| framed(&producer, key, 1)).collect(); - producer.finish_at(Position::group(10), None).unwrap(); + producer.finish_at(Position::group(10)).unwrap(); producer.set_idle(); let mut reader = producer.subscribe(replay()); @@ -12025,7 +12046,7 @@ mod test { assert_eq!(reader.poll_largest(&noop), Poll::Ready(Some(Position::group(5)))); let mut finished = track_producer("test", Info::default()); - framed(&finished, 0, 1).close().unwrap(); + framed(&finished, 0, 1).finish().unwrap(); finished.set_idle(); let finished = finished.finish().unwrap(); let mut reader = finished.subscribe(replay()); @@ -12062,7 +12083,7 @@ mod test { fn idle_copy() -> Producer { let mut producer = track_producer("test", None); for key in 0..4 { - framed(&producer, key, 1).close().unwrap(); + framed(&producer, key, 1).finish().unwrap(); } producer.set_idle(); producer @@ -12093,7 +12114,7 @@ mod test { assert_eq!(reader.floor(), None, "the start waits for the live feed"); producer.set_live(Some(Position::group(4)), None).unwrap(); - framed(&producer, 4, 1).close().unwrap(); + framed(&producer, 4, 1).finish().unwrap(); assert_eq!(ready_groups(&mut reader), expected, "{ranges:?}"); } } @@ -12105,10 +12126,10 @@ mod test { let mut producer = idle_copy(); let mut reader = producer.subscribe(replay().with_ranges([Range::live()])); producer.set_live(Some(Position::group(5)), None).unwrap(); - framed(&producer, 4, 1).close().unwrap(); + framed(&producer, 4, 1).finish().unwrap(); assert_eq!(ready_groups(&mut reader), Vec::::new(), "the answer has not shown"); - framed(&producer, 5, 1).close().unwrap(); + framed(&producer, 5, 1).finish().unwrap(); assert_eq!(ready_groups(&mut reader), vec![5]); } @@ -12124,8 +12145,8 @@ mod test { .chain(current.map(|largest| (largest, true))) { let mut producer = track_producer("test", None); - framed(&producer, 2, 1).close().unwrap(); - framed(&producer, 3, 2).close().unwrap(); + framed(&producer, 2, 1).finish().unwrap(); + framed(&producer, 3, 2).finish().unwrap(); producer.set_idle(); let mut reader = producer.subscribe(replay()); @@ -12152,8 +12173,8 @@ mod test { // Largest names the newest object, which an empty newest group does not hold. for (largest, ok) in [(Some(Position::group(2)), true), (None, false)] { let mut producer = track_producer("test", None); - framed(&producer, 2, 1).close().unwrap(); - framed(&producer, 3, 0).close().unwrap(); + framed(&producer, 2, 1).finish().unwrap(); + framed(&producer, 3, 0).finish().unwrap(); producer.set_idle(); assert_eq!(producer.set_live(largest, None).is_ok(), ok, "{largest:?}"); } @@ -12164,7 +12185,7 @@ mod test { #[test] fn an_idle_copy_judges_its_answer_against_the_ended_feed() { let mut producer = track_producer("test", None); - framed(&producer, 2, 1).close().unwrap(); + framed(&producer, 2, 1).finish().unwrap(); let _open = framed(&producer, 3, 1); producer.set_idle(); @@ -12208,7 +12229,7 @@ mod test { frame.write(&b"x"[..]).unwrap(); group = frame.finish().unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); producer.set_idle(); let answered = producer.set_live( Some(Position { @@ -12236,7 +12257,7 @@ mod test { #[test] fn an_idle_copy_with_a_future_end_waits_for_the_live_feed() { let mut producer = idle_copy(); - producer.finish_at(Position::group(10), None).unwrap(); + producer.finish_at(Position::group(10)).unwrap(); let mut live = producer.subscribe(replay().with_ranges([Range::live()])); let mut oldest = producer.subscribe(replay()); assert_eq!(ready_groups(&mut live), Vec::::new(), "the copy is idle"); @@ -12244,7 +12265,7 @@ mod test { assert_eq!(ready_groups(&mut oldest), Vec::::new(), "the copy is idle"); producer.set_live(Some(Position::group(4)), None).unwrap(); - framed(&producer, 4, 1).close().unwrap(); + framed(&producer, 4, 1).finish().unwrap(); assert_eq!(ready_groups(&mut live), vec![4]); assert_eq!(ready_groups(&mut oldest), vec![0, 1, 2, 3, 4]); } @@ -12270,7 +12291,7 @@ mod test { let producer = track_producer("test", Info::default()); // Counting back counts groups held: two below the edge the answer names. for key in [2, 3] { - framed(&producer, key, 1).close().unwrap(); + framed(&producer, key, 1).finish().unwrap(); } let back = Range { start: super::super::subscription::Anchor::Relative(2), @@ -12281,7 +12302,7 @@ mod test { let upstream = producer.resolve_subscription(&replay().with_ranges([back])).unwrap(); assert_eq!(upstream.start(), Some(2), "the answer resolves the upstream bounds"); - framed(&producer, 5, 1).close().unwrap(); + framed(&producer, 5, 1).finish().unwrap(); // The default max age serves only the live edge, so the groups held below it are stale. assert_eq!(ready_groups(&mut reader), vec![5]); assert_eq!(reader.floor(), Some(2), "the answer anchors the start"); @@ -12335,7 +12356,7 @@ mod test { replacement .write_frame(replacement.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); - replacement.close().unwrap(); + replacement.finish().unwrap(); let mut later = producer.subscribe(Subscription::default().with_range(0..)); assert!(matches!( later.poll_recv_group(&kio::Waiter::noop()), @@ -12374,7 +12395,7 @@ mod test { let consumer = producer.consume(); let fetch = consumer.fetch_group(u64::MAX, None).now_or_never(); assert!(matches!(fetch, Some(Err(Error::NotFound)))); - assert!(dynamic.requested_fill().now_or_never().is_none(), "nothing to fill"); + assert!(dynamic.requested_groups().now_or_never().is_none(), "nothing to fill"); } #[test] @@ -12382,9 +12403,9 @@ mod test { let producer = track_producer("test", Info::timed()); // Create 3 groups at time 0. - producer.append_next().unwrap().close().unwrap(); // seq 0 - producer.append_next().unwrap().close().unwrap(); // seq 1 - producer.append_next().unwrap().close().unwrap(); // seq 2 + producer.append_group(None).unwrap().finish().unwrap(); // seq 0 + producer.append_group(None).unwrap().finish().unwrap(); // seq 1 + producer.append_group(None).unwrap().finish().unwrap(); // seq 2 { let state = producer.state.read(); @@ -12396,7 +12417,7 @@ mod test { elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); // Append a new group to trigger eviction. - producer.append_next().unwrap().close().unwrap(); // seq 3 + producer.append_group(None).unwrap().finish().unwrap(); // seq 3 // Groups 0, 1, 2 are expired but seq 3 (the live edge) is kept. Their arrival // entries no longer resolve, so the leading ones are trimmed and the offset @@ -12430,7 +12451,7 @@ mod test { // The group stays open well past the LRU window, then the next period starts. elapse(&producer, cache::DEFAULT_EXPIRY * 2); - group.close().unwrap(); + group.finish().unwrap(); let _next = producer.create_group(group::Info { start: 1 }).unwrap(); assert!(consumer.next_frame().await.unwrap().is_none()); @@ -12450,11 +12471,11 @@ mod test { for _ in 0..10 { group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let mut reading = subscriber.assert_group(); // A sibling written at the same time that nobody ever reads. - producer.create_group(1u64.into()).unwrap().close().unwrap(); + producer.create_group(1u64.into()).unwrap().finish().unwrap(); // Each step stays well inside the retention window, but the whole read // spans several windows. New groups keep the expiry scan running. @@ -12465,7 +12486,7 @@ mod test { matches!(frame, Ok(Some(_))), "an actively-read group must not expire mid-read (step {seq})" ); - producer.create_group(seq.into()).unwrap().close().unwrap(); + producer.create_group(seq.into()).unwrap().finish().unwrap(); } let state = producer.state.read(); @@ -12487,7 +12508,7 @@ mod test { for _ in 0..20 { group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let mut reading = subscriber.assert_group(); // One whole-frame read per half-window: most are served straight from the @@ -12499,7 +12520,7 @@ mod test { matches!(frame, Ok(Some(_))), "a slow prefetch reader must not expire mid-read (step {seq})" ); - producer.create_group(seq.into()).unwrap().close().unwrap(); + producer.create_group(seq.into()).unwrap().finish().unwrap(); } } @@ -12514,9 +12535,9 @@ mod test { let mut group = producer.create_group(0u64.into()).unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); // A second group so seq 0 leaves the protected live edge. - producer.create_group(1u64.into()).unwrap().close().unwrap(); + producer.create_group(1u64.into()).unwrap().finish().unwrap(); // Deliver just inside the window: the delivery stamps the group. elapse(&producer, cache::DEFAULT_EXPIRY - Duration::from_secs(1)); @@ -12525,7 +12546,7 @@ mod test { // Almost another full window passes: far beyond the write, inside the // delivery stamp. The new group runs the expiry scan. elapse(&producer, cache::DEFAULT_EXPIRY - Duration::from_secs(1)); - producer.create_group(2u64.into()).unwrap().close().unwrap(); + producer.create_group(2u64.into()).unwrap().finish().unwrap(); let frame = reading.read_frame().await.unwrap(); assert!(frame.is_some(), "a just-delivered group must not expire unread"); @@ -12539,7 +12560,7 @@ mod test { let producer = track_producer("test", Info::timed()); let straggler = producer.create_group(0u64.into()).unwrap(); // The live edge moves on, so the straggler is demoted and expirable. - producer.create_group(1u64.into()).unwrap().close().unwrap(); + producer.create_group(1u64.into()).unwrap().finish().unwrap(); let mut frame = straggler .create_frame(frame::Info { @@ -12552,10 +12573,10 @@ mod test { for seq in 2..12u64 { elapse(&producer, cache::DEFAULT_EXPIRY / 2); frame.write(bytes::Bytes::from_static(b"x")).unwrap(); - producer.create_group(seq.into()).unwrap().close().unwrap(); + producer.create_group(seq.into()).unwrap().finish().unwrap(); } let straggler = frame.finish().unwrap(); - straggler.close().unwrap(); + straggler.finish().unwrap(); let state = producer.state.read(); assert!( @@ -12573,7 +12594,7 @@ mod test { let producer = track_producer("test", Info::timed()); let straggler = producer.create_group(0u64.into()).unwrap(); // The live edge moves on, so the straggler is demoted and expirable. - producer.create_group(1u64.into()).unwrap().close().unwrap(); + producer.create_group(1u64.into()).unwrap().finish().unwrap(); let mut frame = straggler .create_frame(frame::Info { @@ -12588,10 +12609,10 @@ mod test { elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); frame.write_deferred(bytes::Bytes::from_static(b"abc")).unwrap(); let straggler = frame.finish().unwrap(); - straggler.close().unwrap(); + straggler.finish().unwrap(); // A new group runs the expiry scan. - producer.create_group(2u64.into()).unwrap().close().unwrap(); + producer.create_group(2u64.into()).unwrap().finish().unwrap(); let state = producer.state.read(); assert!( @@ -12612,7 +12633,7 @@ mod test { for seq in 0..2u64 { let mut group = producer.create_group(seq.into()).unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } // Group 0 is in range; group 1 is beyond the cap and parks. @@ -12628,7 +12649,7 @@ mod test { // Almost another full window passes: far beyond the write, inside the // re-offer stamp. The new group runs the expiry scan. elapse(&producer, cache::DEFAULT_EXPIRY - Duration::from_secs(1)); - producer.create_group(2u64.into()).unwrap().close().unwrap(); + producer.create_group(2u64.into()).unwrap().finish().unwrap(); let frame = reading.read_frame().await.unwrap(); assert!(frame.is_some(), "a just-re-offered group must not expire unread"); @@ -12637,13 +12658,13 @@ mod test { #[test] fn evict_keeps_max_key() { let producer = track_producer("test", Info::timed()); - let _open = producer.append_next().unwrap(); // seq 0 + let _open = producer.append_group(None).unwrap(); // seq 0 // Advance time past the LRU window. elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); // Append another group; seq 0 is expired and evicted. - let _open = producer.append_next().unwrap(); // seq 1 + let _open = producer.append_group(None).unwrap(); // seq 1 { let state = producer.state.read(); @@ -12656,9 +12677,9 @@ mod test { #[test] fn no_eviction_when_fresh() { let producer = track_producer("test", Info::timed()); - producer.append_next().unwrap().close().unwrap(); // seq 0 - producer.append_next().unwrap().close().unwrap(); // seq 1 - producer.append_next().unwrap().close().unwrap(); // seq 2 + producer.append_group(None).unwrap().finish().unwrap(); // seq 0 + producer.append_group(None).unwrap().finish().unwrap(); // seq 1 + producer.append_group(None).unwrap().finish().unwrap(); // seq 2 { let state = producer.state.read(); @@ -12670,12 +12691,12 @@ mod test { #[test] fn consumer_skips_evicted_groups() { let producer = track_producer("test", Info::timed()); - producer.append_next().unwrap().close().unwrap(); // seq 0 + producer.append_group(None).unwrap().finish().unwrap(); // seq 0 let mut consumer = producer.subscribe(None); elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); - producer.append_next().unwrap().close().unwrap(); // seq 1 + producer.append_group(None).unwrap().finish().unwrap(); // seq 1 // Group 0 was evicted. Consumer should get group 1. let group = consumer.assert_group(); @@ -12706,9 +12727,9 @@ mod test { fn pool_sweep_expires_without_a_write() { let pool = cache::Pool::new(cache::Config::default().with_expiry(Duration::from_secs(1))); let producer = track_producer_pooled("test", pool.clone()); - let mut stalled = producer.append_next().unwrap(); // seq 0, left open + let mut stalled = producer.append_group(None).unwrap(); // seq 0, left open stalled.write_frame(stalled.key_time(), b"x".as_slice()).unwrap(); - let _open = producer.append_next().unwrap(); // seq 1, the live edge + let _open = producer.append_group(None).unwrap(); // seq 1, the live edge elapse(&producer, Duration::from_secs(2)); pool.sweep(); @@ -12728,9 +12749,9 @@ mod test { Some(now.saturating_add(Duration::from_millis(500))) ); let producer = track_producer_pooled("test", pool.clone()); - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group.write_frame(group.key_time(), b"first".as_slice()).unwrap(); - let _open = producer.append_next().unwrap(); + let _open = producer.append_group(None).unwrap(); // Activity written while cleanup was idle gets the new supplied time. let later = now.saturating_add(Duration::from_secs(60)); pool.poll(later, &kio::Waiter::noop()); @@ -12745,8 +12766,10 @@ mod test { let pool = cache::Pool::new(cache::Config::default().with_expiry(expiry)); let producer = track_producer_pooled("test", pool.clone()); let now = crate::model::clock::now(); - let groups: Vec<_> = (0..EVICT_SCAN * 3).map(|_| producer.append_next().unwrap()).collect(); - let _open = producer.append_next().unwrap(); + let groups: Vec<_> = (0..EVICT_SCAN * 3) + .map(|_| producer.append_group(None).unwrap()) + .collect(); + let _open = producer.append_group(None).unwrap(); pool.poll(now, &kio::Waiter::noop()); // Keep more than a write scan's worth of leading entries fresh. for group in &groups[..EVICT_SCAN * 2] { @@ -12774,11 +12797,11 @@ mod test { let backlog = 4 * EVICT_SCAN; let mut _open = Vec::new(); for _ in 0..backlog { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); _open.push(group); } - let _open = producer.append_next().unwrap(); // the live edge, always protected + let _open = producer.append_group(None).unwrap(); // the live edge, always protected elapse(&producer, Duration::from_secs(2)); pool.sweep(); @@ -12792,11 +12815,11 @@ mod test { fn pool_expiry_controls_eviction() { // A shorter LRU window on the pool evicts sooner than the default. let producer = track_producer_expiring("test", Duration::from_secs(1)); - let _open = producer.append_next().unwrap(); // seq 0 + let _open = producer.append_group(None).unwrap(); // seq 0 // Past the pool's window but well within cache::DEFAULT_EXPIRY. elapse(&producer, Duration::from_secs(2)); - let _open = producer.append_next().unwrap(); // seq 1 + let _open = producer.append_group(None).unwrap(); // seq 1 // Seq 0 is gone because the pool only keeps idle groups for 1s. let state = producer.state.read(); @@ -12807,8 +12830,8 @@ mod test { #[test] fn small_frame_write_expires_idle_siblings() { let producer = track_producer_expiring("test", Duration::from_secs(1)); - producer.append_next().unwrap().close().unwrap(); // seq 0 - let mut live = producer.append_next().unwrap(); // seq 1 + producer.append_group(None).unwrap().finish().unwrap(); // seq 0 + let mut live = producer.append_group(None).unwrap(); // seq 1 elapse(&producer, Duration::from_secs(2)); live.write_frame(live.key_time(), b"x".as_slice()).unwrap(); @@ -12822,8 +12845,8 @@ mod test { use std::sync::atomic::{AtomicBool, Ordering}; let producer = track_producer_expiring("test", cache::DEFAULT_EXPIRY); - producer.append_next().unwrap().close().unwrap(); - let mut live = producer.append_next().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); + let mut live = producer.append_group(None).unwrap(); let mut consumer = producer.subscribe(replay()); assert_eq!(consumer.assert_group().start, 0); assert_eq!(consumer.assert_group().start, 1); @@ -12853,8 +12876,8 @@ mod test { #[test] fn streaming_frame_write_expires_idle_siblings() { let producer = track_producer_expiring("test", Duration::from_secs(1)); - producer.append_next().unwrap().close().unwrap(); // seq 0 - let live = producer.append_next().unwrap(); // seq 1 + producer.append_group(None).unwrap().finish().unwrap(); // seq 0 + let live = producer.append_group(None).unwrap(); // seq 1 let mut frame = live .create_frame(frame::Info { size: 1, @@ -12951,13 +12974,13 @@ mod test { } let mut subscriber = producer .subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(1)))); - let mut held = producer.append_next().unwrap(); + let mut held = producer.append_group(None).unwrap(); held.write_frame(at, bytes::Bytes::from_static(b"x")).unwrap(); let mut reading = subscriber.assert_group(); assert!(reading.read_frame().now_or_never().unwrap().unwrap().is_some()); // The successor never presents a frame, so media time never bounds the held group. - let _successor = producer.append_next().unwrap(); + let _successor = producer.append_group(None).unwrap(); let woken = Arc::new(std::sync::atomic::AtomicBool::new(false)); let waiter = kio::Waiter::new(futures::task::waker(Arc::new(FlagWake(woken.clone())))); assert!(reading.poll_read_frame(&waiter).is_pending()); @@ -12992,10 +13015,10 @@ mod test { fn the_next_group_in_range_passes_over_skips() { let producer = track_producer("test", Info::default().with_max_age(None)); let subscriber = producer.subscribe(Subscription::default()); - producer.append_group(0).unwrap().close().unwrap(); + producer.append_group(0).unwrap().finish().unwrap(); assert_eq!(subscriber.next_in_range(1), Some(1), "nothing skipped yet"); assert!(!subscriber.is_skipped(1..2)); - producer.append_group(10).unwrap().close().unwrap(); + producer.append_group(10).unwrap().finish().unwrap(); assert_eq!(subscriber.next_in_range(1), Some(10)); assert_eq!(subscriber.next_in_range(11), Some(11)); assert!(subscriber.is_skipped(1..10)); @@ -13025,7 +13048,7 @@ mod test { group .write_frame(Timestamp::ZERO, bytes::Bytes::from_static(b"x")) .unwrap(); - group.finish(40).unwrap(); + group.finish_at(40).unwrap(); let consumer = producer.consume(); elapse(&producer, Duration::from_millis(39)); @@ -13048,7 +13071,7 @@ mod test { elapse(&producer, Duration::ZERO); let mut subscriber = producer .subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(1)))); - let mut held = producer.append_next().unwrap(); + let mut held = producer.append_group(None).unwrap(); held.write_frame(at, bytes::Bytes::from_static(b"x")).unwrap(); let mut reading = subscriber.assert_group(); assert!(reading.read_frame().now_or_never().unwrap().unwrap().is_some()); @@ -13160,7 +13183,7 @@ mod test { assert!(matches!(group.poll_read_frame(&waiter), Poll::Ready(Ok(None)))); } - let failed = producer.append_next().unwrap(); + let failed = producer.append_group(None).unwrap(); assert_eq!(expired(&mut held), [false; 2], "the successor is recorded"); failed.abort(Error::Cancel).unwrap(); let replacement = Duration::from_secs(10); @@ -13232,10 +13255,10 @@ mod test { append_at(&mut producer, 0); let mut open = Vec::new(); for key in 1..=RUN { - let group = producer.append_next().unwrap(); + let group = producer.append_group(None).unwrap(); match key % 2 { 0 => { - group.close().unwrap(); + group.finish().unwrap(); } _ => open.push(group), } @@ -13252,10 +13275,10 @@ mod test { #[test] fn disabled_pool_expiry_never_reclaims() { let producer = track_producer_expiring("test", None); - producer.append_next().unwrap().close().unwrap(); // seq 0 + producer.append_group(None).unwrap().finish().unwrap(); // seq 0 elapse(&producer, Duration::from_secs(3600)); - producer.append_next().unwrap().close().unwrap(); // seq 1 + producer.append_group(None).unwrap().finish().unwrap(); // seq 1 let state = producer.state.read(); assert_eq!(live_groups(&state), 2); @@ -13378,11 +13401,11 @@ mod test { Info::timed().with_max_age(Duration::from_secs(60)), Duration::from_secs(1), ); - producer.append_next().unwrap().close().unwrap(); // seq 0 + producer.append_group(None).unwrap().finish().unwrap(); // seq 0 // Far past the ceiling in wall time, but inside the pool's LRU window. elapse(&producer, Duration::from_secs(2)); - producer.append_next().unwrap().close().unwrap(); // seq 1 + producer.append_group(None).unwrap().finish().unwrap(); // seq 1 let state = producer.state.read(); assert_eq!(live_groups(&state), 2); @@ -13513,22 +13536,22 @@ mod test { /// Append a finished group presenting at `millis`, so the track carries a media /// timeline for the drift budget to measure against. fn append_at(producer: &mut Producer, millis: u64) -> u64 { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(Timestamp::from_millis(millis).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); group.start } /// Append a finished group presenting at its key in milliseconds: a timeline that barely /// advances, since starts strictly increase and can't stop. fn append_frozen(producer: &mut Producer) -> u64 { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from_static(b"x")) .unwrap(); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); group.start } @@ -13554,7 +13577,7 @@ mod test { fn an_answer_past_a_reset_group_skips_the_cache() { let mut producer = track_producer("test", Info::timed()); append_at(&mut producer, 0); - let mut open = producer.append_next().unwrap(); + let mut open = producer.append_group(None).unwrap(); open.write_frame(Timestamp::from_millis(500).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -13589,7 +13612,7 @@ mod test { let mut producer = track_producer("test", None); producer.received(); for key in [0, 4] { - framed(&producer, key, 1).close().unwrap(); + framed(&producer, key, 1).finish().unwrap(); } producer.set_idle(); let mut reader = producer.subscribe( @@ -13599,10 +13622,10 @@ mod test { ); producer.set_live(Some(Position::group(8)), None).unwrap(); for key in [6, 8] { - framed(&producer, key, 1).close().unwrap(); + framed(&producer, key, 1).finish().unwrap(); } assert_eq!(read_now(&mut reader, true), None, "group 5 is still owed"); - framed(&producer, 5, 1).close().unwrap(); + framed(&producer, 5, 1).finish().unwrap(); assert_eq!(read_now(&mut reader, true), Some(Some(5))); assert_eq!(read_now(&mut reader, true), Some(Some(6))); } @@ -13618,12 +13641,12 @@ mod test { let requests = producer.requests(); producer.received(); for key in 0..3 { - framed(&producer, key, 1).close().unwrap(); + framed(&producer, key, 1).finish().unwrap(); } producer.set_idle(); producer.start_at(6).unwrap(); producer.set_live(Some(Position::group(6)), None).unwrap(); - framed(&producer, 6, 1).close().unwrap(); + framed(&producer, 6, 1).finish().unwrap(); if !cached { for key in 0..3 { evict(&producer, key); @@ -13636,7 +13659,7 @@ mod test { ); let waiter = kio::Waiter::noop(); assert_eq!(read_now(&mut reader, false), None); - let Poll::Ready(Ok(fill)) = requests.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = requests.poll_requested_groups(&waiter) else { panic!("cached: {cached}: missing history must be requested"); }; assert_eq!( @@ -13651,7 +13674,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut got = Vec::new(); loop { @@ -13676,12 +13699,12 @@ mod test { let requests = producer.requests(); producer.received(); for key in 0..3 { - framed(&producer, key, 1).close().unwrap(); + framed(&producer, key, 1).finish().unwrap(); } producer.set_idle(); producer.start_at(6).unwrap(); producer.set_live(Some(Position::group(6)), None).unwrap(); - framed(&producer, 6, 1).close().unwrap(); + framed(&producer, 6, 1).finish().unwrap(); for key in 0..3 { evict(&producer, key); } @@ -13691,7 +13714,7 @@ mod test { let mut reader = producer.subscribe(unlimited.clone()); let waiter = kio::Waiter::noop(); assert_eq!(read_now(&mut reader, true), None); - let Poll::Ready(Ok(fill)) = requests.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = requests.poll_requested_groups(&waiter) else { panic!("missing history must be requested"); }; assert_eq!( @@ -13716,7 +13739,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } for key in 3..6 { assert_eq!(read_now(&mut reader, true), Some(Some(key))); @@ -13732,11 +13755,11 @@ mod test { let mut producer = track_producer("test", Info::default().with_max_age(None)); producer.received(); for key in 0..3 { - framed(&producer, key, 1).close().unwrap(); + framed(&producer, key, 1).finish().unwrap(); } producer.set_idle(); producer.set_live(Some(Position::group(6)), None).unwrap(); - framed(&producer, 6, 1).close().unwrap(); + framed(&producer, 6, 1).finish().unwrap(); let delivered = Delivered::default(); let unread = Unread { start: 0, @@ -13760,10 +13783,10 @@ mod test { fn an_evicted_group_below_the_floor_stays_stale() { let mut producer = track_producer("test", Info::default()); producer.received(); - framed(&producer, 0, 1).close().unwrap(); + framed(&producer, 0, 1).finish().unwrap(); producer.set_idle(); producer.set_live(Some(Position::group(6)), None).unwrap(); - framed(&producer, 6, 1).close().unwrap(); + framed(&producer, 6, 1).finish().unwrap(); evict(&producer, 0); let state = producer.state.read(); let edge = state.drift_edge(&Servable::ALL); @@ -13785,7 +13808,7 @@ mod test { let mut producer = track_producer("test", Info::default().with_max_age(None)); let requests = producer.requests(); producer.received(); - framed(&producer, 0, 1).close().unwrap(); + framed(&producer, 0, 1).finish().unwrap(); producer.set_idle(); let subscription = Subscription::default() .with_delay(Delay::default().with_max(None)) @@ -13800,14 +13823,14 @@ mod test { producer.start_at(3).unwrap(); producer.set_live(Some(Position::group(3)), None).unwrap(); - framed(&producer, 3, 1).close().unwrap(); + framed(&producer, 3, 1).finish().unwrap(); assert_eq!(read_now(&mut reader, ordered), Some(Some(0)), "cached history"); // An arrival-order reader may take the live group before its history. if !bounded && !ordered { assert_eq!(read_now(&mut reader, ordered), Some(Some(3))); } assert_eq!(read_now(&mut reader, ordered), None, "the missing run is owed"); - let Poll::Ready(Ok(fill)) = requests.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = requests.poll_requested_groups(&waiter) else { panic!("the missing history was never requested"); }; assert_eq!((fill.start(), fill.end()), (Position::group(1), 3)); @@ -13828,7 +13851,7 @@ mod test { if ordered { assert_eq!(read_now(&mut reader, ordered), Some(Some(3))); } - framed(&producer, 4, 1).close().unwrap(); + framed(&producer, 4, 1).finish().unwrap(); assert_eq!(read_now(&mut reader, ordered), Some(Some(4)), "the feed survives"); } } @@ -13842,7 +13865,7 @@ mod test { fn a_reset_group_is_not_dropped_and_comes_again() { let mut producer = track_producer("test", Info::timed()); append_at(&mut producer, 0); - let mut open = producer.append_next().unwrap(); + let mut open = producer.append_group(None).unwrap(); open.write_frame(Timestamp::from_millis(1000).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -13924,7 +13947,7 @@ mod test { let mut producer = track_producer("test", Info::timed()); append_at(&mut producer, 0); append_at(&mut producer, 1000); - let mut edge = producer.append_next().unwrap(); + let mut edge = producer.append_group(None).unwrap(); edge.write_frame(Timestamp::from_millis(2000).unwrap(), bytes::Bytes::from_static(b"a")) .unwrap(); @@ -14121,7 +14144,7 @@ mod test { group .write_frame(Timestamp::from_millis(millis).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut subscriber = @@ -14134,7 +14157,7 @@ mod test { let mut late = producer.create_group(group::Info { start: 4 }).unwrap(); late.write_frame(Timestamp::from_millis(500).unwrap(), bytes::Bytes::from_static(b"late")) .unwrap(); - late.close().unwrap(); + late.finish().unwrap(); assert_eq!(drain(&mut subscriber), vec![4]); } @@ -14159,7 +14182,7 @@ mod test { fn a_stamped_successor_expires_an_unstamped_group() { let mut producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(None); - let _open = producer.append_next().unwrap(); // seq 0 stalls before its first frame + let _open = producer.append_group(None).unwrap(); // seq 0 stalls before its first frame append_at(&mut producer, 1000); // seq 1 proves the live feed moved on @@ -14173,7 +14196,7 @@ mod test { async fn a_handed_out_group_expires_while_its_first_frame_is_stalled() { let mut producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(None); - let _writer_1 = producer.append_next().unwrap(); + let _writer_1 = producer.append_group(None).unwrap(); let mut stalled = subscriber.recv_group().await.unwrap().expect("stalled group"); let pending = kio::clock::sim::spawn(async move { stalled.read_frame().await }); @@ -14201,7 +14224,7 @@ mod test { let mut producer = track_producer("test", Info::timed()); let mut subscriber = producer .subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_millis(500)))); - let mut old = producer.append_next().unwrap(); + let mut old = producer.append_group(None).unwrap(); old.write_frame(old.key_time(), bytes::Bytes::from_static(b"old")) .unwrap(); @@ -14211,7 +14234,7 @@ mod test { let mut held = subscriber.recv_group().await.unwrap().expect("old group"); assert!(held.read_frame().await.unwrap().is_some()); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); let pending = kio::clock::sim::spawn(async move { held.read_frame().await }); kio::clock::sim::yield_now().await; assert!(!pending.is_finished(), "the newer group has no timestamp yet"); @@ -14253,7 +14276,7 @@ mod test { // Left open, so every read parks instead of ending. let _open: Vec<_> = (0..PARKED) .map(|i| { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame( Timestamp::from_micros(i * FRAME).unwrap(), @@ -14290,7 +14313,7 @@ mod test { // Read `i` can reach its successor's start, `(i + 1) * FRAME`, so an edge at 210ms // puts reads 0..=3 a full 200ms behind and leaves every later one in budget. - let mut next = producer.append_next().unwrap(); + let mut next = producer.append_group(None).unwrap(); next.write_frame( Timestamp::from_micros(210_000).unwrap(), bytes::Bytes::from_static(b"x"), @@ -14328,11 +14351,11 @@ mod test { let mut producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(10)))); - let mut head = producer.append_next().unwrap(); + let mut head = producer.append_group(None).unwrap(); head.write_frame(head.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); append_at(&mut producer, 1000); // the successor bounds the head's reach - let mut between = producer.append_next().unwrap(); + let mut between = producer.append_group(None).unwrap(); append_at(&mut producer, 3000); // the edge let mut held = subscriber @@ -14358,7 +14381,7 @@ mod test { "a first frame below the edge moves neither the reach nor the edge" ); - let mut beyond = producer.append_next().unwrap(); + let mut beyond = producer.append_group(None).unwrap(); beyond .write_frame(Timestamp::from_millis(4000).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -14386,11 +14409,11 @@ mod test { let mut producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(10)))); - let mut head = producer.append_next().unwrap(); + let mut head = producer.append_group(None).unwrap(); head.write_frame(Timestamp::from_millis(0).unwrap(), bytes::Bytes::new()) .unwrap(); append_at(&mut producer, 1000); - let mut edge = producer.append_next().unwrap(); + let mut edge = producer.append_group(None).unwrap(); edge.write_frame(Timestamp::from_millis(2000).unwrap(), bytes::Bytes::new()) .unwrap(); let mut held = subscriber.recv_group().now_or_never().unwrap().unwrap().unwrap(); @@ -14415,8 +14438,8 @@ mod test { "the batch's highest PTS reaches the deadline" ); assert!(matches!(next.as_mut().poll(&mut cx), Poll::Ready(Err(Error::Old)))); - head.close().unwrap(); - edge.close().unwrap(); + head.finish().unwrap(); + edge.finish().unwrap(); } #[test] @@ -14425,11 +14448,11 @@ mod test { let mut producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(10)))); - let mut old = producer.append_next().unwrap(); + let mut old = producer.append_group(None).unwrap(); old.write_frame(Timestamp::from_millis(0).unwrap(), bytes::Bytes::new()) .unwrap(); append_at(&mut producer, 1000); - let mut edge = producer.append_next().unwrap(); + let mut edge = producer.append_group(None).unwrap(); edge.start_at(2).unwrap(); edge.write_frame(Timestamp::from_millis(2000).unwrap(), bytes::Bytes::new()) .unwrap(); @@ -14454,9 +14477,9 @@ mod test { "the adopted prefix reaches the drift deadline" ); assert!(matches!(next.as_mut().poll(&mut cx), Poll::Ready(Err(Error::Old)))); - old.close().unwrap(); - edge.close().unwrap(); - prefix.close().unwrap(); + old.finish().unwrap(); + edge.finish().unwrap(); + prefix.finish().unwrap(); } /// An aborted edge hands the edge to a group between it and the successor, and neither @@ -14467,15 +14490,15 @@ mod test { let mut producer = track_producer("test", crate::track::Info::timed()); let mut subscriber = producer.subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(5)))); - let mut head = producer.append_next().unwrap(); + let mut head = producer.append_group(None).unwrap(); head.write_frame(head.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); append_at(&mut producer, 1000); // the successor bounds the head's reach - let mut between = producer.append_next().unwrap(); - let mut edge = producer.append_next().unwrap(); + let mut between = producer.append_group(None).unwrap(); + let mut edge = producer.append_group(None).unwrap(); edge.write_frame(Timestamp::from_millis(2000).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - let edge = edge.close().unwrap(); + let edge = edge.finish().unwrap(); let mut held = subscriber .recv_group() @@ -14518,11 +14541,11 @@ mod test { let mut producer = track_producer("test", Info::timed()); let mut subscriber = producer .subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_millis(500)))); - let mut head = producer.append_next().unwrap(); + let mut head = producer.append_group(None).unwrap(); head.write_frame(head.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); - let successor = producer.append_next().unwrap(); - let mut replacement = producer.append_next().unwrap(); + let successor = producer.append_group(None).unwrap(); + let mut replacement = producer.append_group(None).unwrap(); append_at(&mut producer, 20_000); // the edge let mut held = subscriber @@ -14574,21 +14597,21 @@ mod test { let mut producer = track_producer("test", crate::track::Info::timed()); let mut subscriber = producer.subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(5)))); - let mut head = producer.append_next().unwrap(); + let mut head = producer.append_group(None).unwrap(); head.write_frame(head.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); append_at(&mut producer, 1000); // the successor bounds the head's reach // Starts below the edge but presents past the deadline. - let mut long = producer.append_next().unwrap(); + let mut long = producer.append_group(None).unwrap(); for millis in [1500, 10_000] { long.write_frame(Timestamp::from_millis(millis).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); } - long.close().unwrap(); - let mut edge = producer.append_next().unwrap(); + long.finish().unwrap(); + let mut edge = producer.append_group(None).unwrap(); edge.write_frame(Timestamp::from_millis(2000).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - let edge = edge.close().unwrap(); + let edge = edge.finish().unwrap(); let mut held = subscriber .recv_group() @@ -14623,7 +14646,7 @@ mod test { let mut producer = track_producer("test", Info::timed()); let mut subscriber = producer .subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_millis(500)))); - let mut head = producer.append_next().unwrap(); + let mut head = producer.append_group(None).unwrap(); head.write_frame(head.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); append_at(&mut producer, 1000); // the successor bounds the head's reach @@ -14670,7 +14693,7 @@ mod test { let mut producer = track_producer("test", crate::track::Info::timed()); let mut subscriber = producer.subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(60)))); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); let mut received: Vec<_> = (0..2) .map(|key| producer.create_group(group::Info { start: key }).unwrap()) .collect(); @@ -14729,7 +14752,7 @@ mod test { let mut producer = track_producer("test", None); 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(); + producer.finish_at(Position::group(1)).unwrap(); let group = producer.create_group(group::Info { start: 0 }).unwrap(); let mut reading = subscriber.assert_group(); assert_eq!(reading.start, 0); @@ -14740,7 +14763,7 @@ mod test { match abort { true => group.abort(Error::Cancel).unwrap(), false => { - group.close().unwrap(); + group.finish().unwrap(); } } kio::clock::timeout(Duration::from_secs(1), next) @@ -14780,7 +14803,7 @@ mod test { group.write_frame(timestamp, bytes::Bytes::from_static(b"x")).unwrap(); }; - let mut open = producer.append_next().unwrap(); + let mut open = producer.append_group(None).unwrap(); write(&mut open, gop(0)[0]); write(&mut open, gop(0)[1]); let mut reading = subscriber.recv_group().await.unwrap().expect("the live group"); @@ -14805,11 +14828,11 @@ mod test { // The next keyframe opens its group. The verdict is taken here, in the // window before the previous group's FIN arrives. - let mut opened = producer.append_next().unwrap(); + let mut opened = producer.append_group(None).unwrap(); write(&mut opened, gop(n)[0]); let verdict = futures::poll!(end.as_mut()); - open.close().unwrap(); + open.finish().unwrap(); let res = match verdict { Poll::Ready(res) => res, Poll::Pending => end.await, @@ -14839,13 +14862,13 @@ mod test { let mut subscriber = producer .subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_millis(80)))); for ms in [0, 100] { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(Timestamp::from_millis(ms).unwrap(), bytes::Bytes::new()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } - let mut edge = producer.append_next().unwrap(); + let mut edge = producer.append_group(None).unwrap(); for ms in [150, 200] { edge.write_frame(Timestamp::from_millis(ms).unwrap(), bytes::Bytes::new()) .unwrap(); @@ -14854,7 +14877,7 @@ mod test { edge.write_frame(Timestamp::from_millis(160).unwrap(), bytes::Bytes::new()) .unwrap(); } - edge.close().unwrap(); + edge.finish().unwrap(); // Group 0 can reach 100ms: 100ms behind the 200ms edge, past its 80ms budget. // Group 1 can reach 150ms and stays within the same budget. assert_eq!( @@ -14881,7 +14904,7 @@ mod test { let mut subscriber = producer.subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_secs(1)))); - let mut open = producer.append_next().unwrap(); + let mut open = producer.append_group(None).unwrap(); open.write_frame(open.key_time(), bytes::Bytes::from_static(b"key")) .unwrap(); open.write_frame( @@ -14898,7 +14921,7 @@ mod test { assert!(futures::poll!(end.as_mut()).is_pending(), "parked at 1900ms"); // The next GOP opens. The reader is 100ms behind it, inside its 1s budget. - let mut next = producer.append_next().unwrap(); + let mut next = producer.append_group(None).unwrap(); next.write_frame(Timestamp::from_millis(2000).unwrap(), bytes::Bytes::from_static(b"key")) .unwrap(); assert!( @@ -14926,7 +14949,7 @@ mod test { async fn an_expired_group_stays_old_when_probed_again() { let mut producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(None); - let mut open = producer.append_next().unwrap(); + let mut open = producer.append_group(None).unwrap(); open.write_frame(open.key_time(), bytes::Bytes::from_static(b"a")) .unwrap(); @@ -14969,7 +14992,7 @@ mod test { async fn a_handed_out_partial_frame_expires_while_its_payload_is_stalled() { let mut producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(None); - let source = producer.append_next().unwrap(); + let source = producer.append_group(None).unwrap(); let mut writing = source .create_frame(frame::Info { size: 6, @@ -15090,12 +15113,12 @@ mod test { let mut producer = track_producer("test", Info::timed()); // Group 0 spans 0..2000ms; group 1 starts at 2000ms, where group 0 ends. - let mut long = producer.append_next().unwrap(); + let mut long = producer.append_group(None).unwrap(); for ms in [0u64, 500, 1000, 1500, 2000] { long.write_frame(Timestamp::from_millis(ms).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); } - long.close().unwrap(); + long.finish().unwrap(); append_at(&mut producer, 2000); // A budget far shorter than the group's own span still keeps it. @@ -15114,12 +15137,12 @@ mod test { fn a_long_group_is_stale_once_its_successor_falls_behind() { let mut producer = track_producer("test", Info::timed()); - let mut long = producer.append_next().unwrap(); + let mut long = producer.append_group(None).unwrap(); for ms in [0u64, 500, 1000] { long.write_frame(Timestamp::from_millis(ms).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); } - long.close().unwrap(); + long.finish().unwrap(); // Group 0 reaches at most 3s (where group 1 starts), a full second behind the 4s // edge and so past the budget. Group 1 reaches the edge itself and is kept. append_at(&mut producer, 3000); @@ -15142,7 +15165,7 @@ mod test { .subscribe(Subscription::default().with_delay(Delay::default().with_max(Duration::from_millis(500)))); append_at(&mut producer, 0); // seq 0 - let _writer_1 = producer.append_next().unwrap(); // seq 1 stalls before its first frame + let _writer_1 = producer.append_group(None).unwrap(); // seq 1 stalls before its first frame append_at(&mut producer, 10_000); // seq 2 append_at(&mut producer, 11_000); // seq 3 @@ -15178,11 +15201,11 @@ mod test { /// A group of untimed frames. #[cfg(feature = "async")] fn append_untimed(producer: &mut Producer) -> u64 { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), bytes::Bytes::from_static(b"x")) .unwrap(); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); group.start } @@ -15254,7 +15277,7 @@ mod test { producer.write_frame(Timestamp::ZERO, bytes::Bytes::from_static(b"x")), Err(Error::TimestampMismatch) )); - assert_eq!(producer.append_next().unwrap().start, 0); + assert_eq!(producer.append_group(None).unwrap().start, 0); } /// Every group the ordered cursor can read right now, in key order. @@ -15315,7 +15338,7 @@ mod test { fn next_group_judges_past_a_frameless_successor() { let mut producer = track_producer("test", Info::timed()); append_at(&mut producer, 0); // seq 0 - let _writer_1 = producer.append_next().unwrap(); // seq 1 stalls before its first frame + let _writer_1 = producer.append_group(None).unwrap(); // seq 1 stalls before its first frame append_at(&mut producer, 10_000); // seq 2 append_at(&mut producer, 11_000); // seq 3 @@ -15386,7 +15409,7 @@ mod test { successor .write_frame(Timestamp::from_millis(1000).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - successor.close().unwrap(); + successor.finish().unwrap(); append_at(&mut producer, 2000); let options = group::Fetch::default().with_max_delay(Duration::ZERO); @@ -15400,7 +15423,7 @@ mod test { #[cfg(feature = "async")] async fn fetched_group_keeps_its_budget_while_reading() { let mut producer = track_producer("test", Info::timed()); - let mut old = producer.append_next().unwrap(); + let mut old = producer.append_group(None).unwrap(); old.write_frame(old.key_time(), bytes::Bytes::from_static(b"first")) .unwrap(); @@ -15442,7 +15465,7 @@ mod test { producer .create_group(group::Info { start: 3 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(subscriber.assert_group().start, 3); assert!(subscriber.poll_start(&waiter).is_pending()); @@ -15477,7 +15500,7 @@ mod test { fetched .write_frame(crate::Timestamp::unscaled(fetched.start), b"2-0".as_ref()) .unwrap(); - fetched.close().unwrap(); + fetched.finish().unwrap(); let Poll::Ready(Ok(mut group)) = kio::Task::poll(&mut *pending, &waiter) else { panic!("fetched group should be cached"); }; @@ -15524,7 +15547,7 @@ mod test { bytes::Bytes::from_static(b"fetched"), ) .unwrap(); - fetched.close().unwrap(); + fetched.finish().unwrap(); pending.await.unwrap(); let mut groups = producer.subscribe(None); @@ -15617,12 +15640,12 @@ mod test { .write_frame(Timestamp::from_millis(millis).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); } - straggler.close().unwrap(); + straggler.finish().unwrap(); let mut next = producer.create_group(1u64.into()).unwrap(); next.write_frame(next.key_time(), bytes::Bytes::from_static(b"x")) .unwrap(); - next.close().unwrap(); + next.finish().unwrap(); let mut subscriber = producer.subscribe(replay()); assert_eq!(drain(&mut subscriber), vec![0, 1]); @@ -15663,7 +15686,7 @@ mod test { group .write_frame(Timestamp::from_millis(millis).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } // With no budget, the newest group the ranges cover is the edge. assert_eq!(drain(&mut producer.subscribe(ranges())), vec![9]); @@ -15671,7 +15694,7 @@ mod test { let mut ten = producer.create_group(group::Info { start: 10 }).unwrap(); ten.write_frame(Timestamp::from_millis(10_000).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - ten.close().unwrap(); + ten.finish().unwrap(); assert_eq!(drain(&mut producer.subscribe(ranges())), vec![10]); } @@ -15693,12 +15716,12 @@ mod test { // The run's own group 10 is held, so its time start names it. let mut ten = producer.create_group(group::Info { start: 10 }).unwrap(); ten.write_frame(at(10_000), bytes::Bytes::from_static(b"x")).unwrap(); - ten.close().unwrap(); + ten.finish().unwrap(); subscriber.update(budget.with_range(10..20)).unwrap(); for (key, millis) in [(1, 1000), (19, 19_000)] { let mut group = producer.create_group(group::Info { start: key }).unwrap(); group.write_frame(at(millis), bytes::Bytes::from_static(b"x")).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let pending = kio::clock::sim::spawn(async move { held.read_frame().await }); @@ -15761,7 +15784,7 @@ mod test { for order in ["ranges first", "cap first", "cap between"] { let producer = track_producer("test", Info::timed()); // Group 10 is held, so the time start names it. - producer.append_group(10).unwrap().close().unwrap(); + producer.append_group(10).unwrap().finish().unwrap(); let mut subscriber = producer.subscribe(Subscription::default()); let control = subscriber.control(); match order { @@ -16018,12 +16041,12 @@ mod test { // The run's own group 10 is held, so its time start names it. let mut ten = producer.create_group(group::Info { start: 10 }).unwrap(); ten.write_frame(at(10_000), bytes::Bytes::from_static(b"x")).unwrap(); - ten.close().unwrap(); + ten.finish().unwrap(); subscriber.control().update(budget.with_range(10..20)).unwrap(); for (key, millis) in [(1, 1000), (19, 19_000)] { let mut group = producer.create_group(group::Info { start: key }).unwrap(); group.write_frame(at(millis), bytes::Bytes::from_static(b"x")).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let pending = kio::clock::sim::spawn(async move { held.read_frame().await }); @@ -16195,7 +16218,7 @@ mod test { elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); // Append seq 6 (becomes new max_key). - let _open = producer.append_next().unwrap(); // seq 6 + let _open = producer.append_group(None).unwrap(); // seq 6 // Seq 3, 4, 5 are all expired. Seq 5 was the old max_key but now 6 is. // All old groups are evicted. @@ -16218,7 +16241,7 @@ mod test { producer .create_group(group::Info { start: 5 }) .unwrap() - .close() + .finish() .unwrap(); elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); @@ -16227,7 +16250,7 @@ mod test { producer .create_group(group::Info { start: 3 }) .unwrap() - .close() + .finish() .unwrap(); // Seq 5 is max_key (protected). Seq 3 is not expired (just created). @@ -16245,7 +16268,7 @@ mod test { producer .create_group(group::Info { start: 2 }) .unwrap() - .close() + .finish() .unwrap(); // Seq 5 is the live edge (protected) and still resolves at the front of @@ -16272,8 +16295,8 @@ mod test { #[cfg(feature = "async")] fn abort_drops_open_groups() { let producer = track_producer("test", Info::timed()); - let _writer_1 = producer.append_next().unwrap(); - let _writer_2 = producer.append_next().unwrap(); + let _writer_1 = producer.append_group(None).unwrap(); + let _writer_2 = producer.append_group(None).unwrap(); let mut consumer = producer.subscribe(None); assert_eq!(live_groups(&producer.state.read()), 2); @@ -16294,7 +16317,7 @@ mod test { fn drop_unfinished_clears_cached_groups() { let producer = track_producer("test", Info::timed()); let writer = producer.clone(); - let _open = writer.append_next().unwrap(); + let _open = writer.append_group(None).unwrap(); // A stale consumer keeps the channel (and thus the cache) alive. let mut consumer = producer.subscribe(None); @@ -16315,7 +16338,7 @@ mod test { fn abort_ends_a_pulled_open_group() { let producer = track_producer("test", Info::timed()); let mut consumer = producer.subscribe(None); - let mut writer = producer.append_next().unwrap(); + let mut writer = producer.append_group(None).unwrap(); writer .write_frame(writer.key_time(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -16336,7 +16359,7 @@ mod test { fn abort_unwanted_waits_for_a_pulled_open_group() { let producer = track_producer("test", Info::timed()); let mut consumer = producer.subscribe(None); - let mut writer = producer.append_next().unwrap(); + let mut writer = producer.append_group(None).unwrap(); writer .write_frame(writer.key_time(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -16360,7 +16383,7 @@ mod test { fn drop_unfinished_ends_a_pulled_open_group() { let producer = track_producer("test", Info::timed()); let mut consumer = producer.subscribe(None); - let mut writer = producer.append_next().unwrap(); + let mut writer = producer.append_group(None).unwrap(); writer .write_frame(writer.key_time(), bytes::Bytes::from_static(b"x")) .unwrap(); @@ -16410,8 +16433,8 @@ mod test { let producer = track_producer("test", Info::timed()); let keep = producer.clone(); let writer = producer.clone(); - let group = writer.append_next().unwrap(); - group.close().unwrap(); + let group = writer.append_group(None).unwrap(); + group.finish().unwrap(); let _consumer = producer.subscribe(None); writer.abort(Error::Cancel).unwrap(); drop(keep); @@ -16424,7 +16447,7 @@ mod test { let warns = count_drop_warnings("track::Producer dropped without finish", || { let producer = track_producer("test", Info::timed()); let writer = producer.clone(); - let _open = writer.append_next().unwrap(); + let _open = writer.append_group(None).unwrap(); let _consumer = producer.subscribe(None); drop(writer); drop(producer); @@ -16436,7 +16459,7 @@ mod test { #[cfg(feature = "async")] fn drop_finished_keeps_cached_groups() { let producer = track_producer("test", Info::timed()); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); let producer = producer.finish().unwrap(); let mut consumer = producer.subscribe(None); @@ -16455,8 +16478,8 @@ mod test { #[cfg(feature = "async")] fn drop_short_of_the_boundary_ends_cleanly() { let mut producer = track_producer("test", Info::timed()); - producer.append_next().unwrap().close().unwrap(); - producer.finish_at(Position::group(3), None).unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); + producer.finish_at(Position::group(3)).unwrap(); let mut consumer = producer.subscribe(None); assert_eq!(consumer.assert_group().start, 0); @@ -16482,14 +16505,14 @@ mod test { producer .create_group(group::Info { start: 0 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 2 }) .unwrap() - .close() + .finish() .unwrap(); - producer.finish_at(Position::group(4), None).unwrap(); + producer.finish_at(Position::group(4)).unwrap(); let mut ordered = producer.subscribe(replay()).ordered(); drop(producer); @@ -16547,17 +16570,17 @@ mod test { // neither finish again nor append. assert!(producer.clone().finish().is_ok()); assert!(producer.clone().finish().is_err()); - assert!(producer.append_next().is_err()); + assert!(producer.append_group(None).is_err()); } #[test] fn finish_after_groups() { let producer = track_producer("test", Info::timed()); - let _open = producer.append_next().unwrap(); + let _open = producer.append_group(None).unwrap(); assert!(producer.clone().finish().is_ok()); assert!(producer.clone().finish().is_err()); - assert!(producer.append_next().is_err()); + assert!(producer.append_group(None).is_err()); } /// The handle `finish` returns still fills an older group below the end, refuses one at or @@ -16570,7 +16593,7 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); let finished = producer.finish().unwrap(); assert!(matches!( @@ -16580,7 +16603,7 @@ mod test { let mut late = finished.create_group(group::Info { start: 0 }).unwrap(); late.write_frame(late.key_time(), &b"late"[..]).unwrap(); - let late = late.close().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.start, 0); @@ -16598,16 +16621,16 @@ mod test { // The boundary is exclusive, so it must be strictly above the highest produced // group. 5 or below would orphan groups that already exist. - assert!(producer.finish_at(Position::group(4), None).is_err()); - assert!(producer.finish_at(Position::group(5), None).is_err()); - assert!(producer.finish_at(Position::group(6), None).is_ok()); + assert!(producer.finish_at(Position::group(4)).is_err()); + assert!(producer.finish_at(Position::group(5)).is_err()); + assert!(producer.finish_at(Position::group(6)).is_ok()); assert_eq!(producer.finished(), Some(Position::group(6))); // Repeating the end is a no-op, moving it is rejected, and no group at or above the // boundary can be created. - assert!(producer.finish_at(Position::group(6), None).is_ok()); - assert!(producer.finish_at(Position::group(7), None).is_err()); + assert!(producer.finish_at(Position::group(6)).is_ok()); + assert!(producer.finish_at(Position::group(7)).is_err()); assert!(producer.create_group(group::Info { start: 4 }).is_ok()); assert!(producer.create_group(group::Info { start: 6 }).is_err()); } @@ -16617,12 +16640,12 @@ mod test { let pool = cache::Pool::new(cache::Config::default().with_expiry(Duration::from_secs(1))); let mut producer = track_producer_pooled("test", pool.clone()); let end = Position { group: 5, frame: 5 }; - producer.finish_at(end, None).unwrap(); + producer.finish_at(end).unwrap(); let mut group = producer.create_group(group::Info { start: 5 }).unwrap(); for _ in 0..5 { group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let consumer = producer.consume(); drop(producer); // Date the last activity before advancing the cache clock past expiry. @@ -16642,12 +16665,12 @@ mod test { fn a_wire_end_repeats_or_refines_but_never_moves() { let mut producer = track_producer("test", Info::timed()); // A FETCH_OK names only the boundary; END_OF_TRACK may then name the frame before it. - producer.finish_at(Position::group(6), None).unwrap(); - producer.finish_at(Position { group: 5, frame: 5 }, None).unwrap(); - producer.finish_at(Position { group: 5, frame: 5 }, None).unwrap(); + producer.finish_at(Position::group(6)).unwrap(); + producer.finish_at(Position { group: 5, frame: 5 }).unwrap(); + producer.finish_at(Position { group: 5, frame: 5 }).unwrap(); assert_eq!(producer.finished(), Some(Position { group: 5, frame: 5 })); for moved in [Position { group: 5, frame: 4 }, Position::group(6), Position::group(5)] { - assert!(matches!(producer.finish_at(moved, None), Err(Error::ProtocolViolation))); + assert!(matches!(producer.finish_at(moved), Err(Error::ProtocolViolation))); } } @@ -16661,11 +16684,11 @@ mod test { group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); } assert!(matches!( - producer.finish_at(Position { group: 5, frame: 5 }, None), + producer.finish_at(Position { group: 5, frame: 5 }), Err(Error::ProtocolViolation) )); assert_eq!(producer.finished(), None, "a refused end declares nothing"); - producer.finish_at(Position { group: 5, frame: 6 }, None).unwrap(); + producer.finish_at(Position { group: 5, frame: 6 }).unwrap(); } /// A mid-group end caps its group, whether the group exists yet or not. @@ -16675,12 +16698,12 @@ mod test { let mut producer = track_producer("test", Info::timed()); let end = Position { group: 5, frame: 2 }; if early { - producer.finish_at(end, None).unwrap(); + producer.finish_at(end).unwrap(); } let mut group = producer.create_group(group::Info { start: 5 }).unwrap(); group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); if !early { - producer.finish_at(end, None).unwrap(); + producer.finish_at(end).unwrap(); } group.write_frame(group.key_time(), b"x".as_slice()).unwrap(); assert!(matches!( @@ -16715,7 +16738,7 @@ mod test { let _open = producer.create_group(group::Info { start: 5 }).unwrap(); assert_eq!(producer.finished(), None, "a group does not declare an end"); - producer.finish_at(Position::group(9), None).unwrap(); + producer.finish_at(Position::group(9)).unwrap(); assert_eq!(producer.finished(), Some(Position::group(9))); // finish() would try to declare a second boundary, so callers check first. @@ -16737,11 +16760,11 @@ mod test { producer .create_group(group::Info { start: 5 }) .unwrap() - .close() + .finish() .unwrap(); // Learn the track ends at group 6 (exclusive 7) while the live edge is still 5. - producer.finish_at(Position::group(7), None).unwrap(); + producer.finish_at(Position::group(7)).unwrap(); let mut consumer = producer.subscribe(None); assert_eq!(consumer.assert_group().start, 5); @@ -16763,7 +16786,7 @@ mod test { producer .create_group(group::Info { start: 6 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(consumer.assert_group().start, 6); let done = consumer @@ -16785,14 +16808,14 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } - producer.finish_at(Position::group(2), Some(Error::App(7))).unwrap(); + producer.end_at(Position::group(2), Some(Error::App(7))).unwrap(); // A repeat must carry the same error. - producer.finish_at(Position::group(2), Some(Error::App(7))).unwrap(); + producer.end_at(Position::group(2), Some(Error::App(7))).unwrap(); assert!(matches!( - producer.finish_at(Position::group(2), None), + producer.finish_at(Position::group(2)), Err(Error::ProtocolViolation) )); @@ -16832,7 +16855,7 @@ mod test { let mut producer = track_producer("test", Info::timed()); let mut arrival = producer.subscribe(None); let mut ordered = producer.subscribe(None).ordered(); - producer.finish_at(Position::group(3), None).unwrap(); + producer.finish_at(Position::group(3)).unwrap(); let _open = producer.create_group(group::Info { start: 2 }).unwrap(); // Missing lower groups do not hold either reader for the wire's grace. @@ -16865,7 +16888,7 @@ mod test { let mut arrival = producer.subscribe(replay()); // The wire declares where the feed starts. producer.start_at(0).unwrap(); - producer.finish_at(Position::group(3), None).unwrap(); + producer.finish_at(Position::group(3)).unwrap(); let _high = producer.create_group(group::Info { start: 2 }).unwrap(); assert_eq!(arrival.assert_group().start, 2); assert!(arrival.recv_group().now_or_never().is_none(), "held at the hole"); @@ -16883,7 +16906,7 @@ mod test { producer.received(); let mut arrival = producer.subscribe(replay()); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); let _high = producer.create_group(group::Info { start: 1 }).unwrap(); assert_eq!(arrival.assert_group().start, 1); assert!(arrival.recv_group().now_or_never().is_none()); @@ -16896,7 +16919,7 @@ mod test { producer.received(); let mut arrival = producer.subscribe(replay()); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); let _high = producer.create_group(group::Info { start: 1 }).unwrap(); assert_eq!(arrival.assert_group().start, 1); drop(producer); @@ -16920,14 +16943,14 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 1); if arrived_late { // The end comes later than the arrival, so its gap runs from the end. elapse(&producer, grace / 2); } - producer.finish_at(Position::group(end), None).unwrap(); + producer.finish_at(Position::group(end)).unwrap(); let woken = Arc::new(std::sync::atomic::AtomicBool::new(false)); let waiter = kio::Waiter::new(futures::task::waker(Arc::new(FlagWake(woken.clone())))); @@ -16967,11 +16990,11 @@ mod test { producer.received(); let mut arrival = producer.subscribe(replay().with_delay(Delay::default().with_max(None))); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); producer .create_group(group::Info { start: arrived }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(arrival.assert_group().start, arrived); @@ -16984,7 +17007,7 @@ mod test { producer .create_group(group::Info { start: missing }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(arrival.assert_group().start, missing); assert!(arrival.recv_group().now_or_never().unwrap().unwrap().is_none()); @@ -17001,13 +17024,13 @@ mod test { let grace = replay().budget(); let mut arrival = producer.subscribe(replay()); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(5), None).unwrap(); + producer.finish_at(Position::group(5)).unwrap(); for key in 0..3 { elapse(&producer, grace / 2); producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(arrival.assert_group().start, key); } @@ -17026,7 +17049,7 @@ mod test { producer.received(); let grace = replay().budget(); let mut arrival = producer.subscribe(replay()); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); elapse(&producer, grace - Duration::from_millis(1)); producer.start_at(0).unwrap(); elapse(&producer, Duration::from_millis(1)); @@ -17043,11 +17066,11 @@ mod test { let mut producer = track_producer("test", None); let mut arrival = producer.subscribe(replay()); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 1); assert!(arrival.recv_group().now_or_never().unwrap().unwrap().is_none()); @@ -17061,11 +17084,11 @@ mod test { producer.received(); let mut arrival = producer.subscribe(replay()); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(3), None).unwrap(); + producer.finish_at(Position::group(3)).unwrap(); producer .create_group(group::Info { start: 2 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 2); assert!(arrival.recv_group().now_or_never().is_none(), "held at the hole"); @@ -17083,7 +17106,7 @@ mod test { producer.received(); producer.request_start(None).unwrap(); let mut arrival = producer.subscribe(replay()); - producer.finish_at(Position::group(0), None).unwrap(); + producer.finish_at(Position::group(0)).unwrap(); assert!(arrival.recv_group().now_or_never().unwrap().unwrap().is_none()); // Nor does one whose groups below it all arrived or were dropped. @@ -17094,11 +17117,11 @@ mod test { producer .create_group(group::Info { start: 0 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 0); producer.drop_groups(1..2, StreamError::NotFound); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); assert!(arrival.recv_group().now_or_never().unwrap().unwrap().is_none()); // A hole is still owed until the grace passes. @@ -17109,10 +17132,10 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(arrival.assert_group().start, 1); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); assert!(arrival.recv_group().now_or_never().is_none(), "group 0 is owed"); elapse(&producer, replay().budget()); assert!(arrival.recv_group().now_or_never().unwrap().unwrap().is_none()); @@ -17129,13 +17152,13 @@ mod test { let consumer = producer.consume(); let mut arrival = producer.subscribe(None); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); let _high = producer.create_group(group::Info { start: 1 }).unwrap(); assert_eq!(arrival.assert_group().start, 1); let _pending = consumer.fetch_group(0, None); let req = dynamic.requested_fill_group().now_or_never().unwrap().unwrap(); - req.accept(None).unwrap().close().unwrap(); + req.accept(None).unwrap().finish().unwrap(); assert!( arrival.recv_group().now_or_never().is_none(), "the live group 0 is still owed" @@ -17151,9 +17174,9 @@ mod test { producer.received(); let mut arrival = producer.subscribe(None); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); let high = producer.create_group(group::Info { start: 1 }).unwrap(); - high.close().unwrap(); + high.finish().unwrap(); assert_eq!(arrival.assert_group().start, 1); assert!(arrival.recv_group().now_or_never().is_none(), "held at the hole"); @@ -17173,12 +17196,12 @@ mod test { producer.received(); let mut arrival = producer.subscribe(replay()); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); for key in [1, 0] { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } producer.clone().abort(Error::Dropped).unwrap(); @@ -17197,12 +17220,12 @@ mod test { producer.received(); let mut arrival = producer.subscribe(None); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(3), None).unwrap(); + producer.finish_at(Position::group(3)).unwrap(); for key in [0, 2] { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(arrival.assert_group().start, key); } @@ -17224,12 +17247,12 @@ mod test { producer.received(); let mut arrival = producer.subscribe(replay()); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(3), None).unwrap(); + producer.finish_at(Position::group(3)).unwrap(); for key in [0, 1] { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(arrival.assert_group().start, key); } @@ -17237,7 +17260,7 @@ mod test { producer .create_group(group::Info { start: 2 }) .unwrap() - .close() + .finish() .unwrap(); assert!(!producer.state.read().lookup.contains_key(&0), "group 0 was evicted"); assert_eq!(arrival.assert_group().start, 2); @@ -17258,13 +17281,10 @@ mod test { assert_eq!(arrival.assert_group().start, 2); assert!(arrival.recv_group().now_or_never().is_none()); - producer.finish_at(Position::group(3), None).unwrap(); + producer.finish_at(Position::group(3)).unwrap(); assert!(arrival.recv_group().now_or_never().is_none(), "held at the hole"); assert!( - matches!( - producer.finish_at(Position::group(2), None), - Err(Error::ProtocolViolation) - ), + matches!(producer.finish_at(Position::group(2)), Err(Error::ProtocolViolation)), "a second end is refused" ); assert_eq!(producer.finished(), Some(Position::group(3)), "the first end stands"); @@ -17286,9 +17306,9 @@ mod test { let mut consumer = producer.subscribe(replay()); let head = producer.create_group(group::Info { start: 0 }).unwrap(); - head.close().unwrap(); + head.finish().unwrap(); let _tail = producer.create_group(group::Info { start: 1 }).unwrap(); - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); assert_eq!(consumer.assert_group().start, 0); producer.abort(Error::Timeout).unwrap(); @@ -17302,8 +17322,8 @@ mod test { fn session_close_is_not_completion_and_keeps_the_resume_position() { let producer = track_producer("local", Info::timed()); let consumer = producer.consume(); - producer.append_next().unwrap().close().unwrap(); - let mut group = producer.append_next().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from_static(b"a")) .unwrap(); @@ -17328,12 +17348,12 @@ mod test { let waiter = kio::Waiter::noop(); let mut producer = track_producer("test", Info::timed()); let demand = producer.demand(); - producer.append_next().unwrap().close().unwrap(); - producer.finish_at(Position::group(2), None).unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); + producer.finish_at(Position::group(2)).unwrap(); assert!(producer.poll_closed(&waiter).is_pending(), "group 1 is still to come"); assert!(demand.closed().now_or_never().is_none()); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); assert!(matches!(producer.poll_closed(&waiter), Poll::Ready(Ok(())))); assert!(matches!(demand.closed().now_or_never(), Some(Ok(())))); assert!( @@ -17354,18 +17374,18 @@ mod test { use std::sync::atomic::{AtomicBool, Ordering}; let mut producer = track_producer("test", Info::timed()); - let open = producer.append_next().unwrap(); - producer.finish_at(Position::group(1), None).unwrap(); + let open = producer.append_group(None).unwrap(); + producer.finish_at(Position::group(1)).unwrap(); let woken = Arc::new(AtomicBool::new(false)); let waiter = kio::Waiter::new(futures::task::waker(Arc::new(FlagWake(woken.clone())))); assert!(producer.poll_closed(&waiter).is_pending(), "group 0 may still abort"); - open.close().unwrap(); + open.finish().unwrap(); assert!(woken.load(Ordering::SeqCst), "the group finishing wakes the wait"); assert!(matches!(producer.poll_closed(&waiter), Poll::Ready(Ok(())))); let mut cut = track_producer("cut", Info::timed()); - let _open = cut.append_next().unwrap(); - cut.finish_at(Position::group(1), None).unwrap(); + let _open = cut.append_group(None).unwrap(); + cut.finish_at(Position::group(1)).unwrap(); assert!(cut.poll_closed(&kio::Waiter::noop()).is_pending()); cut.clone().abort(Error::Cancel).unwrap(); assert!(matches!( @@ -17383,12 +17403,12 @@ mod test { producer.received(); let _short = producer.subscribe(None); producer.start_at(0).unwrap(); - producer.finish_at(Position::group(3), None).unwrap(); + producer.finish_at(Position::group(3)).unwrap(); for key in [0, 2] { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } assert!(producer.poll_closed(&waiter).is_pending(), "held at the hole"); @@ -17413,9 +17433,9 @@ mod test { producer .create_group(group::Info { start: 5 }) .unwrap() - .close() + .finish() .unwrap(); - producer.finish_at(Position::group(6), None).unwrap(); + producer.finish_at(Position::group(6)).unwrap(); assert!(matches!(producer.poll_closed(&waiter), Poll::Ready(Ok(())))); let _late = producer.create_group(group::Info { start: 4 }).unwrap(); @@ -17454,7 +17474,7 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } let _open = producer.create_group(group::Info { start: 2 }).unwrap(); @@ -17483,7 +17503,7 @@ mod test { producer .create_group(group::Info { start: 0 }) .unwrap() - .close() + .finish() .unwrap(); drop(producer); @@ -17499,15 +17519,15 @@ mod test { let pool = cache::Pool::new(cache::Config::default().with_expiry(Duration::from_secs(1))); let live = track_producer_pooled("live", pool.clone()); - live.append_next().unwrap().close().unwrap(); + live.append_group(None).unwrap().finish().unwrap(); let aborted = track_producer_pooled("aborted", pool.clone()); - aborted.append_next().unwrap().close().unwrap(); + aborted.append_group(None).unwrap().finish().unwrap(); let stale_aborted = aborted.consume(); aborted.abort(Error::Timeout).unwrap(); let finished = track_producer_pooled("finished", pool.clone()); - finished.append_next().unwrap().close().unwrap(); + finished.append_group(None).unwrap().finish().unwrap(); let finished = finished.finish().unwrap(); let stale_finished = finished.consume(); drop(finished); @@ -17536,7 +17556,7 @@ mod test { fn closed_track_retires_an_expired_cut() { let pool = cache::Pool::new(cache::Config::default().with_expiry(Duration::from_secs(1))); let producer = track_producer_pooled("cut", pool.clone()); - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group.write_frame(group.key_time(), &b"a"[..]).unwrap(); group.abort(Error::Stream(StreamError::App(5))).unwrap(); let producer = producer.finish().unwrap(); @@ -17570,9 +17590,9 @@ mod test { for key in 0..2 { let group = producer.create_group(group::Info { start: key }).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); assert_eq!(consumer.assert_group().start, 0); assert_eq!(consumer.assert_group().start, 1); @@ -17591,9 +17611,9 @@ mod test { for key in 0..2 { let group = producer.create_group(group::Info { start: key }).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); producer.abort(Error::Timeout).unwrap(); assert_eq!(drain_ordered(&mut consumer), [0, 1]); @@ -17617,10 +17637,10 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); producer.abort(Error::Timeout).unwrap(); consumer.set_range(..1); @@ -17641,10 +17661,10 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } - producer.finish_at(Position::group(3), None).unwrap(); + producer.finish_at(Position::group(3)).unwrap(); producer.abort(Error::Timeout).unwrap(); consumer.set_range(..2); @@ -17667,7 +17687,7 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); let producer = producer.finish().unwrap(); @@ -17750,7 +17770,7 @@ mod test { again.write_frame(at(300), &b"a"[..]).unwrap(); again.write_frame(at(301), &b"b"[..]).unwrap(); assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"b"); - again.close().unwrap(); + again.finish().unwrap(); drop(third); assert!(reader.read_frame().await.unwrap().is_none()); } @@ -17784,7 +17804,7 @@ mod test { again.write_frame(at(300), &b"a"[..]).unwrap(); again.write_frame(at(301), &b"b"[..]).unwrap(); assert!(reader.poll_finished(&waiter).is_pending(), "the re-offer is still open"); - again.close().unwrap(); + again.finish().unwrap(); assert_eq!(reader.finished().await.unwrap(), 1); assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"b"); } @@ -17860,7 +17880,7 @@ mod test { drop(next); last.write_frame(at(300), &b"a"[..]).unwrap(); last.write_frame(at(301), &b"b"[..]).unwrap(); - last.close().unwrap(); + last.finish().unwrap(); assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"b"); assert!(reader.read_frame().await.unwrap().is_none()); } @@ -17903,7 +17923,7 @@ mod test { if !again_fails { drop(next); again.write_frame(at(302), &b"c"[..]).unwrap(); - again.close().unwrap(); + again.finish().unwrap(); assert_eq!(reader.finished().await.unwrap(), 1); assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"b"); assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"c"); @@ -17920,7 +17940,7 @@ mod test { for (millis, payload) in [(300, b"a"), (301, b"b"), (302, b"c")] { last.write_frame(at(millis), &payload[..]).unwrap(); } - last.close().unwrap(); + last.finish().unwrap(); assert_eq!(reader.finished().await.unwrap(), 1); assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"b"); assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"c"); @@ -17970,7 +17990,7 @@ mod test { again.handle().poll_unwanted(&waiter).is_pending(), "the re-offer stays wanted" ); - again.close().unwrap(); + again.finish().unwrap(); // From where the reader stands, with frame 1 still to read. assert_eq!(reader.finished().await.unwrap(), 1); assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"b"); @@ -18006,7 +18026,7 @@ mod test { }; drop(hold); again.write_frame(at(302), &b"c"[..]).unwrap(); - again.close().unwrap(); + again.finish().unwrap(); assert_eq!(producer.demand().wanted(), Some(0), "not read to its end yet"); assert_eq!(reader.finished().await.unwrap(), 1); assert_eq!(producer.demand().wanted(), None, "the re-offer answered the end"); @@ -18037,7 +18057,7 @@ mod test { for (millis, payload) in [(300, b"a"), (301, b"b"), (302, b"c")] { head.write_frame(at(millis), &payload[..]).unwrap(); } - head.close().unwrap(); + head.finish().unwrap(); first.abort(Error::Cancel).unwrap(); // An uncapped reader needs frames past the head, which no copy holds. assert!(reader.clone().with_end(None).read_frame().await.is_err()); @@ -18064,7 +18084,7 @@ mod test { for (millis, payload) in [(300, b"a"), (301, b"b"), (302, b"c")] { head.write_frame(at(millis), &payload[..]).unwrap(); } - head.close().unwrap(); + head.finish().unwrap(); // Takes frames 1 and 2 into its prefetch with frame 0. assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"a"); let mut reader = reader.with_end(None); @@ -18111,7 +18131,7 @@ mod test { let waiter = kio::Waiter::noop(); assert!(reader.poll_finished(&waiter).is_pending(), "the cut copy is still open"); let mut reader = reader.with_range(..); - cut.close().unwrap(); + cut.finish().unwrap(); let res = reader.finished().await; assert!(res.is_err(), "frame 3 is in no copy: {res:?}"); } @@ -18162,7 +18182,7 @@ mod test { for (millis, payload) in [(300, b"a"), (301, b"b"), (302, b"c"), (303, b"d")] { again.write_frame(at(millis), &payload[..]).unwrap(); } - again.close().unwrap(); + again.finish().unwrap(); assert_eq!( &reader.read_frame().await.unwrap().unwrap().payload[..], b"d", @@ -18198,7 +18218,7 @@ mod test { for (millis, payload) in [(300, b"a"), (301, b"b"), (302, b"c")] { head.write_frame(at(millis), &payload[..]).unwrap(); } - head.close().unwrap(); + head.finish().unwrap(); first.abort(Error::Cancel).unwrap(); assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"c"); @@ -18217,7 +18237,7 @@ mod test { for (millis, payload) in [(300, b"a"), (301, b"b"), (302, b"c"), (303, b"d")] { again.write_frame(at(millis), &payload[..]).unwrap(); } - again.close().unwrap(); + again.finish().unwrap(); assert_eq!(&reader.read_frame().await.unwrap().unwrap().payload[..], b"d"); assert!(reader.read_frame().await.unwrap().is_none()); // Its end, from where that reader stood, on the copy holding the rest. @@ -18274,7 +18294,7 @@ mod test { .write_frame(Timestamp::from_millis(millis).unwrap(), &b"x"[..]) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } /// A received group reordered behind its successor is still delivered in order: the @@ -18504,7 +18524,7 @@ mod test { producer .create_group(group::Info { start: 5 }) .unwrap() - .close() + .finish() .unwrap(); let group = consumer .next_group() @@ -18518,19 +18538,19 @@ mod test { producer .create_group(group::Info { start: 3 }) .unwrap() - .close() + .finish() .unwrap(); // Seq 4 arrives late and is also skipped. producer .create_group(group::Info { start: 4 }) .unwrap() - .close() + .finish() .unwrap(); // Seq 7 arrives and is returned. producer .create_group(group::Info { start: 7 }) .unwrap() - .close() + .finish() .unwrap(); let group = consumer @@ -18558,12 +18578,12 @@ mod test { producer .create_group(group::Info { start: 3 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 5 }) .unwrap() - .close() + .finish() .unwrap(); let group = consumer @@ -18598,7 +18618,7 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } let _finished = producer.finish().unwrap(); @@ -18647,7 +18667,7 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } let waiter = kio::Waiter::noop(); @@ -18680,7 +18700,7 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } let Poll::Ready(Ok(Some(reserved))) = subscriber.poll_peek_group(ordered, &kio::Waiter::noop()) else { @@ -18705,7 +18725,7 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } let waiter = kio::Waiter::noop(); @@ -18730,7 +18750,7 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } let waiter = kio::Waiter::noop(); @@ -18761,12 +18781,12 @@ mod test { producer .create_group(group::Info { start: 5 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 3 }) .unwrap() - .close() + .finish() .unwrap(); // The ordered handle returns the smallest key first, regardless of @@ -18793,7 +18813,7 @@ mod test { producer .create_group(group::Info { start: s }) .unwrap() - .close() + .finish() .unwrap(); } @@ -18821,7 +18841,7 @@ mod test { producer .create_group(group::Info { start: s }) .unwrap() - .close() + .finish() .unwrap(); } @@ -18853,7 +18873,7 @@ mod test { producer .create_group(group::Info { start: s }) .unwrap() - .close() + .finish() .unwrap(); } @@ -18867,12 +18887,12 @@ mod test { producer .create_group(group::Info { start: 3 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 4 }) .unwrap() - .close() + .finish() .unwrap(); assert!( consumer.next_group().now_or_never().is_none(), @@ -18897,28 +18917,28 @@ mod test { producer .create_group(group::Info { start: 2 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 5 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 3 }) .unwrap() - .close() + .finish() .unwrap(); // One beyond the cap; should be held even though it arrived in the middle. producer .create_group(group::Info { start: 8 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 4 }) .unwrap() - .close() + .finish() .unwrap(); // next_group walks in key order through everything <= cap. @@ -18947,7 +18967,7 @@ mod test { producer .create_group(group::Info { start: s }) .unwrap() - .close() + .finish() .unwrap(); } @@ -18983,17 +19003,17 @@ mod test { producer .create_group(group::Info { start: 2 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 0 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(consumer.recv_group().now_or_never().unwrap().unwrap().unwrap().start, 0); @@ -19013,31 +19033,31 @@ mod test { producer .create_group(group::Info { start: 2 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(consumer.recv_group().await.unwrap().unwrap().start, 2); consumer.set_range(..4); producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 3 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(consumer.recv_group().await.unwrap().unwrap().start, 3); consumer.set_range(0..=4); producer .create_group(group::Info { start: 0 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 4 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(consumer.recv_group().await.unwrap().unwrap().start, 4); } @@ -19054,7 +19074,7 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); assert!( consumer.recv_group().now_or_never().is_none(), @@ -19065,7 +19085,7 @@ mod test { producer .create_group(group::Info { start: 2 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!( consumer.recv_group().now_or_never().unwrap().unwrap().unwrap().start, @@ -19086,7 +19106,7 @@ mod test { producer .create_group(group::Info { start: 0 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(consumer.recv_group().now_or_never().unwrap().unwrap().unwrap().start, 0); @@ -19117,12 +19137,12 @@ mod test { producer .create_group(group::Info { start: 0 }) .unwrap() - .close() + .finish() .unwrap(); producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); consumer.set_range(..0); @@ -19150,7 +19170,7 @@ mod test { producer .create_group(group::Info { start: s }) .unwrap() - .close() + .finish() .unwrap(); } @@ -19186,7 +19206,7 @@ mod test { for i in 0..3u8 { group.write_frame(group.key_time(), vec![i]).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } assert_eq!(consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, 0); @@ -19227,9 +19247,9 @@ mod test { producer .create_group(group::Info { start: u64::MAX - 1 }) .unwrap() - .close() + .finish() .unwrap(); - assert!(matches!(producer.append_next(), Err(Error::BoundsExceeded(_)))); + assert!(matches!(producer.append_group(None), Err(Error::BoundsExceeded(_)))); assert_eq!( consumer.next_group().now_or_never().unwrap().unwrap().unwrap().start, u64::MAX - 1 @@ -19283,11 +19303,11 @@ mod test { let producer = track_producer("test", Info::timed()); // Produce a cached group. - let mut group = producer.append_next().unwrap(); // seq 0 + let mut group = producer.append_group(None).unwrap(); // seq 0 group .write_frame(group.key_time(), bytes::Bytes::from_static(b"hello")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); // A cached group resolves immediately and never queues a request. `peek_group` // also returns it synchronously. @@ -19329,7 +19349,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"hi")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut g = pending.await.unwrap(); assert_eq!(g.start, 5); @@ -19404,7 +19424,7 @@ mod test { .unwrap(); drop(req); assert!(fresh.poll_unwanted(&kio::Waiter::noop()).is_pending()); - fresh.accept(Info::timed()).unwrap().close().unwrap(); + fresh.accept(Info::timed()).unwrap().finish().unwrap(); assert_eq!(retry.await.unwrap().start, 5); } @@ -19449,7 +19469,7 @@ mod test { .now_or_never() .expect("the retry queues a fresh request") .unwrap(); - fresh.accept(Info::timed()).unwrap().close().unwrap(); + fresh.accept(Info::timed()).unwrap().finish().unwrap(); assert_eq!(retry.await.unwrap().start, 5); } @@ -19481,7 +19501,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"hi")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut fetched = retry.await.unwrap(); assert_eq!(&fetched.read_frame().await.unwrap().unwrap().payload[..], b"hi"); @@ -19549,7 +19569,7 @@ mod test { for _ in 0..4 { prefix.write_frame(prefix.key_time(), b"prefix".as_slice()).unwrap(); } - prefix.close().unwrap(); + prefix.finish().unwrap(); let mut bounded = bounded.await.unwrap().with_range(2..).with_end(Some(4)); for expected in 2..4 { assert_eq!(bounded.index(), expected); @@ -19576,7 +19596,7 @@ mod test { for _ in 0..6 { complete.write_frame(complete.key_time(), b"prefix".as_slice()).unwrap(); } - complete.close().unwrap(); + complete.finish().unwrap(); let mut whole = whole.await.unwrap(); for _ in 0..6 { assert!(whole.read_frame().await.unwrap().is_some()); @@ -19610,7 +19630,7 @@ mod test { assert_eq!((fill.frame_start(), fill.frame_end()), (start, Some(start + 1))); let mut tail = fill.accept(Info::timed()).unwrap(); tail.write_frame(tail.key_time(), b"tail".as_slice()).unwrap(); - tail.close().unwrap(); + tail.finish().unwrap(); assert_eq!(fetched.await.unwrap().index(), start); assert_eq!(producer.state.read().lookup[&0].copies().count(), 2); } @@ -19651,7 +19671,7 @@ mod test { for _ in frames { group.write_frame(group.key_time(), b"tail".as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); }; let later = consumer.fetch_range(0, range(4, 10)); fill(4..10).await; @@ -19694,7 +19714,7 @@ mod test { end: Some(1), }, ); - fill(0, Some(1)).await.close().unwrap(); + fill(0, Some(1)).await.finish().unwrap(); assert_eq!(head.await.unwrap().index(), 0); assert_eq!(tail.await.unwrap().index(), 5); let mut sub = producer.subscribe(None); @@ -19782,7 +19802,7 @@ mod test { for _ in 0..2 { group.write_frame(group.key_time(), b"copy".as_slice()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let mut fetched = fetch.await.unwrap(); producer.abort(Error::Cancel).unwrap(); @@ -19815,10 +19835,10 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); - producer.finish_at(Position::group(2), None).unwrap(); - group.close().unwrap(); + producer.finish_at(Position::group(2)).unwrap(); + group.finish().unwrap(); fetch.await.unwrap(); producer.abort(Error::Timeout).unwrap(); @@ -19852,7 +19872,7 @@ mod test { .accept(Info::timed()) .unwrap(); group.write_frame(group.key_time(), b"head".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); fetch.await.unwrap(); }; let mut arrival = producer.subscribe(replay()); @@ -19959,7 +19979,7 @@ mod test { .now_or_never() .expect("the retry queues a fresh request") .unwrap(); - req.accept(Info::timed()).unwrap().close().unwrap(); + req.accept(Info::timed()).unwrap().finish().unwrap(); assert!(retry.await.unwrap().read_frame().await.unwrap().is_none()); } @@ -19989,7 +20009,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"retry")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = retry.await.unwrap(); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"retry"); @@ -20011,7 +20031,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"tail")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); // A fetch for the tail is covered and resolves from the cache. let fetch = consumer.fetch_group( @@ -20040,7 +20060,7 @@ mod test { whole .write_frame(whole.key_time(), bytes::Bytes::from_static(b"head")) .unwrap(); - whole.close().unwrap(); + whole.finish().unwrap(); let mut served = fetch.await.unwrap(); assert_eq!(served.index(), 0); @@ -20109,7 +20129,7 @@ mod test { live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); - live.close().unwrap(); + live.finish().unwrap(); let mut sub = producer.subscribe(replay().with_range(0..1)); let reading = kio::clock::sim::spawn(async move { @@ -20130,7 +20150,7 @@ mod test { head.write_frame(head.key_time(), bytes::Bytes::from_static(payload)) .unwrap(); } - head.close().unwrap(); + head.finish().unwrap(); let (frames, ended) = reading.await.unwrap(); assert_eq!(frames, [&b"snapshot"[..], b"delta"]); assert!(ended, "the read ends with its range"); @@ -20148,12 +20168,12 @@ mod test { live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); - live.close().unwrap(); + live.finish().unwrap(); let mut newer = producer.create_group(group::Info { start: 1 }).unwrap(); newer .write_frame(Timestamp::from_secs(1).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); let mut sub = producer.subscribe(Subscription::default().with_range(0..1)); let reading = kio::clock::sim::spawn(async move { @@ -20169,7 +20189,7 @@ mod test { head.write_frame(head.key_time(), bytes::Bytes::from_static(payload)) .unwrap(); } - head.close().unwrap(); + head.finish().unwrap(); assert_eq!(reading.await.unwrap(), (Some(0), true)); } @@ -20187,7 +20207,7 @@ mod test { live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); - live.close().unwrap(); + live.finish().unwrap(); let mut sub = producer.subscribe(Subscription::default().with_range(0..2)); assert!(sub.recv_group().now_or_never().is_none(), "the head is still asked"); @@ -20198,7 +20218,7 @@ mod test { newer .write_frame(Timestamp::from_millis(1).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); if evict { producer.modify().unwrap().evict_group(0, Error::Evicted); } @@ -20232,7 +20252,7 @@ mod test { bytes::Bytes::from_static(b"delta"), ) .unwrap(); - live.close().unwrap(); + live.finish().unwrap(); } let mut sub = producer.subscribe(replay().with_order(order).with_range(0..2)); @@ -20252,7 +20272,7 @@ mod test { bytes::Bytes::from_static(b"snapshot"), ) .unwrap(); - head.close().unwrap(); + head.finish().unwrap(); } let mut got = Vec::new(); @@ -20282,8 +20302,8 @@ mod test { bytes::Bytes::from_static(b"delta"), ) .unwrap(); - live.close().unwrap(); - framed(&producer, 1, 1).close().unwrap(); + live.finish().unwrap(); + framed(&producer, 1, 1).finish().unwrap(); let mut sub = producer.subscribe(replay().with_range(0..2)); let group = sub.recv_group().now_or_never().unwrap().unwrap().unwrap(); @@ -20298,7 +20318,7 @@ mod test { bytes::Bytes::from_static(b"snapshot"), ) .unwrap(); - head.close().unwrap(); + head.finish().unwrap(); assert!( matches!(sub.recv_group().now_or_never(), Some(Ok(None))), "the narrowed read ends without group 0" @@ -20320,8 +20340,8 @@ mod test { bytes::Bytes::from_static(b"delta"), ) .unwrap(); - live.close().unwrap(); - framed(&producer, 1, 1).close().unwrap(); + live.finish().unwrap(); + framed(&producer, 1, 1).finish().unwrap(); let mut sub = producer.subscribe(replay().with_range(0..2)).ordered(); let reading = kio::clock::sim::spawn(async move { @@ -20369,7 +20389,7 @@ mod test { fetch.await.unwrap(); assert!(matches!( - producer.finish_at(Position { group: 0, frame: 2 }, None), + producer.finish_at(Position { group: 0, frame: 2 }), Err(Error::ProtocolViolation) )); assert_eq!(producer.finished(), None); @@ -20394,7 +20414,7 @@ mod test { head.write_frame(head.key_time(), bytes::Bytes::from_static(payload)) .unwrap(); } - let head = head.close().unwrap(); + let head = head.finish().unwrap(); assert_eq!(fetch.await.unwrap().index(), 0); (live, head) } @@ -20427,10 +20447,10 @@ mod test { match live { Some(err) => group.abort(err).unwrap(), None => { - group.close().unwrap(); + group.finish().unwrap(); } } - producer.finish_at(Position::group(1), None).unwrap(); + producer.finish_at(Position::group(1)).unwrap(); (producer, head) } @@ -20453,7 +20473,7 @@ mod test { "{live:?}: the head still writes" ); } - head.close().unwrap(); + head.finish().unwrap(); if polled { assert!( woken.load(Ordering::SeqCst), @@ -20518,7 +20538,7 @@ mod test { let noop = kio::Waiter::noop(); let (live, _head) = live_group_with_head(&producer).await; - producer.finish_at(Position::group(1), None).unwrap(); + producer.finish_at(Position::group(1)).unwrap(); assert!(matches!(producer.poll_closed(&noop), Poll::Ready(Ok(())))); live.abort(Error::Cancel).unwrap(); @@ -20544,7 +20564,7 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); let fetch = consumer.fetch_group(0, None); @@ -20560,7 +20580,7 @@ mod test { let woken = Arc::new(AtomicBool::new(false)); let waiter = kio::Waiter::new(futures::task::waker(Arc::new(FlagWake(woken.clone())))); if parked { - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); assert!( producer.poll_closed(&waiter).is_pending(), "{err:?}: the fetch still writes" @@ -20574,7 +20594,7 @@ mod test { "{err:?}: the fetch failing wakes the wait" ); } else { - producer.finish_at(Position::group(2), None).unwrap(); + producer.finish_at(Position::group(2)).unwrap(); } assert!( matches!(producer.poll_closed(&noop), Poll::Ready(Ok(()))), @@ -20625,7 +20645,7 @@ mod test { Poll::Ready(Some(Position { group: 0, frame: 2 })) ); - head.close().unwrap(); + head.finish().unwrap(); assert_eq!(reader.poll_largest(&noop), Poll::Ready(None)); } @@ -20687,7 +20707,7 @@ mod test { async fn reading_the_head_keeps_the_slot_from_expiring() { let producer = track_producer("test", Info::timed()); let (live, _head) = live_group_with_head(&producer).await; - live.close().unwrap(); + live.finish().unwrap(); let _open = producer.create_group(group::Info { start: 1 }).unwrap(); elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); @@ -20711,7 +20731,7 @@ mod test { live.start_at(1).unwrap(); live.write_frame(live.key_time(), bytes::Bytes::from_static(b"delta")) .unwrap(); - let live = live.close().unwrap(); + let live = live.finish().unwrap(); let fetch = consumer.fetch_group(0, None); let mut head = dynamic .requested_fill_group() @@ -20721,7 +20741,7 @@ mod test { .unwrap(); head.write_frame(head.key_time(), bytes::Bytes::from(vec![0u8; 10_000])) .unwrap(); - head.close().unwrap(); + head.finish().unwrap(); drop(fetch.await.unwrap()); if abort_live { live.abort(Error::Cancel).unwrap(); @@ -20802,14 +20822,14 @@ mod test { assert_eq!(narrow.await.unwrap().index(), 5); assert_eq!(wider.await.unwrap().index(), 2); assert!(futures::poll!(widest.as_mut()).is_pending()); - group.close().unwrap(); + group.finish().unwrap(); let mut group = whole.accept(None).unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from_static(b"from0")) .unwrap(); assert_eq!(widest.await.unwrap().index(), 0); - group.close().unwrap(); + group.finish().unwrap(); } #[kio::test] @@ -20856,7 +20876,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"hi")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(first.await.unwrap().start, 5); assert_eq!(second.await.unwrap().start, 5); @@ -20888,7 +20908,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"hi")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(loose.await.unwrap().start, 5); } @@ -20946,7 +20966,7 @@ mod test { // A track with no `Requests` can't serve old content, so a cache miss // resolves to NotFound instead of blocking forever. let producer = track_producer("test", Info::timed()); - let _open = producer.append_next().unwrap(); // seq 0, but we miss on seq 5 + let _open = producer.append_group(None).unwrap(); // seq 0, but we miss on seq 5 let consumer = producer.consume(); assert!(matches!(consumer.fetch_group(5, None).await, Err(Error::NotFound))); } @@ -20955,7 +20975,7 @@ mod test { #[cfg(feature = "async")] async fn fetch_past_final_not_found() { let producer = track_producer("test", Info::timed()); - let _open = producer.append_next().unwrap(); // seq 0 + let _open = producer.append_group(None).unwrap(); // seq 0 producer.finish_shared().unwrap(); // final_key = 1 // A group at or past the final key can never exist, even with a handler, @@ -20983,11 +21003,11 @@ mod test { } fn finished_group(producer: &mut Producer, size: usize) -> u64 { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from(vec![0u8; size])) .unwrap(); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); group.start } @@ -21033,9 +21053,9 @@ mod test { let frame = bytes::Bytes::from(vec![0u8; 256 * 1024]); let groups = 16; for _ in 0..groups { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group.write_frame(group.key_time(), frame.clone()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } assert!(pool.used() < capacity, "the slices fit: {}", pool.used()); @@ -21136,12 +21156,12 @@ mod test { let (mut producer, _) = pooled_producer(22 * unit); finished_group(&mut producer, 20 * unit as usize); - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); let mut reader = group.consume(); for _ in 0..3 { group.write_frame(group.key_time(), vec![0u8; unit as usize]).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); for _ in 0..3 { assert_eq!(reader.read_frame().await.unwrap().unwrap().payload.len(), unit as usize); } @@ -21191,7 +21211,7 @@ mod test { ..Default::default() }); let failed = Producer::new(broadcast.clone(), "failed", Info::timed()); - let mut group = failed.append_next().unwrap(); + let mut group = failed.append_group(None).unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from(vec![0u8; 1_000])) .unwrap(); @@ -21271,8 +21291,8 @@ mod test { // Accept with a fresh Info: the pre-accept group's writes must still be // drained by this track's future charges. let producer = request.accept(Info::timed()); - producer.append_next().unwrap().close().unwrap(); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); assert!( producer.consume().peek_group(0).is_none(), @@ -21286,7 +21306,7 @@ mod test { #[test] fn recreated_key_bounds_eviction_hints() { let (producer, _pool) = pooled_producer(1 << 40); - producer.create_group(5u64.into()).unwrap().close().unwrap(); + producer.create_group(5u64.into()).unwrap().finish().unwrap(); for _ in 0..200 { let group = producer.create_group(1u64.into()).unwrap(); @@ -21312,7 +21332,7 @@ mod test { // No time advances: every stamp lands in the same tick. let (mut producer, _pool) = pooled_producer(10 * unit); - producer.append_next().unwrap().close().unwrap(); // seq 0: empty + producer.append_group(None).unwrap().finish().unwrap(); // seq 0: empty finished_group(&mut producer, 3 * unit as usize); // seq 1: written finished_group(&mut producer, 3 * unit as usize); // seq 2 finished_group(&mut producer, 3 * unit as usize); // seq 3 @@ -21328,8 +21348,8 @@ mod test { #[test] fn frame_only_writer_pays() { let (producer, pool) = pooled_producer(2_000); - let mut demoted = producer.append_next().unwrap(); // seq 0 - producer.append_next().unwrap().close().unwrap(); // seq 1 demotes seq 0 + let mut demoted = producer.append_group(None).unwrap(); // seq 0 + producer.append_group(None).unwrap().finish().unwrap(); // seq 1 demotes seq 0 // One large frame crosses the charge threshold: the write itself pays, // with no further group insert on this track. @@ -21342,7 +21362,7 @@ mod test { "the frame write settled the debt: {}", pool.used() ); - assert!(matches!(demoted.close(), Err(Error::Evicted))); + assert!(matches!(demoted.finish(), Err(Error::Evicted))); } /// One `Info` describing several tracks must not join their eviction accounting: @@ -21398,7 +21418,7 @@ mod test { fn teardown_ignores_a_settling_group() { let (producer, pool) = pooled_producer(1 << 40); // Open, so only the abrupt teardown releases it. - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(group.key_time(), bytes::Bytes::from(vec![0u8; 100])) .unwrap(); @@ -21466,7 +21486,7 @@ mod test { // Accept, then demote the backfill with a live group. let producer = request.accept(Info::timed()); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); // No further insert: the late write into the demoted backfill is the only // thing that can pay the debt it just took on. @@ -21487,22 +21507,22 @@ mod test { #[test] fn write_restarts_retention_clock() { let (producer, _pool) = pooled_producer(1 << 40); - let mut straggler = producer.append_next().unwrap(); // seq 0 - producer.append_next().unwrap().close().unwrap(); // seq 1 demotes seq 0 + let mut straggler = producer.append_group(None).unwrap(); // seq 0 + producer.append_group(None).unwrap().finish().unwrap(); // seq 1 demotes seq 0 // Idle past the window, then the straggler receives a late frame. elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); straggler .write_frame(straggler.key_time(), bytes::Bytes::from(vec![0u8; 100])) .unwrap(); - producer.append_next().unwrap().close().unwrap(); // seq 2 runs expiry + producer.append_group(None).unwrap().finish().unwrap(); // seq 2 runs expiry let consumer = producer.consume(); assert!(consumer.peek_group(0).is_some(), "the write restarted the clock"); // Once the writes stop, the group ages out normally. elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); - producer.append_next().unwrap().close().unwrap(); // seq 3 runs expiry + producer.append_group(None).unwrap().finish().unwrap(); // seq 3 runs expiry assert!(consumer.peek_group(0).is_none(), "idle content still expires"); } @@ -21515,7 +21535,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - producer.create_group(10u64.into()).unwrap().close().unwrap(); + producer.create_group(10u64.into()).unwrap().finish().unwrap(); for key in 1..=5u64 { let pending = consumer.fetch_group(key, None); let req = dynamic @@ -21527,7 +21547,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from(vec![0u8; 100])) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); pending.await.unwrap(); } @@ -21540,7 +21560,7 @@ mod test { // The rotating cursor reaches the fifth entry within a few writes. for _ in 0..3 { - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); } assert!(consumer.peek_group(5).is_none(), "expired backfill is reclaimed"); assert!(consumer.peek_group(1).is_some(), "refreshed backfill survives"); @@ -21552,11 +21572,11 @@ mod test { fn recreated_key_delivered_once() { let (producer, _pool) = pooled_producer(1 << 40); - producer.create_group(0u64.into()).unwrap().close().unwrap(); + producer.create_group(0u64.into()).unwrap().finish().unwrap(); let aborted = producer.create_group(1u64.into()).unwrap(); aborted.abort(Error::Cancel).unwrap(); - producer.create_group(2u64.into()).unwrap().close().unwrap(); - producer.create_group(1u64.into()).unwrap().close().unwrap(); + producer.create_group(2u64.into()).unwrap().finish().unwrap(); + producer.create_group(1u64.into()).unwrap().finish().unwrap(); let mut subscriber = producer.subscribe(replay()); assert_eq!(subscriber.assert_group().start, 0); @@ -21575,8 +21595,8 @@ mod test { #[test] fn aborted_group_leaves_no_ghost_sample() { let (producer, pool) = pooled_producer(1 << 40); - let group0 = producer.append_next().unwrap(); - let _open = producer.append_next().unwrap(); // demotes seq 0 into the mean + let group0 = producer.append_group(None).unwrap(); + let _open = producer.append_group(None).unwrap(); // demotes seq 0 into the mean assert!(pool.average().is_some(), "demoted group is sampled"); group0.abort(Error::Cancel).unwrap(); @@ -21589,8 +21609,8 @@ mod test { fn empty_groups_repay_overhead() { let (producer, pool) = pooled_producer(1_000); for _ in 0..100 { - let group = producer.append_next().unwrap(); - group.close().unwrap(); + let group = producer.append_group(None).unwrap(); + group.finish().unwrap(); } assert!( @@ -21605,8 +21625,8 @@ mod test { #[test] fn growth_on_demoted_group_is_billed() { let (producer, pool) = pooled_producer(2_000); - let mut straggler = producer.append_next().unwrap(); // seq 0 - producer.append_next().unwrap().close().unwrap(); // seq 1 demotes seq 0 + let mut straggler = producer.append_group(None).unwrap(); // seq 0 + producer.append_group(None).unwrap().finish().unwrap(); // seq 1 demotes seq 0 // The demoted group balloons: no eviction yet (nothing ran), but billed. straggler @@ -21614,7 +21634,7 @@ mod test { .unwrap(); // The next append observes the growth and evicts the straggler. - producer.append_next().unwrap().close().unwrap(); // seq 2 + producer.append_group(None).unwrap().finish().unwrap(); // seq 2 let consumer = producer.consume(); assert!(consumer.peek_group(0).is_none(), "the ballooned group is evicted"); @@ -21630,10 +21650,10 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - producer.create_group(0u64.into()).unwrap().close().unwrap(); + producer.create_group(0u64.into()).unwrap().finish().unwrap(); let aborted = producer.create_group(1u64.into()).unwrap(); aborted.abort(Error::Cancel).unwrap(); - producer.create_group(2u64.into()).unwrap().close().unwrap(); + producer.create_group(2u64.into()).unwrap().finish().unwrap(); // Re-serve seq 1 as backfill; its slot replaces the aborted one, and the // old arrival entry for seq 1 now resolves to it. @@ -21647,7 +21667,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"backfill")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); pending.await.unwrap(); // The backfill serves by key, but never in arrival order. @@ -21681,7 +21701,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - producer.create_group(5u64.into()).unwrap().close().unwrap(); + producer.create_group(5u64.into()).unwrap().finish().unwrap(); for key in [2u64, 3u64] { let pending = consumer.fetch_group(key, None); let req = dynamic @@ -21693,7 +21713,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from(vec![0u8; 100])) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); pending.await.unwrap(); } @@ -21701,7 +21721,7 @@ mod test { elapse(&producer, cache::DEFAULT_EXPIRY / 2 + Duration::from_secs(1)); consumer.fetch_group(2, None).await.unwrap(); elapse(&producer, cache::DEFAULT_EXPIRY / 2 + Duration::from_secs(1)); - producer.create_group(6u64.into()).unwrap().close().unwrap(); + producer.create_group(6u64.into()).unwrap().finish().unwrap(); let consumer = producer.consume(); assert!(consumer.peek_group(2).is_some(), "refreshed backfill survives"); @@ -21740,10 +21760,10 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - let straggler = producer.append_next().unwrap(); // seq 0 + let straggler = producer.append_group(None).unwrap(); // seq 0 // The publisher aborts its own latest group; the key stays at the live edge. - let latest = producer.append_next().unwrap(); // seq 1 + let latest = producer.append_group(None).unwrap(); // seq 1 latest.abort(Error::Cancel).unwrap(); // Re-fetch it: the replacement takes over max_key. @@ -21757,7 +21777,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from(vec![0u8; 1000])) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); pending.await.unwrap(); // The refetched latest is protected by omission: it has no entry in the @@ -21800,7 +21820,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"refetched")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = pending.await.unwrap(); assert_eq!(&group.read_frame().await.unwrap().unwrap().payload[..], b"refetched"); @@ -21838,7 +21858,7 @@ mod test { producer .create_group(group::Info { start: 3 }) .expect("an aborted slot releases its key") - .close() + .finish() .unwrap(); } @@ -21851,7 +21871,7 @@ mod test { let (producer, _pool) = pooled_producer(1 << 40); let dynamic = producer.requests(); let consumer = producer.consume(); - producer.create_group(5u64.into()).unwrap().close().unwrap(); + producer.create_group(5u64.into()).unwrap().finish().unwrap(); let mut subscriber = producer.subscribe(replay().with_range(5..)); assert_eq!(subscriber.assert_group().start, 5); @@ -21865,7 +21885,7 @@ mod test { fetched .write_frame(fetched.key_time(), bytes::Bytes::from_static(b"backfill")) .unwrap(); - fetched.close().unwrap(); + fetched.finish().unwrap(); pending.await.unwrap(); let _frameless = producer.create_group(group::Info { start: 3 }).unwrap(); @@ -21899,8 +21919,8 @@ mod test { let consumer = producer.consume(); // The publisher starts at seq 5; earlier groups exist only upstream. - producer.create_group(5u64.into()).unwrap().close().unwrap(); - producer.create_group(6u64.into()).unwrap().close().unwrap(); + producer.create_group(5u64.into()).unwrap().finish().unwrap(); + producer.create_group(6u64.into()).unwrap().finish().unwrap(); // Fetch the gap: it lands in the cache and resolves the fetch... let pending = consumer.fetch_group(2, None); @@ -21913,7 +21933,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"backfill")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut fetched = pending.await.unwrap(); assert_eq!(&fetched.read_frame().await.unwrap().unwrap().payload[..], b"backfill"); assert!(consumer.peek_group(2).is_some(), "backfill is cached for later fetches"); @@ -21971,7 +21991,7 @@ mod test { // The fetch giving up never cuts the group short for the subscriber. drop(fetched); fetching.abort(Error::Cancel).unwrap(); - live.close().unwrap(); + live.finish().unwrap(); assert!(group.read_frame().await.unwrap().is_none()); assert!(matches!( producer.create_group_at(0u64.into(), 0), @@ -21988,7 +22008,7 @@ mod test { let dynamic = producer.requests(); let consumer = producer.consume(); - producer.create_group(5u64.into()).unwrap().close().unwrap(); + producer.create_group(5u64.into()).unwrap().finish().unwrap(); // Serve a backfill fetch for an old key. let pending = consumer.fetch_group(2, None); @@ -22001,13 +22021,13 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from(vec![0u8; 1000])) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); pending.await.unwrap(); let used = pool.used(); // Age past the pool's LRU window; the next write reclaims the backfill. elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); - producer.create_group(6u64.into()).unwrap().close().unwrap(); + producer.create_group(6u64.into()).unwrap().finish().unwrap(); assert!(consumer.peek_group(2).is_none(), "expired backfill is reclaimed"); assert!(pool.used() < used, "its bytes are released"); @@ -22015,7 +22035,7 @@ mod test { /// Append a finished group of a 3 byte first frame and a `delta` byte delta. fn refresh_group(producer: &Producer, delta: usize) { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(crate::Timestamp::unscaled(group.start), &b"key"[..]) .unwrap(); @@ -22024,7 +22044,7 @@ mod test { .write_frame(crate::Timestamp::unscaled(group.start), vec![0u8; delta]) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } /// Poll `demand` for a change without waiting. @@ -22073,14 +22093,14 @@ mod test { fn a_group_read_keeps_its_track_wanted_until_its_end() { let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(None); - let mut writing = producer.append_next().unwrap(); + let mut writing = producer.append_group(None).unwrap(); writing.write_frame(writing.key_time(), &b"key"[..]).unwrap(); let mut group = subscriber.assert_group(); let other = group.clone(); drop(subscriber); assert_eq!(producer.demand().wanted(), Some(0), "the group is read"); - writing.close().unwrap(); + writing.finish().unwrap(); assert_eq!(producer.demand().wanted(), Some(0), "not read to its end yet"); let waiter = kio::Waiter::noop(); assert!(matches!(group.poll_read_frame(&waiter), Poll::Ready(Ok(Some(_))))); @@ -22099,7 +22119,7 @@ mod test { fn a_range_cap_is_not_the_groups_end() { let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(None); - let mut writing = producer.append_next().unwrap(); + let mut writing = producer.append_group(None).unwrap(); writing.write_frame(writing.key_time(), &b"key"[..]).unwrap(); let group = subscriber.assert_group(); let mut capped = group.clone().with_range(..1); @@ -22118,7 +22138,7 @@ mod test { writing.write_frame(writing.key_time(), &b"delta"[..]).unwrap(); let mut capped = capped.with_range(..); assert!(matches!(capped.poll_read_frame(&waiter), Poll::Ready(Ok(Some(_))))); - writing.close().unwrap(); + writing.finish().unwrap(); assert!(matches!(capped.poll_read_frame(&waiter), Poll::Ready(Ok(None)))); assert_eq!(producer.demand().wanted(), None, "read to the group's end"); } @@ -22128,7 +22148,7 @@ mod test { #[cfg(feature = "async")] fn a_fetched_group_keeps_its_track_wanted() { let producer = track_producer("test", Info::timed()); - let mut writing = producer.append_next().unwrap(); + let mut writing = producer.append_group(None).unwrap(); writing.write_frame(writing.key_time(), &b"key"[..]).unwrap(); let group = producer .consume() @@ -22243,10 +22263,10 @@ mod test { let first = consumer.fetch_group(3, None); let second = consumer.fetch_group(3, None); let waiter = kio::Waiter::noop(); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("one fill for both fetches"); }; - assert!(dynamic.poll_requested_fill(&waiter).is_pending(), "the second joined"); + assert!(dynamic.poll_requested_groups(&waiter).is_pending(), "the second joined"); assert_eq!((fill.start(), fill.end()), (Position::group(3), 4)); assert_eq!(fill.wanted(), Some(3)); drop(first); @@ -22269,7 +22289,7 @@ mod test { let consumer = producer.consume(); let mut fetch = consumer.fetch_group(3, None); let waiter = kio::Waiter::noop(); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the fill is ready"); }; let group = fill.accept(3, Info::timed()).unwrap(); @@ -22279,7 +22299,7 @@ mod test { matches!(kio::Task::poll(&mut *fetch, &waiter), Poll::Ready(Ok(_))), "the fetch gets the accepted group" ); - group.close().unwrap(); + group.finish().unwrap(); } /// A feed declared to start at group 2, with groups 2 and 3 written, read from group 0. @@ -22299,7 +22319,7 @@ mod test { group .write_frame(Timestamp::from_millis(millis).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } #[cfg(feature = "async")] @@ -22325,7 +22345,7 @@ mod test { read.push(group.start); } assert_eq!(read, [2, 3]); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; assert_eq!((fill.start().group, fill.end()), (0, 2)); @@ -22341,7 +22361,7 @@ mod test { elapse(&producer, Duration::from_secs(31)); assert_eq!(drained_drops(&mut subscriber), [(1, 2)]); assert!( - dynamic.poll_requested_fill(&waiter).is_pending(), + dynamic.poll_requested_groups(&waiter).is_pending(), "a refusal is not asked again" ); } @@ -22357,7 +22377,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; let mut producer = track_producer("test", None); producer.fills_from_start(); @@ -22370,7 +22390,7 @@ mod test { let waiter = kio::Waiter::noop(); assert_eq!(drain_groups(&mut subscriber), [2, 3]); assert!( - dynamic.poll_requested_fill(&waiter).is_pending(), + dynamic.poll_requested_groups(&waiter).is_pending(), "below the start is no miss" ); assert!(drained_drops(&mut subscriber).is_empty()); @@ -22378,7 +22398,7 @@ mod test { // The re-offer of a widened budget. write(&producer, 1); assert_eq!(drain_groups(&mut subscriber), [1]); - assert!(dynamic.poll_requested_fill(&waiter).is_pending()); + assert!(dynamic.poll_requested_groups(&waiter).is_pending()); } /// Below a start its publisher resolved, a reader asks for the history its budget @@ -22399,7 +22419,7 @@ mod test { drained_drops(&mut reader).is_empty(), "nothing below the start is given up unasked" ); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the reader asks below the start"); }; assert_eq!((fill.start().group, fill.end()), (0, 2)); @@ -22420,13 +22440,13 @@ mod test { let waiter = kio::Waiter::noop(); assert_eq!(drain_groups(&mut reader), [2, 3]); assert!( - dynamic.poll_requested_fill(&waiter).is_pending(), + dynamic.poll_requested_groups(&waiter).is_pending(), "below a declared start is no miss" ); producer.start_resolved(2).unwrap(); assert!(reader.poll_recv_group(&waiter).is_pending()); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the reader asks below the resolved start"); }; assert_eq!((fill.start().group, fill.end()), (0, 2)); @@ -22440,7 +22460,7 @@ mod test { let (producer, dynamic, mut first) = started_late(); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = first.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; while let Some(key) = fill.wanted() { @@ -22454,7 +22474,7 @@ mod test { read.sort(); assert_eq!(read, [0, 1, 2, 3]); assert!( - dynamic.poll_requested_fill(&waiter).is_pending(), + dynamic.poll_requested_groups(&waiter).is_pending(), "the cache answers it" ); } @@ -22472,7 +22492,7 @@ mod test { write_group(&producer, 2); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; while let Some(key) = fill.wanted() { @@ -22504,7 +22524,7 @@ mod test { }; assert_eq!(next(&mut subscriber), None, "groups 0 and 1 are being filled"); // The handler takes the fill and never answers it. - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; elapse(&producer, Duration::from_secs(29)); @@ -22533,7 +22553,7 @@ mod test { "group 0 is being filled" ); // The handler takes the fill and never answers it. - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; assert_eq!((fill.start().group, fill.end()), (0, 10)); @@ -22570,7 +22590,7 @@ mod test { write_group(&producer, 10); let waiter = kio::Waiter::noop(); let fetch = producer.consume().fetch_group(3, None); - let Poll::Ready(Ok(first)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(first)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; let group = first.accept(3, None).unwrap(); @@ -22583,7 +22603,7 @@ mod test { subscriber.poll_next_group(&waiter).is_pending(), "group 0 is being filled" ); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the aborted group is a miss again"); }; assert_eq!((fill.start().group, fill.end()), (0, 10)); @@ -22609,7 +22629,7 @@ mod test { ..Default::default() }, ); - let Poll::Ready(Ok(first)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(first)) = dynamic.poll_requested_groups(&waiter) else { panic!("an evicted group is a miss"); }; first.refuse_groups(3..4, Error::Unsupported); @@ -22623,7 +22643,7 @@ mod test { subscriber.poll_next_group(&waiter).is_pending(), "group 3 is being filled" ); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the source may still have group 3"); }; assert!(fill.is_wanted(3)); @@ -22642,7 +22662,7 @@ mod test { evict(&producer, 3); let waiter = kio::Waiter::noop(); let fetch = producer.consume().fetch_group(3, None); - let Poll::Ready(Ok(first)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(first)) = dynamic.poll_requested_groups(&waiter) else { panic!("an evicted group is a miss"); }; first.group(3).reject(Error::NotFound); @@ -22656,7 +22676,7 @@ mod test { subscriber.poll_next_group(&waiter).is_pending(), "group 3 is being filled" ); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the source may still have part of group 3"); }; assert!(fill.is_wanted(3)); @@ -22675,7 +22695,7 @@ mod test { write_group(&producer, 10); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; // The window inside `Fill::accept` between caching the group and publishing the answer. @@ -22705,7 +22725,7 @@ mod test { subscriber.poll_next_group(&waiter).is_pending(), "group 0 is being filled" ); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; let _writing = fill.accept(0, None).unwrap(); @@ -22731,7 +22751,7 @@ mod test { write_group(&producer, 10); let noop = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&noop) {} - let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_fill(&noop) else { + let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_groups(&noop) else { panic!("below the start is a miss"); }; let (flag, waiter) = Flag::waiter(); @@ -22778,7 +22798,7 @@ mod test { write_group(&producer, 1); let noop = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&noop) {} - let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_fill(&noop) else { + let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_groups(&noop) else { panic!("below the start is a miss"); }; let (flag, waiter) = Flag::waiter(); @@ -22807,7 +22827,7 @@ mod test { write_group(&producer, 10); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; assert_eq!(fill.wanted(), Some(9)); @@ -22850,7 +22870,7 @@ mod test { write_group(&producer, 10); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; let _writing = [fill.accept(0, None).unwrap(), fill.accept(1, None).unwrap()]; @@ -22884,7 +22904,7 @@ mod test { write_group(&producer, 10); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; let group = fill.group(9); @@ -22927,27 +22947,22 @@ mod test { Vec::::new(), "the time start waits on its lookup" ); - let Poll::Ready(Ok(lookup)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(Fill::Lookup(lookup))) = dynamic.poll_requested_fill(&waiter) else { panic!("the time start is looked up"); }; - assert_eq!((lookup.time(), lookup.start().group, lookup.end()), (Some(5), 0, 10)); - assert_eq!(lookup.wanted(), None, "a lookup owes no group"); + assert_eq!((lookup.time(), lookup.span()), (5, 0..10)); drop(lookup); let mut read = drain_groups(&mut subscriber); let mut asked = Vec::new(); - while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) { - asked.push((fill.time(), fill.start().group, fill.end())); + while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) { + asked.push((fill.start().group, fill.end())); while let Some(key) = fill.wanted() { write_filled(fill.accept(key, None), key); } drop(fill); read.extend(drain_groups(&mut subscriber)); } - assert_eq!( - asked, - [(None, 0, 2), (None, 5, 10)], - "nothing below 5 for the time start" - ); + assert_eq!(asked, [(0, 2), (5, 10)], "nothing below 5 for the time start"); assert_eq!(read, [10, 0, 1, 5, 6, 7, 8, 9]); } @@ -22971,18 +22986,17 @@ mod test { Vec::::new(), "nothing reads until it is found" ); - let Poll::Ready(Ok(lookup)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(Fill::Lookup(lookup))) = dynamic.poll_requested_fill(&waiter) else { panic!("the time start is looked up"); }; - assert_eq!(lookup.time(), Some(5)); + assert_eq!(lookup.time(), 5); let found = lookup.accept(5, None); drop(lookup); let mut read = drain_groups(&mut subscriber); assert_eq!(read, [5], "the group found is read at once: its key is its start"); write_filled(found, 5); // The misses past the start, through the end. - while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) { - assert_eq!(fill.time(), None); + while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) { while let Some(key) = fill.wanted() { assert!(key >= 5, "group {key} is below the looked-up start"); write_filled(fill.accept(key, None), key); @@ -23014,14 +23028,14 @@ mod test { }])); let waiter = kio::Waiter::noop(); assert_eq!(drain_groups(&mut subscriber), Vec::::new()); - let Poll::Ready(Ok(lookup)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(Fill::Lookup(lookup))) = dynamic.poll_requested_fill(&waiter) else { panic!("the time start in the evicted gap is looked up"); }; - assert_eq!(lookup.time(), Some(5)); + assert_eq!(lookup.time(), 5); write_filled(lookup.accept(5, None), 5); drop(lookup); let mut read = drain_groups(&mut subscriber); - while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) { + while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) { while let Some(key) = fill.wanted() { write_filled(fill.accept(key, None), key); } @@ -23065,7 +23079,7 @@ mod test { None => ended = true, } } - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&kio::Waiter::noop()) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&kio::Waiter::noop()) else { break; }; while let Some(key) = fill.wanted() { @@ -23088,7 +23102,7 @@ mod test { write_group(&producer, 100); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; assert_eq!((fill.start().group, fill.end()), (0, 100)); @@ -23114,7 +23128,7 @@ mod test { write_group(&producer, 10); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = narrowed.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; narrowed.update(descending(Range::groups(0..8))).unwrap(); @@ -23122,7 +23136,7 @@ mod test { let mut later = producer.subscribe(descending(Range::groups(0..))); while let Poll::Ready(Ok(Some(_))) = later.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(again)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(again)) = dynamic.poll_requested_groups(&waiter) else { panic!("what the first fill stopped owing is asked afresh"); }; assert_eq!((again.start().group, again.end()), (8, 10)); @@ -23146,7 +23160,7 @@ mod test { let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} let mut asked = Vec::new(); - while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) { + while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) { asked.push((fill.start().group, fill.end())); } assert_eq!(asked, [(5, 6), (0, 2)]); @@ -23172,7 +23186,7 @@ mod test { evict(&producer, 0); evict(&producer, 1); assert_eq!(drain_groups(&mut subscriber), [2]); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("group 1 is a miss now"); }; assert_eq!((fill.start().group, fill.end()), (1, 2), "group 0 was taken"); @@ -23180,7 +23194,7 @@ mod test { write_filled(fill.accept(1, None), 1); drop(fill); assert_eq!(drain_groups(&mut subscriber), [1]); - assert!(dynamic.poll_requested_fill(&waiter).is_pending()); + assert!(dynamic.poll_requested_groups(&waiter).is_pending()); assert!(drained_drops(&mut subscriber).is_empty(), "nothing was given up"); let Inner::Plain(cursor) = &subscriber.inner else { unreachable!("a plain subscription"); @@ -23198,12 +23212,12 @@ mod test { let dynamic = producer.requests(); producer.received(); for key in 0..5 { - framed(&producer, key, 1).close().unwrap(); + framed(&producer, key, 1).finish().unwrap(); } producer.set_idle(); // The feed resumes at 8, above the cached 0..=4: its live floor is 5. producer.set_live(Some(Position::group(8)), None).unwrap(); - framed(&producer, 8, 1).close().unwrap(); + framed(&producer, 8, 1).finish().unwrap(); let mut reader = producer.subscribe( Subscription::default() .with_range(0..) @@ -23218,16 +23232,16 @@ mod test { assert_eq!(next(&mut reader), Some(0)); // The gap the feed may still deliver arrives late, so nothing is deferred after. for key in 5..8 { - framed(&producer, key, 1).close().unwrap(); + framed(&producer, key, 1).finish().unwrap(); } assert_eq!(next(&mut reader), Some(1)); // Only the newest group moves before this read: judged on its own. - framed(&producer, 9, 1).close().unwrap(); + framed(&producer, 9, 1).finish().unwrap(); assert_eq!(next(&mut reader), Some(2)); evict(&producer, 3); let _ = next(&mut reader); let mut asked = Vec::new(); - while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) { + while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) { asked.push((fill.start().group, fill.end())); } assert!( @@ -23309,7 +23323,7 @@ mod test { evict(&producer, 0); evict(&producer, 1); assert!(drained_drops(&mut subscriber).is_empty()); - assert!(dynamic.poll_requested_fill(&waiter).is_pending(), "both were taken"); + assert!(dynamic.poll_requested_groups(&waiter).is_pending(), "both were taken"); } /// An ordered reader waits on the refill of a group evicted at or above its next @@ -23332,7 +23346,7 @@ mod test { evict(&producer, 1); evict(&producer, 2); assert_eq!(next(&mut subscriber), None, "group 1 comes before 3"); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("groups 1 and 2 are misses now"); }; assert_eq!((fill.start().group, fill.end()), (1, 3)); @@ -23364,7 +23378,7 @@ mod test { evict(&producer, 1); evict(&producer, 2); assert_eq!(next(&mut subscriber), None, "group 1 comes before 3"); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("groups 1 and 2 are misses now"); }; write_filled(fill.accept(2, None), 2); @@ -23375,7 +23389,7 @@ mod test { write_filled(fill.accept(1, None), 1); drop(fill); assert_eq!([next(&mut subscriber), next(&mut subscriber)], [Some(1), Some(3)]); - assert!(dynamic.poll_requested_fill(&waiter).is_pending(), "refilled once"); + assert!(dynamic.poll_requested_groups(&waiter).is_pending(), "refilled once"); } /// A refill evicted again before its reader took it is given up rather than asked a @@ -23393,7 +23407,7 @@ mod test { assert!(matches!(subscriber.poll_recv_group(&waiter), Poll::Ready(Ok(Some(_))))); evict(&producer, 1); assert_eq!(drain_groups(&mut subscriber), [2]); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("group 1 is a miss now"); }; assert_eq!(fill.wanted(), Some(1)); @@ -23401,7 +23415,7 @@ mod test { drop(fill); evict(&producer, 1); assert!(drain_groups(&mut subscriber).is_empty()); - assert!(dynamic.poll_requested_fill(&waiter).is_pending(), "refilled once"); + assert!(dynamic.poll_requested_groups(&waiter).is_pending(), "refilled once"); assert_eq!(drained_drops(&mut subscriber), [(1, 2)]); } @@ -23419,13 +23433,13 @@ mod test { group .write_frame(Timestamp::from_millis(key).unwrap(), vec![0u8; size]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; let waiter = kio::Waiter::noop(); let mut refilled = 0; let mut fills = Vec::new(); let mut serve = || { - while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) { + while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) { fills.push(fill); } fills.retain_mut(|fill| { @@ -23521,13 +23535,13 @@ mod test { group .write_frame(Timestamp::from_millis(key).unwrap(), vec![0u8; size]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; producer.start_at(GROUPS).unwrap(); write(producer.create_group(group::Info { start: GROUPS }), GROUPS); let waiter = kio::Waiter::noop(); assert!(subscriber.poll_next_group(&waiter).is_pending(), "group 0 is a miss"); - let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the reader asked for the batch"); }; assert_eq!((fill.start().group, fill.end()), (0, GROUPS)); @@ -23563,7 +23577,7 @@ mod test { write_group(&producer, 4); let waiter = kio::Waiter::noop(); assert!(ordered.poll_next_group(&waiter).is_pending(), "group 0 is a miss"); - let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the reader asked for the batch"); }; assert_eq!(fill.order(), Order::Descending); @@ -23592,7 +23606,7 @@ mod test { write_group(&producer, 4); let waiter = kio::Waiter::noop(); assert!(subscriber.poll_next_group(&waiter).is_pending(), "group 0 is a miss"); - let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the reader asked for the batch"); }; assert_eq!(fill.poll_wanted_changed(&waiter), Poll::Ready(Some(0))); @@ -23627,14 +23641,14 @@ mod test { subscriber.poll_recv_group(&waiter).is_pending(), "groups 0..4 are a miss" ); - let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(mut fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the reader asked for the batch"); }; assert_eq!((fill.start().group, fill.end()), (0, 4)); let mut fetch = producer.consume().fetch_group(2, None); assert!(kio::Task::poll(&mut *fetch, &waiter).is_pending()); assert!( - dynamic.poll_requested_fill(&waiter).is_pending(), + dynamic.poll_requested_groups(&waiter).is_pending(), "the fetch joined the batch" ); @@ -23702,7 +23716,7 @@ mod test { write_group(&producer, 4); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = middle.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(taken)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(taken)) = dynamic.poll_requested_groups(&waiter) else { panic!("group 5 is a miss"); }; assert_eq!((taken.start().group, taken.end()), (5, 6)); @@ -23710,7 +23724,7 @@ mod test { let mut subscriber = producer.subscribe(replay().with_range(0..).with_order(Order::Descending)); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} let mut asked = Vec::new(); - while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) { + while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) { asked.push((fill.start().group, fill.end())); } assert_eq!(asked, [(6, 8), (0, 4)]); @@ -23724,7 +23738,7 @@ mod test { let waiter = kio::Waiter::noop(); assert!(drained_drops(&mut subscriber).is_empty()); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; fill.drop_groups(0..2); @@ -23745,7 +23759,7 @@ mod test { let (producer, dynamic, mut subscriber) = started_late(); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; fill.drop_groups(0..2); @@ -23771,7 +23785,7 @@ mod test { for key in [0, 1, 2, 4, 5] { write_group(&producer, key); } - producer.finish_at(Position::group(10), None).unwrap(); + producer.finish_at(Position::group(10)).unwrap(); assert_eq!(drain_groups(&mut subscriber), [0, 1, 2, 4, 5]); assert!(drained_drops(&mut subscriber).is_empty(), "group 3 may still arrive"); write_group(&producer, 3); @@ -23813,13 +23827,13 @@ mod test { elapse(&producer, Duration::from_secs(31)); assert_eq!(drained_drops(&mut subscriber), [(0, 2)]); assert!( - dynamic.poll_requested_fill(&waiter).is_pending(), + dynamic.poll_requested_groups(&waiter).is_pending(), "the miss asked nothing" ); let mut fetch = producer.consume().fetch_group(1, None); assert!(kio::Task::poll(&mut *fetch, &waiter).is_pending()); - let Poll::Ready(Ok(fill)) = dynamic.clone().poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.clone().poll_requested_groups(&waiter) else { panic!("the fetch is taken"); }; assert_eq!((fill.start().group, fill.end()), (1, 2)); @@ -23864,7 +23878,7 @@ mod test { write_group(&producer, WIDE); assert_eq!(drain_groups(&mut subscriber), [WIDE]); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&kio::Waiter::noop()) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&kio::Waiter::noop()) else { panic!("the miss below the start is asked"); }; for refused in 1..=REFUSED { @@ -23894,13 +23908,13 @@ mod test { let _ = ascending.poll_recv_group(&kio::Waiter::noop()); let _ = descending.poll_recv_group(&kio::Waiter::noop()); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&kio::Waiter::noop()) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&kio::Waiter::noop()) else { panic!("the miss below the start is asked"); }; assert_eq!((fill.start().group, fill.end()), (0, 4)); assert_eq!(fill.order(), Order::Descending); assert!( - dynamic.poll_requested_fill(&kio::Waiter::noop()).is_pending(), + dynamic.poll_requested_groups(&kio::Waiter::noop()).is_pending(), "both readers share the fill" ); } @@ -23917,7 +23931,7 @@ mod test { producer.start_at(6).unwrap(); write_group(&producer, 6); let _ = descending.poll_recv_group(&kio::Waiter::noop()); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&kio::Waiter::noop()) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&kio::Waiter::noop()) else { panic!("the miss below the start is asked"); }; assert_eq!(fill.order(), Order::Descending); @@ -23956,7 +23970,7 @@ mod test { subscriber.update(subscriber.subscription().with_priority(3)).unwrap(); assert!(subscriber.poll_recv_group(&waiter).is_pending()); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the miss below the start is asked"); }; assert_eq!((fill.start().group, fill.end()), (0, 4)); @@ -23994,7 +24008,7 @@ mod test { _ => panic!("the read ended"), }; assert_eq!(next(), None, "group 0 is being filled"); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("below the start is a miss"); }; write_filled(fill.accept(0, None), 0); @@ -24013,7 +24027,7 @@ mod test { let (producer, dynamic, mut subscriber) = started_late(); let waiter = kio::Waiter::noop(); while let Poll::Ready(Ok(Some(_))) = subscriber.poll_recv_group(&waiter) {} - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the gap is a miss"); }; drop(subscriber); @@ -24027,7 +24041,7 @@ mod test { let consumer = producer.consume(); let mut fetch = consumer.fetch_group(3, None); let waiter = kio::Waiter::noop(); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the fill is ready"); }; match drop_all { @@ -24098,7 +24112,7 @@ mod test { group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// Every group the subscriber hands out right now, in arrival order. @@ -24195,7 +24209,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// The wall clock forgets the gaps on an untimed track, which has no media time to @@ -24265,7 +24279,7 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } _ => write_group(&producer, key), @@ -24383,7 +24397,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(drain_groups(&mut subscriber), [key]); } assert_eq!(subscriber.delivered_runs(), 1000); @@ -24443,11 +24457,11 @@ mod test { let mut early = producer.subscribe(replay().with_ranges([Range::live()])); let _fetching = consumer.fetch_group(5, None); let req = dynamic.requested_fill_group().now_or_never().unwrap().unwrap(); - req.accept(None).unwrap().close().unwrap(); + req.accept(None).unwrap().finish().unwrap(); producer .create_group(group::Info { start: 0 }) .unwrap() - .close() + .finish() .unwrap(); let mut late = producer.subscribe(replay().with_ranges([Range::live()])); assert_eq!(drain(&mut early), vec![0]); @@ -24470,7 +24484,7 @@ mod test { group .write_frame(crate::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; write(10); elapse(&producer, cache::DEFAULT_EXPIRY + Duration::from_secs(1)); @@ -24551,7 +24565,7 @@ mod test { let mut producer = track_producer("test", Info::timed()); append_at(&mut producer, 1000); - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); let refused = group.write_frame(Timestamp::from_millis(500).unwrap(), &b"x"[..]); assert!(matches!(refused, Err(Error::TimestampMismatch)), "{refused:?}"); assert_eq!(group.frame_count(), 0); @@ -24580,19 +24594,19 @@ mod test { #[test] fn a_rewind_is_refused_whichever_group_lands_first() { let producer = track_producer("test", Info::timed()); - start_at_millis(&producer, 5, 1000).unwrap().close().unwrap(); + start_at_millis(&producer, 5, 1000).unwrap().finish().unwrap(); assert!(matches!( start_at_millis(&producer, 3, 2000), Err(Error::TimestampMismatch) )); - start_at_millis(&producer, 3, 500).unwrap().close().unwrap(); + start_at_millis(&producer, 3, 500).unwrap().finish().unwrap(); for millis in [400, 500, 1000] { assert!(matches!( start_at_millis(&producer, 4, millis), Err(Error::TimestampMismatch) )); } - start_at_millis(&producer, 4, 800).unwrap().close().unwrap(); + start_at_millis(&producer, 4, 800).unwrap().finish().unwrap(); } /// The batched and streamed writes check frame 0 the same way, before writing anything. @@ -24602,7 +24616,7 @@ mod test { append_at(&mut producer, 1000); let rewound = Timestamp::from_millis(500).unwrap(); - let mut batched = producer.append_next().unwrap(); + let mut batched = producer.append_group(None).unwrap(); let mut frames = frame::Buffer::<4>::new(); frames .push(frame::Frame::new(rewound, bytes::Bytes::from_static(b"x"))) @@ -24614,7 +24628,7 @@ mod test { assert_eq!(frames.len(), 1, "the batch is left to retry"); assert_eq!(batched.frame_count(), 0); - let streamed = producer.append_next().unwrap(); + let streamed = producer.append_group(None).unwrap(); let handle = streamed.handle(); let refused = streamed .create_frame(frame::Info { @@ -24632,8 +24646,8 @@ mod test { #[test] fn an_evicted_predecessor_still_bounds_a_delayed_stamp() { let producer = track_producer("test", Info::timed()); - start_at_millis(&producer, 0, 0).unwrap().close().unwrap(); - start_at_millis(&producer, 1, 1000).unwrap().close().unwrap(); + start_at_millis(&producer, 0, 0).unwrap().finish().unwrap(); + start_at_millis(&producer, 1, 1000).unwrap().finish().unwrap(); let mut delayed = producer.create_group(group::Info { start: 2 }).unwrap(); evict(&producer, 1); @@ -24651,7 +24665,7 @@ mod test { fn a_late_group_below_the_watermark_is_unverified() { let producer = track_producer("test", Info::timed()); for (key, millis) in [(0, 1000), (1, 2000), (2, 3000), (3, 4000)] { - start_at_millis(&producer, key, millis).unwrap().close().unwrap(); + start_at_millis(&producer, key, millis).unwrap().finish().unwrap(); } evict(&producer, 1); evict(&producer, 2); @@ -24668,7 +24682,7 @@ mod test { assert_eq!(late.handle().timestamp(), None, "nor drives media-time expiry"); // Group 2 really started before late group 1 claimed to. - start_at_millis(&producer, 2, 2500).unwrap().close().unwrap(); + start_at_millis(&producer, 2, 2500).unwrap().finish().unwrap(); } /// Subscribers may have seen an aborted group's start, so a replacement at its key @@ -24686,7 +24700,7 @@ mod test { start_at_millis(&producer, 1, 600), Err(Error::TimestampMismatch) )); - start_at_millis(&producer, 1, 1500).unwrap().close().unwrap(); + start_at_millis(&producer, 1, 1500).unwrap().finish().unwrap(); } /// A group received from past its first frame stamps a later frame, which may overlap @@ -24694,13 +24708,13 @@ mod test { #[test] fn a_resumed_partial_group_is_neither_checked_nor_a_bound() { let producer = track_producer("test", Info::timed()); - start_at_millis(&producer, 0, 1000).unwrap().close().unwrap(); + start_at_millis(&producer, 0, 1000).unwrap().finish().unwrap(); let mut partial = producer.create_group(group::Info { start: 1 }).unwrap(); partial.start_at(3).unwrap(); partial .write_frame(Timestamp::from_millis(2100).unwrap(), &b"x"[..]) .unwrap(); - start_at_millis(&producer, 2, 2000).unwrap().close().unwrap(); + start_at_millis(&producer, 2, 2000).unwrap().finish().unwrap(); } /// An untimed track has no timeline, so its groups land in any order. @@ -24871,7 +24885,7 @@ mod test { producer .create_group(group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } assert_eq!(drain(&mut narrow), vec![0, 1]); @@ -25064,7 +25078,7 @@ mod test { let waiter = kio::Waiter::noop(); assert_eq!(drain_groups(&mut subscriber), [3]); assert!( - dynamic.poll_requested_fill(&waiter).is_pending(), + dynamic.poll_requested_groups(&waiter).is_pending(), "the stale run settles the reader" ); @@ -25072,7 +25086,7 @@ mod test { .update(narrow.with_delay(Delay::default().with_max(Duration::from_secs(60)))) .unwrap(); assert!(subscriber.poll_next_group(&waiter).is_pending()); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the wider budget asks for the stale run"); }; assert_eq!((fill.start().group, fill.end()), (0, 3)); @@ -25098,7 +25112,7 @@ mod test { assert_eq!(drain_groups(&mut subscriber), [3]); for secs in [60, 120, 240] { assert!(subscriber.poll_drop(&waiter).is_pending()); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("a fill is asked under {secs}s"); }; assert_eq!((fill.start().group, fill.end()), (0, 3)); @@ -25109,7 +25123,7 @@ mod test { assert_eq!(subscriber.reoffer_stale(), [0..3]); } assert!(subscriber.poll_drop(&waiter).is_pending()); - assert!(matches!(dynamic.poll_requested_fill(&waiter), Poll::Ready(Ok(_)))); + assert!(matches!(dynamic.poll_requested_groups(&waiter), Poll::Ready(Ok(_)))); } /// A fill's OLD answer under the publisher's max age binds every reader, so the track holds @@ -25138,7 +25152,7 @@ mod test { // A reader of the run alone, which the verdict does not settle, waits on the same fill. let mut bounded = producer.subscribe(terms().with_ranges([Range::groups(0..3)])); assert!(drain_groups(&mut bounded).is_empty()); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("a fill is asked below the start"); }; fill.reject_groups(0..3, Error::Old); @@ -25149,7 +25163,7 @@ mod test { [(0, 3)], "the readers waiting now are refused" ); - assert!(dynamic.poll_requested_fill(&waiter).is_pending()); + assert!(dynamic.poll_requested_groups(&waiter).is_pending()); assert_eq!( producer.state.read().drops.get(&0), Some(&Hole::stale(max_age)), @@ -25160,7 +25174,7 @@ mod test { assert_eq!(drain_groups(&mut later), [3]); assert_eq!(drained_drops(&mut later), [(0, 3)]); assert!( - dynamic.poll_requested_fill(&waiter).is_pending(), + dynamic.poll_requested_groups(&waiter).is_pending(), "the verdict is not asked again" ); @@ -25168,7 +25182,7 @@ mod test { let mut again = producer.subscribe(terms()); assert_eq!(drain_groups(&mut again), [3]); assert!( - matches!(dynamic.poll_requested_fill(&waiter), Poll::Ready(Ok(_))), + matches!(dynamic.poll_requested_groups(&waiter), Poll::Ready(Ok(_))), "a forgotten verdict is asked again" ); } @@ -25193,7 +25207,7 @@ mod test { producer.supersede_stale(judged([(0, 2), (4, 6)])); producer.give_up(0..2, Hole::stale(budget)); producer.give_up(4..6, Hole::stale(budget)); - producer.create_group(3u64.into()).unwrap().close().unwrap(); + producer.create_group(3u64.into()).unwrap().finish().unwrap(); let mut subscriber = producer.subscribe( Subscription::default() .with_delay(Delay::default().with_max(budget)) @@ -25210,7 +25224,7 @@ mod test { matches!(subscriber.poll_recv_group(&waiter), Poll::Ready(Ok(None))), "nothing else is owed" ); - assert!(dynamic.poll_requested_fill(&waiter).is_pending(), "nothing is asked"); + assert!(dynamic.poll_requested_groups(&waiter).is_pending(), "nothing is asked"); } /// A reader whose ranges only partly overlap the ones a stale verdict was judged against @@ -25228,7 +25242,7 @@ mod test { producer.give_up(0..2, Hole::stale(budget)); producer.give_up(4..6, Hole::stale(budget)); // Held, so a time start at 4 names it. - producer.create_group(3u64.into()).unwrap().close().unwrap(); + producer.create_group(3u64.into()).unwrap().finish().unwrap(); let reader = |ranges: [Range; 2]| { producer.subscribe( Subscription::default() @@ -25243,7 +25257,7 @@ mod test { assert_eq!(wider.poll_drop(&waiter), Poll::Ready((0..2, Hole::stale(budget)))); assert_eq!(wider.poll_drop(&waiter), Poll::Ready((4..6, Hole::stale(budget)))); assert!(wider.poll_drop(&waiter).is_pending()); - assert!(dynamic.poll_requested_fill(&waiter).is_pending(), "nothing is asked"); + assert!(dynamic.poll_requested_groups(&waiter).is_pending(), "nothing is asked"); // Stops at 4, which the upstream judged against 5: its own newest, which no verdict // convicts. Both runs are unknown to it, and asked for. let mut narrower = reader([Range::groups(0..2), Range::groups(4..5)]); @@ -25254,7 +25268,7 @@ mod test { assert!(narrower.poll_recv_group(&waiter).is_pending()); assert!(narrower.poll_drop(&waiter).is_pending()); let mut asked = Vec::new(); - while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) { + while let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) { asked.push((fill.start().group, fill.end())); } asked.sort(); @@ -25285,7 +25299,7 @@ mod test { let waiter = kio::Waiter::noop(); let mut first = reader(); assert!(first.poll_recv_group(&waiter).is_pending()); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the unsettled stale run is asked for"); }; assert_eq!((fill.start().group, fill.end()), (0, 2)); @@ -25297,7 +25311,7 @@ mod test { group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } drop(fill); let mut late = reader(); @@ -25339,14 +25353,14 @@ mod test { write_group(&producer, 2); write_group(&producer, 5); write_group(&producer, 7); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); assert_eq!(subscriber.poll_drop(&waiter), Poll::Ready((3..5, Hole::Skip))); assert_eq!(subscriber.poll_drop(&waiter), Poll::Ready((6..7, Hole::Skip))); assert_eq!(drain_groups(&mut subscriber), [2, 5, 7, 8]); // The next append only names what was left since this one. write_group(&producer, 10); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); assert_eq!(subscriber.poll_drop(&waiter), Poll::Ready((9..10, Hole::Skip))); let skipped: Vec<_> = producer .state @@ -25367,7 +25381,7 @@ mod test { write_group(&producer, 0); write_group(&producer, 4); producer.give_up(1..2, Hole::drop(StreamError::Cancel)); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); let drops: Vec<_> = producer .state .read() @@ -25386,7 +25400,7 @@ mod test { let producer = track_producer("test", Info::timed()); write_group(&producer, 0); write_group(&producer, 3); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); assert!(matches!( producer.create_group(group::Info { start: 1 }), Err(Error::Skipped) @@ -25398,7 +25412,7 @@ mod test { Err(Error::Skipped) )); // The next key, 5, was skipped too. - assert!(matches!(producer.append_next(), Err(Error::Skipped))); + assert!(matches!(producer.append_group(None), Err(Error::Skipped))); // A later drop leaves a skipped key skipped. producer.give_up(1..2, Hole::drop(StreamError::Cancel)); assert!(matches!( @@ -25471,7 +25485,7 @@ mod test { write_group(&producer, 0); producer.drop_groups(1..2, StreamError::Old); write_group(&producer, 2); - producer.finish_at(Position::group(3), None).unwrap(); + producer.finish_at(Position::group(3)).unwrap(); drain_groups(&mut subscriber); let waiter = kio::Waiter::noop(); assert!(matches!(subscriber.poll_recv_group(&waiter), Poll::Ready(Ok(None)))); @@ -25495,7 +25509,7 @@ mod test { write_group(&producer, 0); producer.drop_groups(1..2, StreamError::Old); write_group(&producer, 2); - producer.finish_at(Position::group(3), None).unwrap(); + producer.finish_at(Position::group(3)).unwrap(); drain_groups(&mut subscriber); let waiter = kio::Waiter::noop(); assert!(matches!(subscriber.poll_recv_group(&waiter), Poll::Ready(Ok(None)))); @@ -25519,7 +25533,7 @@ mod test { #[cfg(feature = "async")] fn a_refined_end_stays_reached_after_its_drops_expire() { let (mut producer, _subscriber, _pool) = reached_then_expired(); - producer.finish_at(Position { group: 2, frame: 1 }, None).unwrap(); + producer.finish_at(Position { group: 2, frame: 1 }).unwrap(); let mut late = producer.subscribe(patient()); drain_groups(&mut late); assert!(matches!( @@ -25559,7 +25573,7 @@ mod test { }; assert_eq!(first.start, 0); assert!( - dynamic.poll_requested_fill(&waiter).is_pending(), + dynamic.poll_requested_groups(&waiter).is_pending(), "a dropped run asks no fill" ); @@ -25567,7 +25581,7 @@ mod test { pool.sweep(); assert!(producer.state.read().drops.is_empty(), "the run expired"); let _ = subscriber.poll_recv_group(&waiter); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&waiter) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&waiter) else { panic!("the forgotten run is asked of a fill"); }; assert_eq!(fill.start().group..fill.end(), 1..2); @@ -25586,7 +25600,7 @@ mod test { producer.start_at(START).unwrap(); write_group(&producer, START); assert_eq!(drain_groups(&mut subscriber), [START]); - let Poll::Ready(Ok(fill)) = dynamic.poll_requested_fill(&kio::Waiter::noop()) else { + let Poll::Ready(Ok(fill)) = dynamic.poll_requested_groups(&kio::Waiter::noop()) else { panic!("the miss below the start is asked"); }; // Nothing arrives once the feed ends, so a refusal is a verdict on the track. @@ -25711,7 +25725,7 @@ mod test { group .write_frame(Timestamp::from_millis(key).unwrap(), vec![0u8; 16 * 1024]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); match subscriber.poll_recv_group(&waiter) { Poll::Ready(Ok(Some(group))) => assert_eq!(group.start, key, "stale={stale}"), res => { @@ -25854,7 +25868,7 @@ mod test { group .write_frame(Timestamp::from_millis(1).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(replay().with_range(0..)); @@ -25870,7 +25884,7 @@ mod test { let mut subscriber = producer.subscribe(replay().with_range(0..)); write_group(&producer, 0); write_far(&producer); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); assert_eq!(producer.state.read().drops.iter().count(), 1); assert_eq!(subscriber.poll_drop(&waiter), Poll::Ready((1..FAR, Hole::Skip))); assert_eq!(drain_groups(&mut subscriber), [0, FAR, FAR + 1]); @@ -25886,7 +25900,7 @@ mod test { let group = producer.create_group(group::Info { start: 0 }).unwrap(); group.abort(Error::Stream(StreamError::Cancel)).unwrap(); write_group(&producer, 0); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); assert!(producer.state.read().drops.is_empty()); let mut read = drain_groups(&mut subscriber); read.dedup(); @@ -25957,7 +25971,7 @@ mod test { let producer = track_producer("test", Info::timed()); let mut subscriber = producer.subscribe(replay().with_range(0..)); write_group(&producer, 3); - producer.append_next().unwrap().close().unwrap(); + producer.append_group(None).unwrap().finish().unwrap(); assert!(producer.state.read().drops.is_empty()); assert!(drained_drops(&mut subscriber).is_empty()); } @@ -26127,7 +26141,7 @@ mod test { open.write_frame(open.key_time(), &b"a"[..]).unwrap(); let mut finished = producer.create_group(group::Info { start: 1 }).unwrap(); finished.write_frame(finished.key_time(), &b"b"[..]).unwrap(); - finished.close().unwrap(); + finished.finish().unwrap(); let mut held = subscriber.assert_group(); assert_eq!( @@ -26166,13 +26180,13 @@ mod test { live.start_at(1).unwrap(); live.write_frame(live.key_time(), &b"delta"[..]).unwrap(); let _fetch = consumer.fetch_group(0, None); - let fill = dynamic.requested_fill().await.unwrap(); + let fill = dynamic.requested_groups().await.unwrap(); let mut head = fill.accept(0, Info::timed()).unwrap(); head.write_frame(head.key_time(), &b"snapshot"[..]).unwrap(); producer.drop_groups(0..1, StreamError::App(5)); head.write_frame(head.key_time(), &b"delta"[..]).unwrap(); - head.close().unwrap(); + head.finish().unwrap(); let mut group = consumer.peek_group(0).expect("the head still serves group 0"); for payload in [&b"snapshot"[..], b"delta"] { @@ -26196,7 +26210,7 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); let _producer = producer.finish().unwrap(); @@ -26235,7 +26249,7 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); assert_eq!(subscriber.assert_group().start, 1, "{err:?}"); } @@ -26255,7 +26269,7 @@ mod test { producer .create_group(group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); let _live = producer.create_group(group::Info { start: 2 }).unwrap(); @@ -26292,7 +26306,7 @@ mod test { producer .create_group(group::Info { start: 0 }) .unwrap() - .close() + .finish() .unwrap(); let mut cut = producer.create_group(group::Info { start: 1 }).unwrap(); cut.write_frame(cut.key_time(), &b"a"[..]).unwrap(); @@ -26363,7 +26377,7 @@ mod test { partial .write_frame(Timestamp::from_millis(2500).unwrap(), bytes::Bytes::from_static(b"x")) .unwrap(); - partial.close().unwrap(); + partial.finish().unwrap(); let mut seek = producer.subscribe(replay().with_ranges([Range { start: Anchor::Time(2200), @@ -26428,7 +26442,7 @@ mod test { fn an_untimed_track_reads_time_anchors_as_keys() { let producer = untimed_producer(); for key in [0, 5, 10, 15] { - producer.append_group(key).unwrap().close().unwrap(); + producer.append_group(key).unwrap().finish().unwrap(); } let mut subscriber = producer.subscribe(replay().with_ranges([Range { start: Anchor::Time(7), @@ -26665,7 +26679,7 @@ mod test { for frame in start..end { tail.write_frame(tail.key_time(), vec![frame as u8; size]).unwrap(); } - let tail = tail.close().unwrap(); + let tail = tail.finish().unwrap(); deliveries.push(tail.handle()); held.push(pending.await.unwrap()); } @@ -26742,7 +26756,7 @@ mod test { ) .unwrap(); tail.write_frame(tail.key_time(), vec![start as u8; 4]).unwrap(); - let tail = tail.close().unwrap(); + let tail = tail.finish().unwrap(); held.push(tail.consume().with_range(start..)); tails.push(tail); } @@ -26768,7 +26782,7 @@ mod test { .unwrap(); assert!(Arc::ptr_eq(&owner, &refill.handle().content().unwrap())); refill.write_frame(refill.key_time(), b"zero".as_slice()).unwrap(); - let refill = refill.close().unwrap(); + let refill = refill.finish().unwrap(); refill.abort(Error::Cancel).unwrap(); let mut recreated = producer.create_group(group::Info { start: 0 }).unwrap(); recreated.start_at(8).unwrap(); @@ -26845,7 +26859,7 @@ mod test { assert!(budget.reserve(1).is_none(), "the survivor still holds admission"); second.write(vec![4; 768]).unwrap(); let second = second.finish().unwrap(); - second.close().unwrap(); + second.finish().unwrap(); assert!(matches!(streaming.read_chunk().await, Err(Error::Cancel))); let frame = second_read.read_frame().await.unwrap().unwrap(); assert_eq!(frame.payload.as_ref(), &[4; 1024]); @@ -26857,7 +26871,7 @@ mod test { } else { second.write(vec![4; 768]).unwrap(); let second = second.finish().unwrap(); - second.close().unwrap(); + second.finish().unwrap(); let later_copy = second_read.read_frame().await.unwrap().unwrap(); assert!( budget.reserve(1).is_none(), @@ -26868,7 +26882,7 @@ mod test { kio::clock::sim::advance(Duration::from_millis(10)).await; first.write(vec![4; 512]).unwrap(); let first = first.finish().unwrap(); - let first = first.close().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()), @@ -26940,7 +26954,7 @@ mod test { properties: Default::default(), }) .unwrap(); - let head = head.close().unwrap(); + let head = head.finish().unwrap(); let earlier = producer .state .write() @@ -26951,7 +26965,7 @@ mod test { earlier.set_wire(wire(90)).unwrap(); let earlier = write(earlier, 90, b"b"); let earlier = write(earlier, 95, b"c"); - let earlier = earlier.close().unwrap(); + let earlier = earlier.finish().unwrap(); assert!(head.consume().end_object().is_some_and(|fields| fields.id == 101)); assert!( earlier.consume().end_object().is_none(), @@ -27036,7 +27050,7 @@ mod test { for payload in &expected { source.write_frame(source.key_time(), payload.clone()).unwrap(); } - let source = source.close().unwrap(); + let source = source.finish().unwrap(); let mut stored = arrayvec::ArrayVec::::new(); assert!(matches!( source @@ -27079,7 +27093,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]); - let head = head.close().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(); @@ -27165,7 +27179,7 @@ mod test { .insert_group_request(0, group::Bounds { start: 3, end: Some(4) }, None) .unwrap(); head.write_frame(head.key_time(), b"three".as_slice()).unwrap(); - head.close().unwrap(); + head.finish().unwrap(); let identity = Arc::downgrade(&observing.content().unwrap()); producer .state @@ -27199,7 +27213,7 @@ mod test { .unwrap(); refill.write(vec![4; 1024]).unwrap(); let refill = refill.finish().unwrap(); - let refill = refill.close().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, @@ -27228,7 +27242,7 @@ mod test { .insert_group_request(0, group::Bounds { start: 0, end: Some(1) }, None) .unwrap(); head.write_frame(head.key_time(), bytes::Bytes::new()).unwrap(); - let head = head.close().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); @@ -27276,7 +27290,7 @@ mod test { "test", Info::default().with_refresh(1_000_000), ); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); for index in 0..1_000 { live.write_frame(crate::Timestamp::unscaled(live.start), numbered(index)) .unwrap(); @@ -27301,7 +27315,7 @@ mod test { ); // Joined before the group grew, so the join asks for nothing. let _subscriber = producer.subscribe(None); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); let mut reader = live.consume(); for index in 0..1_000 { live.write_frame(crate::Timestamp::unscaled(live.start), numbered(index)) @@ -27335,7 +27349,7 @@ mod test { fn a_late_joiner_rides_a_flight_and_hands_over() { let producer = track_producer("test", Info::default()); let requests = producer.requests(); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); let mut reader = live.consume(); let mut late = live.consume(); // 48 MiB, half again the live tail. @@ -27348,7 +27362,7 @@ mod test { // Frame 0 was shed: the late reader asks the handler for a flight from it. assert_eq!(read_numbered(&mut late), None); - let fill = match requests.poll_requested_fill(&kio::Waiter::noop()) { + let fill = match requests.poll_requested_groups(&kio::Waiter::noop()) { Poll::Ready(fill) => fill.unwrap(), Poll::Pending => panic!("a flight is asked"), }; @@ -27399,7 +27413,7 @@ mod test { fn a_compressed_flight_starts_at_frame_0_and_its_rider_skips_ahead() { let producer = track_producer("test", Info::default().with_compression(Compression::Deflate)); let requests = producer.requests(); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); let mut reader = live.consume(); let mut behind = live.consume(); const FRAMES: u32 = 3_000; @@ -27460,7 +27474,7 @@ mod test { fn shed_live_group(frames: u32) -> (Producer, Requests, group::Producer, group::Consumer) { let producer = track_producer("test", Info::default()); let requests = producer.requests(); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); let mut reader = live.consume(); for index in 0..frames { live.write_frame(crate::Timestamp::unscaled(live.start), numbered(index)) @@ -27472,8 +27486,8 @@ mod test { /// The next fill asked of `requests`, if any. #[cfg(feature = "async")] - fn asked(requests: &Requests) -> Option { - match requests.poll_requested_fill(&kio::Waiter::noop()) { + fn asked(requests: &Requests) -> Option { + match requests.poll_requested_groups(&kio::Waiter::noop()) { Poll::Ready(fill) => Some(fill.unwrap()), Poll::Pending => None, } @@ -27535,7 +27549,7 @@ mod test { Info::default(), ); let requests = producer.requests(); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); let mut late = live.consume(); for index in 0..1_000 { live.write_frame(crate::Timestamp::unscaled(live.start), numbered(index)) @@ -27561,7 +27575,7 @@ mod test { let producer = track_producer("test", Info::timed()); let requests = producer.requests(); let mut sub = producer.subscribe(None); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); for index in 0..3_000u32 { let at = Timestamp::from_millis(index.into()).unwrap(); live.write_frame(at, numbered(index)).unwrap(); @@ -27569,7 +27583,7 @@ mod test { let mut late = sub.recv_group().now_or_never().unwrap().unwrap().expect("group 0"); assert!(late.read_frame().now_or_never().is_none(), "boarding"); let _flight = asked(&requests).expect("a flight, never answered"); - let mut newer = producer.append_next().unwrap(); + let mut newer = producer.append_group(None).unwrap(); newer .write_frame(Timestamp::from_millis(100_000).unwrap(), numbered(0)) .unwrap(); @@ -27591,7 +27605,7 @@ mod test { .with_delay(Delay::default().with_max(budget)) .with_order(Order::Descending), ); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); for index in 0..3_000u32 { live.write_frame(crate::Timestamp::unscaled(live.start), numbered(index)) .unwrap(); @@ -27631,7 +27645,7 @@ mod test { producer.subscribe(Subscription::default().with_delay(delay)) }; let (mut tight, mut loose) = (subscribe(1), subscribe(10)); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); for index in 0..3_000u32 { live.write_frame(crate::Timestamp::unscaled(live.start), numbered(index)) .unwrap(); @@ -27675,7 +27689,7 @@ mod test { Info::default(), ); let requests = producer.requests(); - let mut old = producer.append_next().unwrap(); + let mut old = producer.append_group(None).unwrap(); let mut late = old.consume(); for index in 0..1_000 { old.write_frame(crate::Timestamp::unscaled(old.start), numbered(index)) @@ -27685,7 +27699,7 @@ mod test { let mut flight = asked(&requests).expect("a flight").accept(0, None).unwrap(); assert_eq!(read_numbered(&mut late), None); // A newer group leaves group 0 cold, and its cached copy goes whole. - let mut newer = producer.append_next().unwrap(); + let mut newer = producer.append_group(None).unwrap(); for index in 0..1_000 { newer .write_frame(crate::Timestamp::unscaled(newer.start), numbered(index)) @@ -27713,7 +27727,7 @@ mod test { let requests = producer.requests(); // Joined before the group grew, so the join asks for nothing. let _subscriber = producer.subscribe(None); - let mut live = producer.append_next().unwrap(); + let mut live = producer.append_group(None).unwrap(); let mut late = live.consume(); for index in 0..3_000 { live.write_frame(crate::Timestamp::unscaled(live.start), numbered(index)) @@ -27843,7 +27857,7 @@ mod test { #[test] fn a_read_with_more_to_come_parks() { let producer = track_producer("test", Info::timed()); - producer.create_group(0u64.into()).unwrap().close().unwrap(); + producer.create_group(0u64.into()).unwrap().finish().unwrap(); let mut open = producer.subscribe(replay().with_range(0..)); assert_eq!(read_now(&mut open, false), Some(Some(0))); @@ -27856,7 +27870,7 @@ mod test { let mut owed = producer.subscribe(replay().with_range(0..2)); assert_eq!(read_now(&mut owed, false), Some(Some(0))); assert_eq!(read_now(&mut owed, false), None, "group 1 may still arrive"); - producer.create_group(1u64.into()).unwrap().close().unwrap(); + producer.create_group(1u64.into()).unwrap().finish().unwrap(); assert_eq!(read_now(&mut owed, false), Some(Some(1))); assert_eq!(read_now(&mut owed, false), Some(None)); } @@ -27867,7 +27881,7 @@ mod test { fn a_bounded_read_ends_past_dropped_and_stale_groups() { let producer = track_producer("test", Info::timed()); let mut dropped = producer.subscribe(replay().with_range(0..2)); - producer.create_group(0u64.into()).unwrap().close().unwrap(); + producer.create_group(0u64.into()).unwrap().finish().unwrap(); assert_eq!(read_now(&mut dropped, false), Some(Some(0))); assert_eq!(read_now(&mut dropped, false), None); producer.drop_groups(1..2, StreamError::NotFound); @@ -27884,7 +27898,7 @@ mod test { .write_frame(Timestamp::from_millis(*at).unwrap(), bytes::Bytes::from_static(b"f")) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } let mut stale = producer.subscribe( Subscription::default() @@ -27903,7 +27917,7 @@ mod test { #[test] fn a_parked_bounded_read_waits_past_its_end() { let producer = track_producer("test", Info::timed()); - producer.create_group(0u64.into()).unwrap().close().unwrap(); + producer.create_group(0u64.into()).unwrap().finish().unwrap(); let mut reader = producer.subscribe(replay().with_range(0..1)).parked(); assert_eq!(read_now(&mut reader, false), Some(Some(0))); assert_eq!(read_now(&mut reader, false), None); @@ -27917,8 +27931,8 @@ mod test { // A received copy, whose missing groups may still arrive. producer.received(); let dynamic = producer.requests(); - producer.create_group(0u64.into()).unwrap().close().unwrap(); - producer.create_group(2u64.into()).unwrap().close().unwrap(); + producer.create_group(0u64.into()).unwrap().finish().unwrap(); + producer.create_group(2u64.into()).unwrap().finish().unwrap(); let producer = producer.finish().unwrap(); // From group 0, which a time start names without a lookup, through the hole at 1. let mut reader = producer.subscribe(replay().with_order(Order::Ascending).with_range(0..2)); @@ -27934,7 +27948,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"filled")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(read_now(&mut reader, false), Some(Some(1))); assert_eq!(read_now(&mut reader, false), Some(None)); } @@ -27948,7 +27962,7 @@ mod test { async fn a_hole_below_an_undeclared_start_is_asked_after_a_bounded_grace() { let (producer, _pool) = pooled_producer(1 << 40); let dynamic = producer.requests(); - producer.create_group(10u64.into()).unwrap().close().unwrap(); + producer.create_group(10u64.into()).unwrap().finish().unwrap(); let mut reader = producer.subscribe( Subscription::default() .with_delay(crate::track::Delay::default().with_max(None)) @@ -27969,7 +27983,7 @@ mod test { // With no fill handler, the hole is given up once the grace passed. let (producer, _pool) = pooled_producer(1 << 40); - producer.create_group(10u64.into()).unwrap().close().unwrap(); + producer.create_group(10u64.into()).unwrap().finish().unwrap(); let mut reader = producer.subscribe( Subscription::default() .with_delay(crate::track::Delay::default().with_max(None)) @@ -27993,7 +28007,7 @@ mod test { } let dynamic = producer.requests(); producer.start_at(10).unwrap(); - producer.create_group(10u64.into()).unwrap().close().unwrap(); + producer.create_group(10u64.into()).unwrap().finish().unwrap(); let mut reader = producer.subscribe( Subscription::default() .with_delay(crate::track::Delay::default().with_max(None)) @@ -28029,14 +28043,14 @@ mod test { let mut reader = producer.subscribe(replay().with_order(Order::Ascending).with_range(0..2)); assert_eq!(read_now(&mut reader, false), None); assert!( - dynamic.requested_fill().now_or_never().is_none(), + dynamic.requested_groups().now_or_never().is_none(), "an idle copy a feed may still answer asks nothing" ); producer.set_unfed(true); assert_eq!(read_now(&mut reader, false), None, "the fill is out"); let fill = dynamic - .requested_fill() + .requested_groups() .now_or_never() .expect("the holes are asked at once") .unwrap(); @@ -28045,7 +28059,7 @@ mod test { group .write_frame(group.key_time(), bytes::Bytes::from_static(b"filled")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); fill.refuse_groups(1..2, Error::Unsupported); assert_eq!(read_now(&mut reader, false), Some(Some(0))); assert_eq!(read_now(&mut reader, false), Some(None), "the refusal is final"); @@ -28089,7 +28103,7 @@ mod test { .write_frame(Timestamp::from_millis(at).unwrap(), bytes::Bytes::from_static(b"f")) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } assert_eq!(read_now(&mut reader, false), Some(Some(2 * round + 1)), "round {round}"); assert!( @@ -28120,7 +28134,7 @@ mod test { .write_frame(Timestamp::from_millis(*at).unwrap(), bytes::Bytes::from_static(b"f")) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } assert_eq!(read_now(&mut reader, false), Some(Some(1)), "evict: {evict}"); reader @@ -28142,7 +28156,7 @@ mod test { async fn an_unfillable_hole_below_the_start_wakes_its_reader() { let (mut producer, _pool) = pooled_producer(1 << 40); producer.start_at(10).unwrap(); - producer.create_group(10u64.into()).unwrap().close().unwrap(); + producer.create_group(10u64.into()).unwrap().finish().unwrap(); let mut reader = producer.subscribe( Subscription::default() .with_delay(crate::track::Delay::default().with_max(None)) diff --git a/rs/moq-net/src/model/track/fill.rs b/rs/moq-net/src/model/track/fill.rs index 94be67cbedb..fab777aefc5 100644 --- a/rs/moq-net/src/model/track/fill.rs +++ b/rs/moq-net/src/model/track/fill.rs @@ -2,8 +2,8 @@ //! //! A miss is a key a reader wants that the cache doesn't hold and the live feed will //! never deliver. A reader joins the fill already covering it, or queues a new one, and a -//! handler serves each fill it takes as one bounded run: [`Fill::accept`] for each group it -//! has, [`Fill::drop_groups`] for the rest. +//! handler serves each fill it takes as one bounded run: [`FillGroups::accept`] for each group it +//! has, [`FillGroups::drop_groups`] for the rest. //! //! A fill serves under what its readers ask now: a reader changing its priority, budget, or //! order moves every fill it waits on, queued or taken. Only the first group's start frame @@ -60,7 +60,7 @@ struct Pending { // How many joins still read each key: one a reader narrowed away is no longer owed. wants: RangeMap, // What its handler accepted that no join has picked up yet, which holds back the next - // group: see [`Fill::poll_wanted_changed`]. + // group: see [`FillGroups::poll_wanted_changed`]. unseen: RangeSet, // Readers hold consumers, so it counts the fill's demand; the handler's copy says what // became of each key. @@ -830,14 +830,14 @@ pub(super) fn poll_requested( start, end, frame_end, - time, flight, asks, result, }; - return Poll::Ready(Ok(Fill { - inner: Arc::new(SendCell::new(inner)), - prev: None, + let inner = Arc::new(SendCell::new(inner)); + return Poll::Ready(Ok(match time { + Some(time) => Fill::Lookup(FillLookup { inner, time }), + None => Fill::Groups(FillGroups { inner, prev: None }), })); } @@ -852,6 +852,15 @@ pub(super) fn poll_requested( } } +/// What readers ask a [`Requests`](super::Requests) handler for: a run of groups to serve, or a +/// time to look up. +pub enum Fill { + /// Groups readers miss. + Groups(FillGroups), + /// A time a reader's range starts at that no cached group resolves. + Lookup(FillLookup), +} + /// A run of groups readers miss, for a [`Requests`](super::Requests) handler to serve. /// /// It names `start.group` up to the exclusive [`end`](Self::end), the first group from @@ -870,7 +879,7 @@ pub(super) fn poll_requested( /// A clone serves the same fill, and the fill is settled once the last clone drops. Each /// clone watches on its own, so its first [`poll_wanted_changed`](Self::poll_wanted_changed) /// reports the current value. -pub struct Fill { +pub struct FillGroups { // Its track state reaches every group of the track, so the cell proves `Send` once // here instead of inside every session machine holding a fill. inner: Arc>, @@ -878,7 +887,7 @@ pub struct Fill { prev: Option>, } -impl Clone for Fill { +impl Clone for FillGroups { fn clone(&self) -> Self { Self { inner: self.inner.clone(), @@ -887,7 +896,7 @@ impl Clone for Fill { } } -/// The state a [`Fill`] and its per-group handles share. The last one dropping settles what +/// The state a fill and its per-group handles share. The last one dropping settles what /// was left. struct Inner { state: kio::Producer, @@ -897,14 +906,61 @@ struct Inner { end: u64, // Exclusive frame cap in the last group; None asks through the original end. frame_end: Option, - time: Option, // Answered with a copy of its own rather than the cache's; see [`FillState::fly`]. flight: bool, asks: kio::Shared, result: kio::Producer, } -impl Fill { +/// A time a reader's range starts at that no group the cache holds resolves, for a +/// [`Requests`](super::Requests) handler to look up: [`accept`](Self::accept) the group +/// containing it, the newest one starting at or before it, or the oldest group when every group +/// starts after it. The reader's range then starts there. +/// +/// A lookup owes no group, so it waits only on its first accept. Dropped unanswered, as a +/// handler that can't resolve times does, the reader's range reaches back to the newest group +/// the cache holds at or before the time, or, with none, reads every group the cache holds and +/// asks none starting before the time. +pub struct FillLookup { + inner: Arc>, + time: u64, +} + +impl FillLookup { + /// The time to look up, in the track's timescale (a bare start on a scale-less track). + pub fn time(&self) -> u64 { + self.time + } + + /// The most urgent delivery priority among the readers waiting on it now. + pub fn priority(&self) -> i8 { + self.inner.asks.read().priority() + } + + /// The most tolerant age budget among the readers waiting on it now, or `None` for the + /// publisher's max age alone. Each reader still enforces its own. + pub fn max_delay(&self) -> Option { + self.inner.max_delay() + } + + /// Insert group `key`, the one containing [`time`](Self::time), into the track's cache, + /// handing it to the readers waiting on the lookup, and return a [`group::Producer`] to fill. + /// + /// `info` sets the track's [`Info`] if it hasn't been accepted yet, and is ignored otherwise. + /// Errors with [`Error::Duplicate`] if the group was already answered or cached, + /// [`Error::Skipped`] if the track skipped it, or the track's abort error. + pub fn accept(&self, key: u64, info: impl Into>) -> Result { + self.inner.accept(key, info.into()) + } + + /// The groups the answer may lie in, which a test checks the lookup was asked over. + #[cfg(all(test, feature = "async"))] + pub(crate) fn span(&self) -> ops::Range { + self.inner.start.group..self.inner.end + } +} + +impl FillGroups { /// The first group to fill, and the frame within it to start from. pub fn start(&self) -> Position { self.inner.start @@ -934,22 +990,6 @@ impl Fill { self.inner.end } - /// The time a reader's range starts at that no group the cache holds resolves, in the - /// track's timescale (a bare start on a scale-less track), so this fill looks it up: - /// [`accept`](Self::accept) the group containing it, the newest one starting at or before - /// it, or the oldest group when every group starts after it. The reader's range then - /// starts there. - /// - /// A lookup owes no group, so [`wanted`](Self::wanted) is `None` and - /// [`is_wanted`](Self::is_wanted) false throughout; it waits only on its first accept. - /// Dropped unanswered, as a handler that can't resolve times does, the reader's range - /// reaches back to the newest group the cache holds at or before the time, or, with none, - /// reads every group the cache holds and asks none starting before the time. `None` for - /// a fill of groups. - pub fn time(&self) -> Option { - self.inner.time - } - /// The most urgent delivery priority among the readers waiting on it now. pub fn priority(&self) -> i8 { self.inner.asks.read().priority() @@ -1571,7 +1611,7 @@ impl Readers { } } -/// One group of a [`Fill`], for a session serving it a group at a time. Answering it answers +/// One group of a [`FillGroups`], for a session serving it a group at a time. Answering it answers /// that group of the fill; dropping it unanswered leaves the group to the fill. #[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))] pub(crate) struct GroupFill { @@ -1616,7 +1656,7 @@ impl GroupFill { self.inner.accept_from(self.key, Some(info), frames) } - /// Poll until no reader waits on this group, as [`Fill::poll_unwanted`]. + /// Poll until no reader waits on this group, as [`FillGroups::poll_unwanted`]. pub(crate) fn poll_unwanted(&self, waiter: &kio::Waiter) -> Poll<()> { self.inner.poll_unwanted(self.key, waiter) } @@ -1638,7 +1678,7 @@ impl GroupFill { } } - /// Insert the group into the cache, as [`Fill::accept`]. + /// Insert the group into the cache, as [`FillGroups::accept`]. #[cfg(test)] pub(crate) fn accept(self, info: impl Into>) -> Result { self.inner.accept(self.key, info.into()) diff --git a/rs/moq-net/src/model/track/miss.rs b/rs/moq-net/src/model/track/miss.rs index 12d9d559188..f8e6497386e 100644 --- a/rs/moq-net/src/model/track/miss.rs +++ b/rs/moq-net/src/model/track/miss.rs @@ -1669,7 +1669,7 @@ mod tests { track .create_group(crate::group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } let requests = handled.then(|| track.requests()); @@ -1730,7 +1730,7 @@ mod tests { track .create_group(crate::group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } track.start_at(3).unwrap(); @@ -1804,7 +1804,7 @@ mod tests { track .create_group(crate::group::Info { start: 2 }) .unwrap() - .close() + .finish() .unwrap(); let state = track.state.read(); assert!(state.drops.is_empty(), "recreation removed the last drop run"); @@ -1875,7 +1875,7 @@ mod tests { track .create_group(crate::group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } track.start_at(3).unwrap(); @@ -1952,7 +1952,7 @@ mod tests { track .create_group(crate::group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } let mut misses = Misses::default(); @@ -2003,7 +2003,7 @@ mod tests { track .create_group(crate::group::Info { start: 1 }) .unwrap() - .close() + .finish() .unwrap(); let state = track.state.read(); assert!( @@ -2089,7 +2089,7 @@ mod tests { track .create_group(crate::group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } let mut misses = Misses::default(); @@ -2147,7 +2147,7 @@ mod tests { track .create_group(crate::group::Info { start: 4 }) .unwrap() - .close() + .finish() .unwrap(); let state = track.state.read(); let opened = state.cache.pool().now_wall(); @@ -2353,7 +2353,7 @@ mod tests { track .create_group(crate::group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } if next(2) == 0 { @@ -2456,7 +2456,7 @@ mod tests { track .create_group(crate::group::Info { start: key }) .unwrap() - .close() + .finish() .unwrap(); } // Four groups below where the feed starts, 1, 3, 5, and 7, each a fill of its own. @@ -2483,7 +2483,7 @@ mod tests { ); // One fill answers: only its join is looked at again, and the later task wakes. - let fill = std::future::poll_fn(|cx| requests.poll_requested_fill(&kio::Waiter::new(cx.waker().clone()))) + let fill = std::future::poll_fn(|cx| requests.poll_requested_groups(&kio::Waiter::new(cx.waker().clone()))) .await .unwrap(); let woken = second.0.load(Ordering::Relaxed); @@ -2532,7 +2532,7 @@ mod tests { track .create_group(crate::group::Info { start: 8 }) .unwrap() - .close() + .finish() .unwrap(); let track = track.finish().unwrap(); // Group 0 lies below where the feed starts: only a fill may deliver it. @@ -2560,7 +2560,7 @@ mod tests { "a no-op poll leaves the real registrations in place" ); - let fill = std::future::poll_fn(|cx| requests.poll_requested_fill(&kio::Waiter::new(cx.waker().clone()))) + let fill = std::future::poll_fn(|cx| requests.poll_requested_groups(&kio::Waiter::new(cx.waker().clone()))) .await .unwrap(); let (read_woken, drops_woken) = (read.0.load(Ordering::Relaxed), drops.0.load(Ordering::Relaxed)); diff --git a/rs/moq-net/src/reconnect/tests.rs b/rs/moq-net/src/reconnect/tests.rs index c1473c08ebe..a4d9899997c 100644 --- a/rs/moq-net/src/reconnect/tests.rs +++ b/rs/moq-net/src/reconnect/tests.rs @@ -1104,9 +1104,9 @@ async fn busy_handshake() -> (Session, Session, Vec>) { .await .expect("the broadcast resolves") .unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(crate::Timestamp::ZERO, b"live".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); sub.recv_group().await.unwrap().expect("the track ended"); ( diff --git a/rs/moq-net/src/recv.rs b/rs/moq-net/src/recv.rs index a475e6f77c2..9ab2f64d857 100644 --- a/rs/moq-net/src/recv.rs +++ b/rs/moq-net/src/recv.rs @@ -99,7 +99,7 @@ impl Group { /// Finish receiving without running cancellation cleanup. pub fn finish(mut self) -> Result<(), Error> { - self.writer.take().expect("group owned until consumed").close()?; + self.writer.take().expect("group owned until consumed").finish()?; self.armed = false; Ok(()) } diff --git a/rs/moq-net/src/session/tests.rs b/rs/moq-net/src/session/tests.rs index 7683e18f3ff..21d947c7eb0 100644 --- a/rs/moq-net/src/session/tests.rs +++ b/rs/moq-net/src/session/tests.rs @@ -119,9 +119,9 @@ async fn a_subscription_keeps_both_ends_busy() { "{version}: an announcement kept the subscriber busy" ); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(Timestamp::ZERO, b"live".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut sub = kio::clock::timeout(TIMEOUT, remote.track("video").unwrap().subscribe(None)) .await .expect("subscribe timeout") @@ -161,7 +161,7 @@ async fn a_fetch_keeps_both_ends_busy() { broadcast: _broadcast, } = setup(version).await; - let mut writing = track.append_next().unwrap(); + let mut writing = track.append_group(None).unwrap(); writing.write_frame(Timestamp::ZERO, b"first".as_ref()).unwrap(); let fetching = remote.track("video").unwrap(); let fetch = kio::clock::sim::spawn(async move { @@ -178,7 +178,7 @@ async fn a_fetch_keeps_both_ends_busy() { assert!(!idle(&pair.server), "{version}: idle while a fetch is in flight"); writing.write_frame(Timestamp::ZERO, b"last".as_ref()).unwrap(); - writing.close().unwrap(); + writing.finish().unwrap(); let frames = kio::clock::timeout(TIMEOUT, fetch) .await .expect("fetch timeout") diff --git a/rs/moq-net/tests/group_charge.rs b/rs/moq-net/tests/group_charge.rs index 5b7275ab6c6..83d8fbb6324 100644 --- a/rs/moq-net/tests/group_charge.rs +++ b/rs/moq-net/tests/group_charge.rs @@ -75,7 +75,7 @@ fn measure(frames: usize, payload: usize) -> (usize, u64) { // any lazy statics aren't billed to the groups. let mut group = track.append_group(0).unwrap(); group.write_frame(Timestamp::ZERO, vec![0u8; payload]).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let before_heap = LIVE.with(Cell::get); let before_charge = pool.used(); @@ -86,7 +86,7 @@ fn measure(frames: usize, payload: usize) -> (usize, u64) { for _ in 0..frames { group.write_frame(timestamp, vec![0u8; payload]).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } let heap = (LIVE.with(Cell::get) - before_heap) / GROUPS; diff --git a/rs/moq-net/tests/integration/announce_to_serve.rs b/rs/moq-net/tests/integration/announce_to_serve.rs index 22e93156f15..450cf5f1e52 100644 --- a/rs/moq-net/tests/integration/announce_to_serve.rs +++ b/rs/moq-net/tests/integration/announce_to_serve.rs @@ -11,7 +11,6 @@ //! is a virtual sleep. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -114,9 +113,9 @@ async fn next(rx: &mut mpsc::UnboundedReceiver) -> String { } fn write_group(track: &moq_net::track::Producer, payload: &'static str) { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload.as_bytes()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// Walk one broadcast through its whole announce lifecycle and record what the diff --git a/rs/moq-net/tests/integration/answer_behind_cache.rs b/rs/moq-net/tests/integration/answer_behind_cache.rs index b9d1dcbea3f..b235c2ae882 100644 --- a/rs/moq-net/tests/integration/answer_behind_cache.rs +++ b/rs/moq-net/tests/integration/answer_behind_cache.rs @@ -24,7 +24,7 @@ fn write_group(track: &track::Producer, payload: &'static [u8]) { group .write_frame(moq_net::Timestamp::unscaled(group.start), payload) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// The next group `subscriber` receives, with its first frame. @@ -160,7 +160,7 @@ async fn a_reset_newest_group_answers_the_group_before(version: &str) { .unwrap() .unwrap(); assert_eq!(next_group(&mut subscriber).await.unwrap(), (0, b"0a".to_vec())); - g0.close().unwrap(); + g0.finish().unwrap(); let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); g1.write_frame(moq_net::Timestamp::unscaled(g1.start), &b"1a"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/auth.rs b/rs/moq-net/tests/integration/auth.rs index 91a70d96bee..1425a969d0d 100644 --- a/rs/moq-net/tests/integration/auth.rs +++ b/rs/moq-net/tests/integration/auth.rs @@ -5,7 +5,6 @@ //! moq-transport carries tokens only on the requests that name them. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -1247,7 +1246,7 @@ async fn exact_and_subtree_grants_admit_their_broadcast(version: &'static str) { }) .await; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::from_millis(0).unwrap(), b"frame".as_ref()) .unwrap(); @@ -1326,7 +1325,7 @@ async fn a_live_subscription_survives_union_renewal(version: &'static str) { .await .unwrap() .unwrap(); - let mut group = published.append_next().unwrap(); + let mut group = published.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::from_millis(0).unwrap(), b"first".as_ref()) .unwrap(); @@ -1343,7 +1342,7 @@ async fn a_live_subscription_survives_union_renewal(version: &'static str) { let _renewed = renewed.unwrap(); drop(first); first_grant.closed().await; - let mut group = published.append_next().unwrap(); + let mut group = published.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::from_millis(1).unwrap(), b"renewed".as_ref()) .unwrap(); @@ -1398,9 +1397,9 @@ async fn a_revoked_grant_cancels_its_subscriptions(version: &'static str) { }); let (_, setup) = issued.next().await.unwrap(); - let mut group = down_track.append_next().unwrap(); + let mut group = down_track.append_group(None).unwrap(); group.write_frame(ts(0), b"down".as_ref()).unwrap(); - let mut group = up_track.append_next().unwrap(); + let mut group = up_track.append_group(None).unwrap(); group.write_frame(ts(0), b"up".as_ref()).unwrap(); let remote = received @@ -1824,9 +1823,9 @@ async fn a_narrowing_deafens_one_path(version: &'static str) { }) .await; - let mut group = audio_track.append_next().unwrap(); + let mut group = audio_track.append_group(None).unwrap(); group.write_frame(ts(0), b"a".as_ref()).unwrap(); - let mut group = video_track.append_next().unwrap(); + let mut group = video_track.append_group(None).unwrap(); group.write_frame(ts(0), b"v".as_ref()).unwrap(); let remote = received @@ -1857,7 +1856,7 @@ async fn a_narrowing_deafens_one_path(version: &'static str) { wait_announced(&received.consume(), "room/alice/audio", false).await; // The sibling keeps flowing. - let mut group = video_track.append_next().unwrap(); + let mut group = video_track.append_group(None).unwrap(); group.write_frame(ts(1), b"v".as_ref()).unwrap(); let group = video_sub.recv_group().await.unwrap().expect("video still flows"); assert_eq!(group.start, 1); @@ -1918,9 +1917,9 @@ async fn a_narrowing_aborts_what_the_peer_published(version: &'static str) { }) .await; - let mut group = mic_track.append_next().unwrap(); + let mut group = mic_track.append_group(None).unwrap(); group.write_frame(ts(0), b"m".as_ref()).unwrap(); - let mut group = cam_track.append_next().unwrap(); + let mut group = cam_track.append_group(None).unwrap(); group.write_frame(ts(0), b"c".as_ref()).unwrap(); let remote = relay @@ -1950,7 +1949,7 @@ async fn a_narrowing_aborts_what_the_peer_published(version: &'static str) { assert!(unauthorized(&err), "{err:?}"); wait_announced(&relay.consume(), "room/bob/mic", false).await; - let mut group = cam_track.append_next().unwrap(); + let mut group = cam_track.append_group(None).unwrap(); group.write_frame(ts(1), b"c".as_ref()).unwrap(); let group = cam_sub.recv_group().await.unwrap().expect("cam still flows"); assert_eq!(group.start, 1); @@ -1973,7 +1972,7 @@ async fn a_narrowing_resets_a_fetch_in_flight(version: &'static str) { let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); // The group stays open, so the fetch is still in flight when the grant narrows. - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(0), b"first".as_ref()).unwrap(); let received = produce_origin(3); @@ -2057,7 +2056,7 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { }) .await; - let mut group = audio_track.append_next().unwrap(); + let mut group = audio_track.append_group(None).unwrap(); group.write_frame(ts(0), b"a".as_ref()).unwrap(); let remote = received .consume() @@ -2087,7 +2086,7 @@ async fn a_widening_brings_back_a_deafened_path(version: &'static str) { .unwrap() .unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); - let mut group = audio_track.append_next().unwrap(); + let mut group = audio_track.append_group(None).unwrap(); group.write_frame(ts(1), b"a".as_ref()).unwrap(); recv_through(&mut sub, 1).await; @@ -2148,7 +2147,7 @@ async fn a_widening_brings_back_what_the_peer_published(version: &'static str) { .unwrap() .unwrap(); let mut sub = remote.track("opus").unwrap().subscribe(prefs()).await.unwrap(); - let mut group = mic_track.append_next().unwrap(); + let mut group = mic_track.append_group(None).unwrap(); group.write_frame(ts(0), b"m".as_ref()).unwrap(); recv_through(&mut sub, 0).await; @@ -2412,7 +2411,7 @@ async fn a_broadcast_relayed_from_another_client_is_not_ours_to_check(version: & .await; assert_eq!(granted(&pair.client).await, grant(&["local"], &[""])); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::from_millis(0).unwrap(), b"frame".as_ref()) .unwrap(); diff --git a/rs/moq-net/tests/integration/catalog_acquisition.rs b/rs/moq-net/tests/integration/catalog_acquisition.rs index 39f3bb9f335..d46d59e1325 100644 --- a/rs/moq-net/tests/integration/catalog_acquisition.rs +++ b/rs/moq-net/tests/integration/catalog_acquisition.rs @@ -3,7 +3,6 @@ //! Initial catalog acquisition while the same publisher gains a second session. use crate::support; -use support::AppendNext; use moq_net::{Error, Version, origin}; use support::harness::{MockConnectOptions, MockPair, connect_mock}; @@ -72,11 +71,11 @@ async fn acquisition(version: &str, carries_instance: bool) { }; assert!(new_cost < old_cost, "the cheaper session wins the route"); let track = request.accept(None); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::unscaled(group.start), b"catalog".to_vec()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let result = pending.await; if carries_instance { let mut subscription = result.expect("the same instance must acquire"); diff --git a/rs/moq-net/tests/integration/catalog_churn.rs b/rs/moq-net/tests/integration/catalog_churn.rs index c53d287a32e..18581f515a2 100644 --- a/rs/moq-net/tests/integration/catalog_churn.rs +++ b/rs/moq-net/tests/integration/catalog_churn.rs @@ -10,7 +10,6 @@ //! shrunk to the ops it needs, which the report names. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -303,7 +302,7 @@ async fn execute(version: Version, ops: &[Op]) -> Result<(), Failure> { _upstream: upstream, }; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); // The open group as written so far, as `group:payload`. let mut written: Vec = Vec::new(); let mut readers: Vec = Vec::new(); @@ -327,8 +326,8 @@ async fn execute(version: Version, ops: &[Op]) -> Result<(), Failure> { match *op { Op::Write => write(&mut group, &mut written, &mut readers, &format!("d{step}")), Op::NewGroup => { - group.close().unwrap(); - group = track.append_next().unwrap(); + group.finish().unwrap(); + group = track.append_group(None).unwrap(); written.clear(); write(&mut group, &mut written, &mut readers, "snapshot"); // Let it reach `R`, so the newest group at the next join is unambiguous. diff --git a/rs/moq-net/tests/integration/catalog_handover.rs b/rs/moq-net/tests/integration/catalog_handover.rs index c4163b182cc..8e55fa55117 100644 --- a/rs/moq-net/tests/integration/catalog_handover.rs +++ b/rs/moq-net/tests/integration/catalog_handover.rs @@ -12,7 +12,6 @@ //! no catalog. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -113,7 +112,7 @@ impl Topology { .unwrap(); let track = broadcast.broadcast().create_track("catalog.json", timed()).unwrap(); broadcast.announce().unwrap(); - let group = track.append_next().unwrap(); + let group = track.append_group(None).unwrap(); let p_to_a = link(version, &publisher, &relay_a, None).await; let p_to_b = link(version, &publisher, &relay_b, None).await; diff --git a/rs/moq-net/tests/integration/claim_continues.rs b/rs/moq-net/tests/integration/claim_continues.rs index 3dd88d12a5e..2953203ac89 100644 --- a/rs/moq-net/tests/integration/claim_continues.rs +++ b/rs/moq-net/tests/integration/claim_continues.rs @@ -8,7 +8,6 @@ //! subscription through the claim sees another broadcast rather than a splice. use crate::support; -use support::AppendNext; use support::AtStart; use std::{cell::RefCell, rc::Rc, time::Duration}; @@ -71,9 +70,9 @@ impl Worker { ) .unwrap(); let tag = format!("{name}{}", served.borrow().len()); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), tag.into_bytes()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); prepared.announce().unwrap(); served.borrow_mut().push((prepared, track)); } diff --git a/rs/moq-net/tests/integration/compress.rs b/rs/moq-net/tests/integration/compress.rs index 34c9388fd30..dce709009ee 100644 --- a/rs/moq-net/tests/integration/compress.rs +++ b/rs/moq-net/tests/integration/compress.rs @@ -6,7 +6,6 @@ //! signal compression receive the plain frames the relay inflates once for all of them. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -170,7 +169,7 @@ async fn a_start_group_arrives_whole() { ); } write(&mut group, head..5); - group.close().unwrap(); + group.finish().unwrap(); let mut reading = fixture.subscriber.recv_group().await.unwrap().unwrap(); assert_eq!(reading.start, 5, "{case}"); for index in 0..5 { @@ -203,7 +202,7 @@ async fn relay_serves_every_version() { "{version}: compression declared" ); - let mut group = fixture.track.append_next().unwrap(); + let mut group = fixture.track.append_group(None).unwrap(); group .write_frame(Timestamp::from_millis(0).unwrap(), payload(0)) .unwrap(); @@ -225,7 +224,7 @@ async fn relay_serves_every_version() { group .write_frame(Timestamp::from_millis(3).unwrap(), bytes::Bytes::new()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = fixture.subscriber.recv_group().await.unwrap().expect("group"); for index in 0..3 { @@ -251,13 +250,13 @@ async fn ietf_ingress_stays_compressed_across_protocols() { fixture.subscriber.info().compression == moq_net::track::Compression::Deflate, "{upstream} -> {downstream}" ); - let mut group = fixture.track.append_next().unwrap(); + let mut group = fixture.track.append_group(None).unwrap(); for index in 0..3 { group .write_frame(Timestamp::from_millis(index).unwrap(), payload(index)) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let mut received = fixture.subscriber.recv_group().await.unwrap().unwrap(); for index in 0..3 { assert_eq!( @@ -283,13 +282,13 @@ async fn ietf_fetch_keeps_the_stored_form() { .route("bcast", moq_net::origin::RouteOptions::hidden()) .unwrap(); let track = broadcast.broadcast().create_track("data", compressed()).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); for index in 0..3 { group .write_frame(Timestamp::from_millis(index).unwrap(), payload(index)) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); broadcast.announce().unwrap(); let origin = produce_origin(2); diff --git a/rs/moq-net/tests/integration/control_stats.rs b/rs/moq-net/tests/integration/control_stats.rs index 22fd3f30f37..bb5dc000ace 100644 --- a/rs/moq-net/tests/integration/control_stats.rs +++ b/rs/moq-net/tests/integration/control_stats.rs @@ -2,7 +2,6 @@ //! Control counters cross real protocol drivers, including legacy multiplexing. -use crate::support::AppendNext; use crate::support::AtStart; use crate::support::{ harness::{MockConnectOptions, connect_mock, now, spawn, subscribed}, @@ -54,11 +53,11 @@ async fn control_classes_cross_lite_and_ietf_sessions_without_counting_payload() .unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); subscribed(&track).await; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(group.at_start(), bytes::Bytes::from(vec![7; 64 * 1024])) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload.len(), 64 * 1024); let rows = registry.snapshot().control(); diff --git a/rs/moq-net/tests/integration/drained_claim.rs b/rs/moq-net/tests/integration/drained_claim.rs index 369a389060b..408f97511bf 100644 --- a/rs/moq-net/tests/integration/drained_claim.rs +++ b/rs/moq-net/tests/integration/drained_claim.rs @@ -10,7 +10,6 @@ //! the path now, rather than the drained worker. use crate::support; -use support::AppendNext; use support::AtStart; use std::{cell::RefCell, rc::Rc, time::Duration}; @@ -64,9 +63,9 @@ impl Worker { while let Some(request) = handler.requested().await { let prepared = request.route(moq_net::origin::RouteOptions::hidden()).unwrap(); let track = prepared.broadcast().create_track("video", timed()).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), name.as_bytes().to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); prepared.announce().unwrap(); served.borrow_mut().push((prepared, track)); } diff --git a/rs/moq-net/tests/integration/drop_record.rs b/rs/moq-net/tests/integration/drop_record.rs index a1b86b05e50..7b4e563be9a 100644 --- a/rs/moq-net/tests/integration/drop_record.rs +++ b/rs/moq-net/tests/integration/drop_record.rs @@ -41,7 +41,7 @@ fn write(source: &track::Producer, key: u64, millis: u64) { group .write_frame(Timestamp::from_millis(millis).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// A publisher, a relay subscribing to it, and a viewer subscribing to the relay. @@ -413,7 +413,7 @@ async fn an_origin_eviction_drop_is_forwarded_final() { group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), vec![0u8; PAYLOAD]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; for key in 0..4 { write(key); diff --git a/rs/moq-net/tests/integration/empty_group.rs b/rs/moq-net/tests/integration/empty_group.rs index d3828e62a45..d9c448dcc92 100644 --- a/rs/moq-net/tests/integration/empty_group.rs +++ b/rs/moq-net/tests/integration/empty_group.rs @@ -3,7 +3,6 @@ //! A group finished with no frames reaches the subscriber as an empty group. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -51,7 +50,7 @@ async fn an_empty_group_arrives_empty() { .expect("subscribe"); subscribed(&track).await; - track.append_next().unwrap().close().unwrap(); + track.append_group(None).unwrap().finish().unwrap(); let mut empty = kio::clock::timeout(TIMEOUT, sub.recv_group()) .await .unwrap_or_else(|_| panic!("{version}: the empty group was dropped")) @@ -64,9 +63,9 @@ async fn an_empty_group_arrives_empty() { .unwrap(); assert!(frame.is_none(), "{version}: the empty group carried a frame"); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), &b"ok"[..]).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut next = kio::clock::timeout(TIMEOUT, sub.recv_group()) .await .expect("group timeout") diff --git a/rs/moq-net/tests/integration/errored_end.rs b/rs/moq-net/tests/integration/errored_end.rs index 5b55c7cba8c..4fcc19bb83a 100644 --- a/rs/moq-net/tests/integration/errored_end.rs +++ b/rs/moq-net/tests/integration/errored_end.rs @@ -6,12 +6,11 @@ use crate::support; use moq_net::track::Delay; -use support::AppendNext; use support::AtStart; use std::time::Duration; -use moq_net::track::{Position, Subscription}; +use moq_net::track::Subscription; use moq_net::{Error, StreamError, Version}; use support::harness::{MockConnectOptions, connect_mock}; @@ -87,16 +86,16 @@ async fn an_errored_end_keeps_its_history_across_a_hop() { let info = moq_net::track::Info::default() .with_timescale(moq_net::Timescale::MILLI) .with_max_age(None); - let mut track = broadcast.broadcast().create_track("video", info).unwrap(); + let track = broadcast.broadcast().create_track("video", info).unwrap(); broadcast.announce().unwrap(); for _ in 0..GROUPS { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); for frame in FRAMES { group.write_frame(group.at_start(), frame).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } - track.finish_at(Position::group(GROUPS), Some(Error::App(7))).unwrap(); + let track = track.fail(Error::App(7)).unwrap(); let subscriber = produce_origin(2); let mut options = MockConnectOptions::new(version); diff --git a/rs/moq-net/tests/integration/failover_chain.rs b/rs/moq-net/tests/integration/failover_chain.rs index d5e9ecbcfe9..6d4ea0efc4e 100644 --- a/rs/moq-net/tests/integration/failover_chain.rs +++ b/rs/moq-net/tests/integration/failover_chain.rs @@ -14,7 +14,6 @@ use crate::support::harness::MockPair; use std::time::Duration; -use crate::support::AppendNext; use crate::support::AtStart; use futures::StreamExt; use futures::channel::mpsc; @@ -84,7 +83,7 @@ impl Chain { track::Subscription::default().with_delay(track::Delay::default().with_max(Duration::from_secs(60))); let mut sub = remote.track("video").unwrap().subscribe(prefs).await.unwrap(); - let mut group0 = track.append_next().unwrap(); + let mut group0 = track.append_group(None).unwrap(); group0.write_frame(group0.at_start(), payload(0, 0)).unwrap(); let mut read0 = sub.recv_group().await.unwrap().unwrap(); assert_eq!(read0.start, 0); @@ -93,9 +92,9 @@ impl Chain { payload(0, 0) ); - let mut group1 = track.append_next().unwrap(); + let mut group1 = track.append_group(None).unwrap(); group1.write_frame(group1.at_start(), payload(1, 0)).unwrap(); - group1.close().unwrap(); + group1.finish().unwrap(); let mut read1 = sub.recv_group().await.unwrap().unwrap(); assert_eq!(read1.start, 1); assert_eq!( @@ -146,7 +145,7 @@ impl Chain { /// The publisher ends the track at group 2 while group 0 is still open. async fn end(&mut self) { - self.track.finish_at(track::Position::group(2), None).unwrap(); + self.track.finish_at(track::Position::group(2)).unwrap(); settle().await; } @@ -154,7 +153,7 @@ impl Chain { fn finish_group0(&mut self) { let mut group0 = self.group0.take().expect("finished once"); group0.write_frame(group0.at_start(), payload(0, 1)).unwrap(); - group0.close().unwrap(); + group0.finish().unwrap(); } } diff --git a/rs/moq-net/tests/integration/fastest_reader.rs b/rs/moq-net/tests/integration/fastest_reader.rs index 11bd64e880e..238fe52301f 100644 --- a/rs/moq-net/tests/integration/fastest_reader.rs +++ b/rs/moq-net/tests/integration/fastest_reader.rs @@ -10,7 +10,6 @@ use std::time::Duration; use bytes::Bytes; use moq_net::{Timestamp, Version, origin, track, transport::ReceiveWindow}; -use crate::support::AppendNext; use crate::support::AtStart; use crate::support::harness::{MockPair, peer, spawn}; @@ -102,7 +101,7 @@ async fn idle_reader(version: &str, window: ReceiveWindow, expected: std::ops::R let mut relay = relay(version).await; relay.pair.server_transport.set_receive_window(Some(window)); - let mut group = relay.track.append_next().unwrap(); + let mut group = relay.track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload.clone()).unwrap(); let mut reader = kio::clock::timeout(TIMEOUT, relay.subscriber.recv_group()) .await @@ -113,7 +112,7 @@ async fn idle_reader(version: &str, window: ReceiveWindow, expected: std::ops::R for _ in 1..30 { group.write_frame(group.at_start(), payload.clone()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); // Simulated time moves only once every task is parked: the relay's ingest stopped. kio::clock::sleep(Duration::from_secs(1)).await; @@ -145,7 +144,7 @@ async fn a_reset_reaches_a_paused_relay() { for version in VERSIONS { let mut relay = relay(version).await; - let mut group = relay.track.append_next().unwrap(); + let mut group = relay.track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload.clone()).unwrap(); let mut reader = kio::clock::timeout(TIMEOUT, relay.subscriber.recv_group()) .await @@ -178,7 +177,7 @@ async fn a_large_frame_sheds_nothing_an_idle_reader_wants() { let mut relay = relay(version).await; relay.pair.server_transport.set_receive_window(Some(uncapped())); - let mut group = relay.track.append_next().unwrap(); + let mut group = relay.track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload.clone()).unwrap(); let mut reader = kio::clock::timeout(TIMEOUT, relay.subscriber.recv_group()) .await @@ -194,7 +193,7 @@ async fn a_large_frame_sheds_nothing_an_idle_reader_wants() { group .write_frame(group.at_start(), Bytes::from(vec![7u8; 20 * MB])) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; assert_eq!( @@ -225,7 +224,7 @@ async fn a_session_past_its_credit_cap_reads_on() { let window = moq_net::transport::ReceiveWindow::new(std::num::NonZeroU64::new(MB as u64), MB as u64); relay.pair.server_transport.set_receive_window(Some(window)); - let mut group = relay.track.append_next().unwrap(); + let mut group = relay.track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload.clone()).unwrap(); let reader = kio::clock::timeout(TIMEOUT, relay.subscriber.recv_group()) .await @@ -235,7 +234,7 @@ async fn a_session_past_its_credit_cap_reads_on() { for _ in 1..30 { group.write_frame(group.at_start(), payload.clone()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; let held = reader.frame_count(); @@ -249,7 +248,7 @@ async fn a_slow_reader_falls_off_without_slowing_the_fast_one() { for version in VERSIONS { let mut relay = relay(version).await; - let mut group = relay.track.append_next().unwrap(); + let mut group = relay.track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload.clone()).unwrap(); let mut fast = kio::clock::timeout(TIMEOUT, relay.subscriber.recv_group()) .await @@ -270,7 +269,7 @@ async fn a_slow_reader_falls_off_without_slowing_the_fast_one() { .expect("a frame"); assert_eq!(frame.payload.len(), MB, "{version}: frame {index}"); } - group.close().unwrap(); + group.finish().unwrap(); let fell = kio::clock::timeout(TIMEOUT, slow.read_frame()) .await @@ -330,7 +329,7 @@ async fn two_relays_bound_their_cache_and_resume_without_a_hole() { .await .unwrap(); crate::support::harness::subscribed(&track).await; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); let written = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0)); let progress = written.clone(); let writer = kio::clock::sim::spawn(async move { @@ -344,7 +343,7 @@ async fn two_relays_bound_their_cache_and_resume_without_a_hole() { group.write_frame(group.at_start(), payload).unwrap(); progress.store(index + 1, std::sync::atomic::Ordering::Relaxed); } - group.close().unwrap(); + group.finish().unwrap(); }); let mut reader = subscriber.recv_group().await.unwrap().unwrap(); // Simulated time advances only once all drivers and the paced writer park. diff --git a/rs/moq-net/tests/integration/fetch_cancel.rs b/rs/moq-net/tests/integration/fetch_cancel.rs index 22e414550aa..77e5d399464 100644 --- a/rs/moq-net/tests/integration/fetch_cancel.rs +++ b/rs/moq-net/tests/integration/fetch_cancel.rs @@ -65,7 +65,9 @@ async fn abandoned_fetch_reaches_the_publisher(version: &str, relays: u64, stage let groups = request.requests(); let _track = request.accept(timed()); let mut request = match futures::future::select(std::pin::pin!(groups.requested_fill()), &mut waiting).await { - futures::future::Either::Left((request, _)) => request.expect("the fetch reaches the publisher"), + futures::future::Either::Left((request, _)) => { + support::groups(request.expect("the fetch reaches the publisher")) + } futures::future::Either::Right(_) => panic!("nothing answered the fetch"), }; @@ -104,7 +106,7 @@ async fn abandoned_fetch_reaches_the_publisher(version: &str, relays: u64, stage group .write_frame(group.at_start(), Bytes::from_static(b"tail")) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut fetched = kio::clock::timeout(Duration::from_secs(5), track.fetch_group(0, None)) .await .unwrap_or_else(|_| panic!("{ctx}: the refetch stalled")) @@ -134,7 +136,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); - let group = group.close().unwrap(); + let group = group.finish().unwrap(); kio::clock::sleep(LATENCY).await; drop(fetched); kio::clock::sleep(Duration::from_secs(1)).await; @@ -197,14 +199,16 @@ async fn a_refetch_within_the_linger_stays_on_the_relay(version: &str) { let groups = request.requests(); let _track = request.accept(timed()); let request = match futures::future::select(std::pin::pin!(groups.requested_fill()), &mut waiting).await { - futures::future::Either::Left((request, _)) => request.expect("the fetch reaches the publisher"), + futures::future::Either::Left((request, _)) => { + support::groups(request.expect("the fetch reaches the publisher")) + } futures::future::Either::Right(_) => panic!("nothing answered the fetch"), }; let mut group = request.accept(0, timed()).unwrap(); group .write_frame(group.at_start(), Bytes::from_static(b"segment")) .unwrap(); - let group = group.close().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_fanout.rs b/rs/moq-net/tests/integration/fetch_fanout.rs index 6b4f7672fd4..c5a3c79dcea 100644 --- a/rs/moq-net/tests/integration/fetch_fanout.rs +++ b/rs/moq-net/tests/integration/fetch_fanout.rs @@ -6,7 +6,6 @@ use crate::support; use moq_net::{Version, origin, track}; use std::time::Duration; -use support::AppendNext; use support::harness::{MockConnectOptions, connect_mock}; fn origin(hop: u64) -> origin::Producer { @@ -51,7 +50,7 @@ async fn sequential_viewers_share_the_relays_fetched_groups() { viewers.push((viewer, pair, remote)); } for round in 0..3 { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); let key = group.start; group .write_frame( @@ -59,7 +58,7 @@ async fn sequential_viewers_share_the_relays_fetched_groups() { b"payload".as_ref(), ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); for (i, (_, _, remote)) in viewers.iter().enumerate() { let mut group = remote.track("video").unwrap().fetch_group(key, None).await.unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload.as_ref(), b"payload"); diff --git a/rs/moq-net/tests/integration/fetch_from_feed.rs b/rs/moq-net/tests/integration/fetch_from_feed.rs index 9e96bebec28..1a4c8cfd8a2 100644 --- a/rs/moq-net/tests/integration/fetch_from_feed.rs +++ b/rs/moq-net/tests/integration/fetch_from_feed.rs @@ -5,7 +5,6 @@ //! never a version error that a caller would retry forever. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -33,11 +32,11 @@ struct Relay { /// Append the next group of an untimed track, holding one frame. fn write(track: &moq_net::track::Producer, payload: &'static [u8]) { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::unscaled(group.start), payload) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// A publisher on `version` with group 0 of an untimed track written, and the relay's view of it. @@ -165,7 +164,7 @@ async fn an_unfed_fetch_is_a_miss() { skipped .write_frame(moq_net::Timestamp::unscaled(skipped.start), &b"3"[..]) .unwrap(); - skipped.close().unwrap(); + skipped.finish().unwrap(); let mut subscriber = kio::clock::timeout(TIMEOUT, relay.remote.track("video").unwrap().subscribe(None)) .await .expect("subscribe timeout") diff --git a/rs/moq-net/tests/integration/fetch_only.rs b/rs/moq-net/tests/integration/fetch_only.rs index c347bb8b33f..5376f724738 100644 --- a/rs/moq-net/tests/integration/fetch_only.rs +++ b/rs/moq-net/tests/integration/fetch_only.rs @@ -7,7 +7,6 @@ //! the fetches that report where the track ends. use crate::support; -use support::AppendNext; use support::AtStart; use std::sync::Arc; @@ -49,13 +48,13 @@ fn publish_finished(origin: &moq_net::origin::Producer) -> (moq_net::origin::Rou let mut track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); for key in 0..3u64 { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); for frame in 0..2 { group .write_frame(group.at_start(), format!("{key}-{frame}").into_bytes()) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } let _finished = track.clone().finish().unwrap(); @@ -181,9 +180,9 @@ async fn a_subscribe_after_track_status_keeps_timestamps() { crate::support::wanted(track.demand()).await.unwrap(); // Far from any arrival time, so a frame stamped on arrival cannot pass. let stamp = Timestamp::from_millis(123_456).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(stamp, b"frame".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); let frame = group.read_frame().await.unwrap().unwrap(); @@ -331,7 +330,7 @@ fn write_group(track: &moq_net::track::Producer, key: u64) { for frame in frames(key) { group.write_frame(group.at_start(), frame).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } /// Publish a live track of groups `0..groups`, which the publisher keeps writing. diff --git a/rs/moq-net/tests/integration/fetch_pipeline.rs b/rs/moq-net/tests/integration/fetch_pipeline.rs index 8f894629d3f..f570047ee7a 100644 --- a/rs/moq-net/tests/integration/fetch_pipeline.rs +++ b/rs/moq-net/tests/integration/fetch_pipeline.rs @@ -6,7 +6,6 @@ //! `model::resume`'s staged copies. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -51,7 +50,7 @@ async fn fetch_ahead( relays: u64, ) -> ( moq_net::track::Request, - moq_net::track::Fill, + moq_net::track::FillGroups, kio::clock::sim::JoinHandle>, Held, ) { @@ -84,6 +83,7 @@ async fn fetch_ahead( let fill = kio::clock::timeout(TIMEOUT, request.requests().requested_fill()) .await .unwrap_or_else(|_| panic!("{version}: the FETCH waited for the info")) + .map(support::groups) .unwrap(); let held = Held { _publisher: publisher, @@ -103,7 +103,7 @@ async fn the_first_fetch_goes_out_with_the_info_request() { let _track = request.accept(timed()); let mut group = fill.accept(0, timed()).unwrap(); group.write_frame(group.at_start(), b"early".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut fetched = kio::clock::timeout(TIMEOUT, fetching) .await .expect("the fetch resolves") @@ -146,9 +146,9 @@ async fn first_fetch(version: &str, relays: u64, rtt: Duration) -> Duration { .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"frame".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut links = Vec::new(); let mut upstream = publisher.clone(); diff --git a/rs/moq-net/tests/integration/finished_broadcast_mock.rs b/rs/moq-net/tests/integration/finished_broadcast_mock.rs index c77063c24b7..d80872d11aa 100644 --- a/rs/moq-net/tests/integration/finished_broadcast_mock.rs +++ b/rs/moq-net/tests/integration/finished_broadcast_mock.rs @@ -15,7 +15,6 @@ //! nothing when the broadcast ends. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -92,9 +91,9 @@ async fn round(finish_broadcast: bool) -> (Vec>, Option) // One frame and a textbook clean end, innermost first, with no await in between: // nothing is served until the ending is done. - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), PAYLOAD).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let track = track.finish().unwrap(); drop(track); if finish_broadcast { diff --git a/rs/moq-net/tests/integration/finite_relay.rs b/rs/moq-net/tests/integration/finite_relay.rs index 832aa69a0e5..29384fe59c1 100644 --- a/rs/moq-net/tests/integration/finite_relay.rs +++ b/rs/moq-net/tests/integration/finite_relay.rs @@ -10,7 +10,6 @@ use crate::support; use moq_net::track::Delay; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -142,12 +141,12 @@ async fn round(name: &str, arrival: Arrival) -> (Vec, Result<(), moq_net::E // tells the relay where its feed starts; otherwise the outcome rests on whether the // first group is written before SUBSCRIBE_OK. kio::clock::sleep(Duration::from_millis(1)).await; - track.finish_at(moq_net::track::Position::group(GROUPS), None).unwrap(); + track.finish_at(moq_net::track::Position::group(GROUPS)).unwrap(); match arrival { Arrival::HeldTails => { let mut groups = Vec::new(); for key in 0..GROUPS { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), &b"head"[..]).unwrap(); groups.push(group); // IETF requests the live edge, so observe each header before advancing it. @@ -162,16 +161,16 @@ async fn round(name: &str, arrival: Arrival) -> (Vec, Result<(), moq_net::E kio::clock::sleep(Duration::from_millis(100)).await; for mut group in groups { group.write_frame(group.at_start(), &b"tail"[..]).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } } Arrival::NewestFirst => { upstream.server_transport.hold_unis(); for _ in 0..GROUPS { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), &b"head"[..]).unwrap(); group.write_frame(group.at_start(), &b"tail"[..]).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); // IETF serves from the live edge, so let each group open its stream before // the next one supersedes it. kio::clock::sleep(Duration::from_millis(10)).await; diff --git a/rs/moq-net/tests/integration/flights.rs b/rs/moq-net/tests/integration/flights.rs index 4c8c404f750..fd722163ecd 100644 --- a/rs/moq-net/tests/integration/flights.rs +++ b/rs/moq-net/tests/integration/flights.rs @@ -15,7 +15,6 @@ use std::time::Duration; use bytes::Bytes; use moq_net::{Version, cache, frame, group, origin, track}; -use crate::support::AppendNext; use crate::support::harness::{MockConnectOptions, connect_mock, spawn}; const TIMEOUT: Duration = Duration::from_secs(10); @@ -55,7 +54,7 @@ fn origin(hop: u64, pool: &cache::Pool) -> origin::Producer { /// archive has nothing newer yet, so only wait for that. async fn write_paced( group: &mut group::Producer, - fill: &track::Fill, + fill: &track::FillGroups, demand: &mut group::Demand, payload: Option, ) -> bool { @@ -83,7 +82,7 @@ async fn write_paced( /// whole group, so each fill finishes after its last frame. fn serve(requests: track::Requests, written: Arc, ended: Arc, finish: bool) { drop(kio::clock::sim::spawn(async move { - while let Ok(fill) = requests.requested_fill().await { + while let Ok(track::Fill::Groups(fill)) = requests.requested_fill().await { let start = fill.start(); let mut group = fill.accept(start.group, None).expect("accept"); let mut demand = group.demand(); @@ -92,7 +91,7 @@ fn serve(requests: track::Requests, written: Arc, ended: Arc Vec<(u64, usiz old.write_frame(Timestamp::from_millis(5).unwrap(), &b"old"[..]) .unwrap(); } - old.close().unwrap(); + old.finish().unwrap(); let mut live = track.create_group(moq_net::group::Info { start: 6 }).unwrap(); for _ in 0..2 { live.write_frame(Timestamp::from_millis(6).unwrap(), &b"live"[..]) @@ -257,7 +257,7 @@ async fn a_late_subscriber_receives_the_relays_cached_history() { old.write_frame(Timestamp::from_millis(5).unwrap(), &b"old"[..]) .unwrap(); } - old.close().unwrap(); + old.finish().unwrap(); let mut live = track.create_group(moq_net::group::Info { start: 6 }).unwrap(); for _ in 0..2 { live.write_frame(Timestamp::from_millis(6).unwrap(), &b"live"[..]) diff --git a/rs/moq-net/tests/integration/history_join.rs b/rs/moq-net/tests/integration/history_join.rs index 9d4e7b65390..a4f14e34675 100644 --- a/rs/moq-net/tests/integration/history_join.rs +++ b/rs/moq-net/tests/integration/history_join.rs @@ -6,7 +6,6 @@ use std::time::Duration; use moq_net::{Timestamp, Version, cache, origin, track}; -use crate::support::AppendNext; use crate::support::harness::{MockConnectOptions, connect_mock, spawn}; const TIMEOUT: Duration = Duration::from_secs(10); @@ -39,11 +38,11 @@ async fn each_joining_viewer_reads_the_held_group() { .with_timescale(moq_net::Timescale::MILLI) .with_max_age(None); let source = broadcast.broadcast().create_track("video", info).unwrap(); - let mut group = source.append_next().unwrap(); + let mut group = source.append_group(None).unwrap(); group .write_frame(Timestamp::from_millis(0).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); for join in 0..3 { let viewer = origin(3 + join); diff --git a/rs/moq-net/tests/integration/idle_cancel_refetch.rs b/rs/moq-net/tests/integration/idle_cancel_refetch.rs index 6466c98bef5..48c783a8a58 100644 --- a/rs/moq-net/tests/integration/idle_cancel_refetch.rs +++ b/rs/moq-net/tests/integration/idle_cancel_refetch.rs @@ -37,7 +37,7 @@ async fn a_group_cut_by_an_idle_cancel_is_refetched_whole() { let mut g0 = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); g0.write_frame(moq_net::Timestamp::unscaled(g0.start), &b"0a"[..]) .unwrap(); - g0.close().unwrap(); + g0.finish().unwrap(); let mut g1 = track.create_group(moq_net::group::Info { start: 1 }).unwrap(); g1.write_frame(moq_net::Timestamp::unscaled(g1.start), &b"1a"[..]) .unwrap(); @@ -82,7 +82,7 @@ async fn a_group_cut_by_an_idle_cancel_is_refetched_whole() { g1.write_frame(moq_net::Timestamp::unscaled(g1.start), &b"1b"[..]) .unwrap(); - g1.close().unwrap(); + g1.finish().unwrap(); let mut g2 = track.create_group(moq_net::group::Info { start: 2 }).unwrap(); g2.write_frame(moq_net::Timestamp::unscaled(g2.start), &b"2a"[..]) .unwrap(); diff --git a/rs/moq-net/tests/integration/late_lower_group.rs b/rs/moq-net/tests/integration/late_lower_group.rs index 2b3e20e9d61..d850dbe155f 100644 --- a/rs/moq-net/tests/integration/late_lower_group.rs +++ b/rs/moq-net/tests/integration/late_lower_group.rs @@ -51,7 +51,7 @@ fn write_group(track: &moq_net::track::Producer, key: u64) { let timestamp = Timestamp::from_millis(key * 1000 + frame).unwrap(); group.write_frame(timestamp, &b"x"[..]).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } async fn read_all(sub: &mut moq_net::track::Subscriber) -> Vec<(u64, usize)> { diff --git a/rs/moq-net/tests/integration/late_tail_reader.rs b/rs/moq-net/tests/integration/late_tail_reader.rs index 6258f05527b..317a17b2af5 100644 --- a/rs/moq-net/tests/integration/late_tail_reader.rs +++ b/rs/moq-net/tests/integration/late_tail_reader.rs @@ -95,7 +95,7 @@ async fn each_late_reader_reads_the_finished_group() { .write_frame(moq_net::Timestamp::from_micros(START + frame).unwrap(), &b"frame"[..]) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let finished = track.finish().unwrap(); broadcast.announce().unwrap(); @@ -155,7 +155,7 @@ async fn concurrent_late_readers_read_the_finished_group() { .write_frame(moq_net::Timestamp::from_micros(START + frame).unwrap(), &b"frame"[..]) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let finished = track.finish().unwrap(); broadcast.announce().unwrap(); @@ -225,7 +225,7 @@ async fn an_empty_history_read_leaves_the_group_to_readers_joining_meanwhile() { .write_frame(moq_net::Timestamp::from_micros(START + frame).unwrap(), &b"frame"[..]) .unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let finished = track.finish().unwrap(); broadcast.announce().unwrap(); diff --git a/rs/moq-net/tests/integration/mesh_sweep.rs b/rs/moq-net/tests/integration/mesh_sweep.rs index 0e07ab17c09..6226cfa57a7 100644 --- a/rs/moq-net/tests/integration/mesh_sweep.rs +++ b/rs/moq-net/tests/integration/mesh_sweep.rs @@ -25,7 +25,6 @@ use futures::channel::mpsc; use moq_net::{Instance, Timescale, Version, cache, origin, stats, track}; use support::harness::{MockConnectOptions, MockPair, connect_mock}; -use crate::support::AppendNext; use crate::support::AtStart; use crate::support::{self, Rng}; @@ -363,11 +362,11 @@ impl Mesh { .broadcast() .create_track(TRACK, track::Info::default().with_timescale(Timescale::MILLI)) .unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(group.at_start(), bytes::Bytes::from(path.clone())) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); route.announce().unwrap(); Held { route, _track: track } }; diff --git a/rs/moq-net/tests/integration/model.rs b/rs/moq-net/tests/integration/model.rs index 71fa4aeb187..001aa929ee1 100644 --- a/rs/moq-net/tests/integration/model.rs +++ b/rs/moq-net/tests/integration/model.rs @@ -28,7 +28,7 @@ fn origin_front_serves_media_with_only_explicit_polls() { .unwrap(); let mut group = track.create_group(group::Info { start: 7 }).unwrap(); group.write_frame(Timestamp::from_millis(7).unwrap(), b"media").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); broadcast.announce().unwrap(); // Resolving and subscribing pass through the origin's core front tasks. diff --git a/rs/moq-net/tests/integration/mount.rs b/rs/moq-net/tests/integration/mount.rs index bc5602327a1..494a23c8eba 100644 --- a/rs/moq-net/tests/integration/mount.rs +++ b/rs/moq-net/tests/integration/mount.rs @@ -5,7 +5,6 @@ //! itself, and a reader there reaches the target. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -31,9 +30,9 @@ fn publish(origin: &origin::Producer, path: &str) -> (origin::Route, track::Prod track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) .unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), path.as_bytes().to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); (route, track) } diff --git a/rs/moq-net/tests/integration/multi_cdn.rs b/rs/moq-net/tests/integration/multi_cdn.rs index ff1eac34806..78c34051db8 100644 --- a/rs/moq-net/tests/integration/multi_cdn.rs +++ b/rs/moq-net/tests/integration/multi_cdn.rs @@ -12,7 +12,6 @@ //! onto it is a restart that ends the subscription rather than stitching onto it. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -209,13 +208,13 @@ impl Topology { fn group(&mut self) -> Vec<(u64, Vec)> { let key = self.key; self.key += 1; - let mut group = self.track.append_next().unwrap(); + let mut group = self.track.append_group(None).unwrap(); let mut written = Vec::new(); for frame in 0..FRAMES { group.write_frame(timestamp(key, frame), payload(key, frame)).unwrap(); written.push((key, payload(key, frame))); } - group.close().unwrap(); + group.finish().unwrap(); written } diff --git a/rs/moq-net/tests/integration/nested_claim.rs b/rs/moq-net/tests/integration/nested_claim.rs index a239024e477..ed832b260ce 100644 --- a/rs/moq-net/tests/integration/nested_claim.rs +++ b/rs/moq-net/tests/integration/nested_claim.rs @@ -11,7 +11,6 @@ //! same setup reaches the derivative on some runs and is refused on others. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -62,9 +61,9 @@ fn publish(node: &origin::Producer, path: &str, tag: &'static str) -> (origin::R track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) .unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), tag.as_bytes().to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); route.announce().unwrap(); (route, track) } diff --git a/rs/moq-net/tests/integration/partial_group.rs b/rs/moq-net/tests/integration/partial_group.rs index 880531f9c43..607d2f33143 100644 --- a/rs/moq-net/tests/integration/partial_group.rs +++ b/rs/moq-net/tests/integration/partial_group.rs @@ -6,7 +6,6 @@ use crate::support; use moq_net::track::Delay; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -64,7 +63,7 @@ async fn round(version: &str) -> Option, moq_net::Error>> { .expect("subscribe"); subscribed(&track).await; - let mut stalled = track.append_next().unwrap(); + let mut stalled = track.append_group(None).unwrap(); stalled.write_frame(stalled.at_start(), &b"head"[..]).unwrap(); let mut group = kio::clock::timeout(TIMEOUT, live.recv_group()) .await @@ -77,10 +76,10 @@ async fn round(version: &str) -> Option, moq_net::Error>> { // The live edge moves a full second past the stalled group's reach. kio::clock::sleep(Duration::from_secs(1)).await; for millis in [1000, 2000] { - let mut next = track.append_next().unwrap(); + let mut next = track.append_group(None).unwrap(); next.write_frame(Timestamp::from_millis(millis).unwrap(), &b"edge"[..]) .unwrap(); - next.close().unwrap(); + next.finish().unwrap(); } let tail = kio::clock::timeout(TIMEOUT, group.read_frame()) .await diff --git a/rs/moq-net/tests/integration/path_routes.rs b/rs/moq-net/tests/integration/path_routes.rs index 390d0c81e50..06d04ec7bf2 100644 --- a/rs/moq-net/tests/integration/path_routes.rs +++ b/rs/moq-net/tests/integration/path_routes.rs @@ -11,7 +11,7 @@ use crate::route_change::{link, next, payload, produce_origin, read, timed}; use crate::support; -use support::{AppendNext, AtStart}; +use support::AtStart; use std::time::Duration; @@ -202,9 +202,9 @@ async fn a_flapping_link_keeps_a_dual_homed_publisher_routed() { _ => p_a = peer(version, &p, &a).await, } let sent = kio::clock::now(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload(flap, 0)).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(next(&mut rx).await, (flap, payload(flap, 0)), "flap {flap}"); let late = kio::clock::now().saturating_duration_since(sent); assert!(late < DOUBT / 2, "flap {flap}: read {late:?} after it was written"); diff --git a/rs/moq-net/tests/integration/quiet_catalog.rs b/rs/moq-net/tests/integration/quiet_catalog.rs index 329ceb7b593..5340315c45a 100644 --- a/rs/moq-net/tests/integration/quiet_catalog.rs +++ b/rs/moq-net/tests/integration/quiet_catalog.rs @@ -6,7 +6,6 @@ //! must still get it. use crate::support; -use support::AppendNext; use support::AtStart; use std::{future::Future, time::Duration}; @@ -53,9 +52,9 @@ fn publish(origin: &origin::Producer) -> (moq_net::origin::Route, track::Produce let broadcast = origin.route("live", moq_net::origin::RouteOptions::hidden()).unwrap(); let track = broadcast.broadcast().create_track("catalog.json", timed()).unwrap(); broadcast.announce().unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"snapshot").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); (broadcast, track) } diff --git a/rs/moq-net/tests/integration/range_anchors.rs b/rs/moq-net/tests/integration/range_anchors.rs index 300492d6fd9..c8a245e94c6 100644 --- a/rs/moq-net/tests/integration/range_anchors.rs +++ b/rs/moq-net/tests/integration/range_anchors.rs @@ -63,7 +63,7 @@ async fn read(version: Option<&str>, range: Range) -> Result, Error> { for key in (0..5).map(|second| second * 1000) { let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); group.write_frame(millis(key), &b"x"[..]).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let subscriber = produce_origin(2); @@ -202,7 +202,7 @@ async fn a_relative_start_reports_the_publishers_start_over_a_frameless_newest_g group .write_frame(moq_net::Timestamp::unscaled(group.start), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut newest = track.create_group(moq_net::group::Info { start: 5 }).unwrap(); @@ -233,7 +233,7 @@ async fn a_relative_start_reports_the_publishers_start_over_a_frameless_newest_g newest .write_frame(moq_net::Timestamp::unscaled(newest.start), &b"x"[..]) .unwrap(); - newest.close().unwrap(); + newest.finish().unwrap(); let group = kio::clock::timeout(TIMEOUT, reader.recv_group()) .await .expect("group timeout") diff --git a/rs/moq-net/tests/integration/range_fill.rs b/rs/moq-net/tests/integration/range_fill.rs index ae8bbbab514..8e4d8487369 100644 --- a/rs/moq-net/tests/integration/range_fill.rs +++ b/rs/moq-net/tests/integration/range_fill.rs @@ -67,7 +67,7 @@ impl Fixture { group .write_frame(Timestamp::from_millis(index * 1000).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let copy = origin(2, None); @@ -154,7 +154,7 @@ async fn evicted_history_is_recovered_once_on_its_own_subscription() { group .write_frame(Timestamp::from_millis(6000).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(receive(&mut first, 1).await, [6].into()); assert_eq!(fixture.opened(SUBSCRIBE), subscribes + 1, "recovered once"); @@ -197,7 +197,7 @@ async fn sparse_history_is_recovered_across_its_skips() { group .write_frame(Timestamp::from_millis(6000).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(receive(&mut first, 1).await, [6000].into()); }) .await @@ -235,7 +235,7 @@ async fn a_recovery_takes_a_skip_inside_it() { group .write_frame(Timestamp::from_millis(start * 1000).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut first = fixture.subscribe([Range::oldest()]).await; assert_eq!(receive(&mut first, 5).await, [0, 1, 3, 4, 5].into()); @@ -251,7 +251,7 @@ async fn a_recovery_takes_a_skip_inside_it() { group .write_frame(Timestamp::from_millis(6000).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(receive(&mut first, 1).await, [6].into()); }) .await diff --git a/rs/moq-net/tests/integration/range_read.rs b/rs/moq-net/tests/integration/range_read.rs index 1f334b6fbfc..1f94664e305 100644 --- a/rs/moq-net/tests/integration/range_read.rs +++ b/rs/moq-net/tests/integration/range_read.rs @@ -5,7 +5,6 @@ //! past the live edge ends once the groups up to its end arrive. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -23,13 +22,13 @@ fn produce_origin(hop: u64) -> moq_net::origin::Producer { } fn write_group(track: &mut moq_net::track::Producer, key: u64) { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); assert_eq!(group.start, key); let at = Timestamp::from_millis(key).unwrap(); for frame in 0..2u64 { group.write_frame(at, payload(key, frame)).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } fn payload(key: u64, frame: u64) -> Vec { diff --git a/rs/moq-net/tests/integration/received_rewind.rs b/rs/moq-net/tests/integration/received_rewind.rs index 899be31b926..bf290b781d9 100644 --- a/rs/moq-net/tests/integration/received_rewind.rs +++ b/rs/moq-net/tests/integration/received_rewind.rs @@ -36,7 +36,7 @@ fn write_group(track: &moq_net::track::Producer, key: u64) { let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); let timestamp = millis(key); group.write_frame(timestamp, &b"x"[..]).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// The groups at one second then at zero of a millisecond track, into a relay over diff --git a/rs/moq-net/tests/integration/rejoin.rs b/rs/moq-net/tests/integration/rejoin.rs index c3759826411..c9e33efd2b2 100644 --- a/rs/moq-net/tests/integration/rejoin.rs +++ b/rs/moq-net/tests/integration/rejoin.rs @@ -3,7 +3,6 @@ //! A reader leaving and rejoining a track relayed over the in-memory mock transport. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -76,10 +75,10 @@ async fn rejoin_recovers_the_group_reset_on_leave() { track::Subscription::default().with_delay(track::Delay::default().with_max(Duration::from_secs(10))) }; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(0), b"a0".as_ref()).unwrap(); - group.close().unwrap(); - let mut open = track.append_next().unwrap(); + group.finish().unwrap(); + let mut open = track.append_group(None).unwrap(); open.write_frame(ts(100), b"b0".as_ref()).unwrap(); let mut sub = remote.track("video").unwrap().subscribe(prefs()).await.unwrap(); @@ -95,12 +94,12 @@ async fn rejoin_recovers_the_group_reset_on_leave() { drop(sub); crate::support::unwanted(track.demand()).await.unwrap(); open.write_frame(ts(133), b"b1".as_ref()).unwrap(); - open.close().unwrap(); + open.finish().unwrap(); if advance { - let mut live = track.append_next().unwrap(); + let mut live = track.append_group(None).unwrap(); live.write_frame(ts(5000), b"c0".as_ref()).unwrap(); - live.close().unwrap(); + live.finish().unwrap(); } let mut sub = remote.track("video").unwrap().subscribe(prefs()).await.unwrap(); @@ -177,9 +176,9 @@ async fn rejoin_skips_a_cache_kept_by_another_handle() { // Held for fetches only: it keeps the relay's copy without subscribing. let _held = remote.track("video").unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(0), b"old".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(read_all(&mut group).await.unwrap(), [b"old".to_vec()], "{version}"); @@ -188,9 +187,9 @@ async fn rejoin_skips_a_cache_kept_by_another_handle() { // The publisher moves on while nobody subscribes. for key in 1..=3u64 { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(key * 1000), b"new".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); @@ -245,9 +244,9 @@ async fn rejoin_keeps_the_cache_when_the_backlog_lands_newest_first() { // Held for fetches only: it keeps the relay's copy without subscribing. let _held = remote.track("video").unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(0), b"0".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut sub = remote.track("video").unwrap().subscribe(prefs()).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(read_all(&mut group).await.unwrap(), [b"0".to_vec()], "{version}"); @@ -256,9 +255,9 @@ async fn rejoin_keeps_the_cache_when_the_backlog_lands_newest_first() { // The publisher moves on while nobody subscribes, all within the max age. for key in 1..=3u64 { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(key * 100), key.to_string()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } pair.server_transport.hold_unis(); @@ -310,7 +309,7 @@ async fn rejoin_mid_group_keeps_the_head_for_later_readers() { let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); // Left open, as a JSON snapshot group stays open for its deltas. - let mut open = track.append_next().unwrap(); + let mut open = track.append_group(None).unwrap(); open.write_frame(open.at_start(), b"a0".as_ref()).unwrap(); let version: Version = version.parse().unwrap(); @@ -389,7 +388,7 @@ async fn rejoin_goes_live_without_the_join_head() { .unwrap(); let track = broadcast.broadcast().create_track("video", timed()).unwrap(); broadcast.announce().unwrap(); - let mut open = track.append_next().unwrap(); + let mut open = track.append_group(None).unwrap(); open.write_frame(open.at_start(), b"a0".as_ref()).unwrap(); let version: Version = version.parse().unwrap(); @@ -431,10 +430,10 @@ async fn rejoin_goes_live_without_the_join_head() { kio::clock::sleep(Duration::from_millis(100)).await; upstream.server_transport.drop_unis(); - let mut next = track.append_next().unwrap(); + let mut next = track.append_group(None).unwrap(); next.write_frame(Timestamp::from_millis(1000).unwrap(), b"b0".as_ref()) .unwrap(); - next.close().unwrap(); + next.finish().unwrap(); let local = relay.consume().request("bench", None).await.unwrap(); let mut sub = local.track("video").unwrap().subscribe(None).await.unwrap(); @@ -483,9 +482,9 @@ async fn rejoin_during_the_cancel_skips_the_cache() { .unwrap(); let ts = |ms| Timestamp::from_millis(ms).unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(0), b"old".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(read_all(&mut group).await.unwrap(), [b"old".to_vec()], "{version}"); @@ -494,9 +493,9 @@ async fn rejoin_during_the_cancel_skips_the_cache() { // The publisher moves on while the relay's cancel is still in flight. for key in 1..=3u64 { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(key * 1000), b"new".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); @@ -556,18 +555,18 @@ async fn rejoin_waits_for_the_answers_first_frame() { // Held for fetches only: it keeps the relay's copy without subscribing. let _held = remote.track("video").unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(0), b"old".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(read_all(&mut group).await.unwrap(), [b"old".to_vec()], "{version}"); drop((group, sub)); crate::support::unwanted(track.demand()).await.unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(500), b"new".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); pair.server_transport.split_unis(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); @@ -617,9 +616,9 @@ async fn leaving_after_the_cache_window_keeps_the_latest_group() { .unwrap(); let track = broadcast.broadcast().create_track("catalog", timed()).unwrap(); broadcast.announce().unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"c0".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut options = MockConnectOptions::new(version); options.server_publish = Some(publisher.consume()); @@ -719,9 +718,9 @@ async fn rejoin_keeps_source_timestamps() { for (key, ms) in [(0, 123_456), (1, 654_321)] { let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); crate::support::wanted(track.demand()).await.unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(ts(ms), b"frame".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = loop { let group = sub.recv_group().await.unwrap().unwrap(); @@ -791,9 +790,9 @@ async fn quiet_catalog_survives_cache_expiry(version: Version, takeover: bool) { .unwrap(); let track = broadcast.broadcast().create_track("catalog", timed()).unwrap(); broadcast.announce().unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"catalog".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let upstream = |cost| { let mut options = MockConnectOptions::new(version); @@ -879,11 +878,11 @@ async fn quiet_catalog_survives_cache_expiry(version: Version, takeover: bool) { drop(group); // A newer catalog supersedes it, so the old one expires like any other group. - let mut newer = track.append_next().unwrap(); + let mut newer = track.append_group(None).unwrap(); newer .write_frame(Timestamp::from_millis(1000).unwrap(), b"newer".as_ref()) .unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); // Unnamed wires end the old holder on takeover. The late reader uses the // current route on every version, and keeps that copy live for the expiry check. assert_eq!(later.recv_group().await.unwrap().unwrap().start, 1, "{version}"); diff --git a/rs/moq-net/tests/integration/relay_upstream_close.rs b/rs/moq-net/tests/integration/relay_upstream_close.rs index 895718ad058..50754b39c71 100644 --- a/rs/moq-net/tests/integration/relay_upstream_close.rs +++ b/rs/moq-net/tests/integration/relay_upstream_close.rs @@ -15,7 +15,6 @@ use crate::support; use moq_net::track::Delay; -use support::AppendNext; use std::time::Duration; @@ -149,12 +148,12 @@ async fn round(name: &str, end: End) -> Vec { downstream.server_transport.hold_unis(); for track in &tracks { for key in 0..GROUPS { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); for index in 0..FRAMES { let at = Timestamp::from_millis(key * FRAMES + index).unwrap(); group.write_frame(at, index.to_string().into_bytes()).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } let _finished = track.clone().finish().unwrap(); } diff --git a/rs/moq-net/tests/integration/replacement.rs b/rs/moq-net/tests/integration/replacement.rs index 9a5c34436cc..dbd12c11102 100644 --- a/rs/moq-net/tests/integration/replacement.rs +++ b/rs/moq-net/tests/integration/replacement.rs @@ -11,7 +11,6 @@ //! from then on, so its holder follows the `Restart` instead. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -50,9 +49,9 @@ async fn next_event(announced: &mut origin::Routes) -> origin::RouteEvent { /// Write one group of one frame tagged `tag`. fn write(track: &track::Producer, tag: &str) { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), tag.as_bytes().to_vec()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// The next frame a subscription delivers, as text. diff --git a/rs/moq-net/tests/integration/route_change.rs b/rs/moq-net/tests/integration/route_change.rs index fa67d9da085..78417fc62ad 100644 --- a/rs/moq-net/tests/integration/route_change.rs +++ b/rs/moq-net/tests/integration/route_change.rs @@ -17,7 +17,6 @@ //! same way. use crate::support; -use support::AppendNext; use support::AtStart; use std::collections::BTreeMap; @@ -255,13 +254,13 @@ async fn route_change(version: &str, trigger: Trigger, position: Position) { let mut seen = Vec::new(); // Group 0 in full through `A`. - let mut group = topology.track.append_next().unwrap(); + let mut group = topology.track.append_group(None).unwrap(); for frame in 0..FRAMES { group.write_frame(group.at_start(), payload(0, frame)).unwrap(); expected.push((0, payload(0, frame))); seen.push(next(&mut rx).await); } - group.close().unwrap(); + group.finish().unwrap(); // Group 1: half through `A`, then the route changes. Between groups, the change // lands before the group starts at all. @@ -272,7 +271,7 @@ async fn route_change(version: &str, trigger: Trigger, position: Position) { if split == 0 { topology.trigger(trigger).await; } - let mut group = topology.track.append_next().unwrap(); + let mut group = topology.track.append_group(None).unwrap(); for frame in 0..FRAMES { if frame == split && split != 0 { topology.trigger(trigger).await; @@ -281,16 +280,16 @@ async fn route_change(version: &str, trigger: Trigger, position: Position) { expected.push((1, payload(1, frame))); seen.push(next(&mut rx).await); } - group.close().unwrap(); + group.finish().unwrap(); // Group 2 entirely through the replacement. - let mut group = topology.track.append_next().unwrap(); + let mut group = topology.track.append_group(None).unwrap(); for frame in 0..FRAMES { group.write_frame(group.at_start(), payload(2, frame)).unwrap(); expected.push((2, payload(2, frame))); seen.push(next(&mut rx).await); } - group.close().unwrap(); + group.finish().unwrap(); let render = |frames: &[(u64, Vec)]| { frames @@ -321,7 +320,7 @@ async fn route_flaps(version: &str) { let triggers = [Trigger::BetterRoute, Trigger::BetterRouteDies, Trigger::Disconnect]; let mut expected = Vec::new(); let mut seen = Vec::new(); - let mut group = topology.track.append_next().unwrap(); + let mut group = topology.track.append_group(None).unwrap(); for frame in 0..FRAMES * (triggers.len() as u64 + 1) { if frame % FRAMES == FRAMES / 2 && let Some(trigger) = triggers.get((frame / FRAMES) as usize) @@ -332,7 +331,7 @@ async fn route_flaps(version: &str) { expected.push((0, payload(0, frame))); seen.push(next(&mut rx).await); } - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(seen, expected, "{version}"); settle().await; @@ -348,15 +347,15 @@ async fn route_dies_without_instances(version: &str, trigger: Trigger) { let mut rx = read(sub); topology.standby().await; - let mut group = topology.track.append_next().unwrap(); + let mut group = topology.track.append_group(None).unwrap(); for frame in 0..FRAMES { group.write_frame(group.at_start(), payload(0, frame)).unwrap(); assert_eq!(next(&mut rx).await, (0, payload(0, frame)), "{version}"); } - group.close().unwrap(); + group.finish().unwrap(); topology.trigger(trigger).await; - let mut group = topology.track.append_next().unwrap(); + let mut group = topology.track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload(1, 0)).unwrap(); settle().await; match kio::clock::timeout(Duration::from_secs(10), rx.next()) @@ -380,8 +379,8 @@ async fn route_dies_without_instances(version: &str, trigger: Trigger) { let sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); let mut rx = read(sub); group.write_frame(group.at_start(), payload(1, 1)).unwrap(); - group.close().unwrap(); - let mut group = topology.track.append_next().unwrap(); + group.finish().unwrap(); + let mut group = topology.track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload(2, 0)).unwrap(); while next(&mut rx).await != (2, payload(2, 0)) {} } @@ -437,9 +436,9 @@ async fn route_dies_across_instances(version: &str, trigger: Trigger) { let _b_to_r = link(version, &relay_b, &standby).await; settle().await; - let mut group = track_a.append_next().unwrap(); + let mut group = track_a.append_group(None).unwrap(); group.write_frame(group.at_start(), tagged("A", 0, 0)).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(next(&mut rx).await, (0, tagged("A", 0, 0)), "{version}"); match trigger { @@ -506,9 +505,9 @@ async fn route_dies_across_instances(version: &str, trigger: Trigger) { assert!(!second.is_clone(&first), "{version}: joined the replaced broadcast"); let sub = second.track("video").unwrap().subscribe(None).await.unwrap(); let mut rx = read(sub); - let mut group = track_b.append_next().unwrap(); + let mut group = track_b.append_group(None).unwrap(); group.write_frame(group.at_start(), tagged("B", 0, 0)).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(next(&mut rx).await, (0, tagged("B", 0, 0)), "{version} {trigger:?}"); } @@ -529,7 +528,7 @@ async fn better_route_restarts(version: &str) { other => panic!("{version}: expected the route, got {other:?}"), } - let mut group = topology.track.append_next().unwrap(); + let mut group = topology.track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload(0, 0)).unwrap(); assert_eq!(next(&mut rx).await, (0, payload(0, 0)), "{version}"); let incumbent = consumer.request("live", None).await.unwrap(); @@ -552,8 +551,8 @@ async fn better_route_restarts(version: &str) { assert!(!replaced.is_clone(&incumbent), "{version}: joined the replaced front"); let sub = replaced.track("video").unwrap().subscribe(None).await.unwrap(); let mut fresh = read(sub); - group.close().unwrap(); - let mut group = topology.track.append_next().unwrap(); + group.finish().unwrap(); + let mut group = topology.track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload(1, 0)).unwrap(); while next(&mut fresh).await != (1, payload(1, 0)) {} assert_eq!( @@ -738,16 +737,16 @@ async fn lagging_route_dies(version: Version) { let b_r = lagged(version, &b, &r, Duration::ZERO).await; settle().await; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); for frame in 0..4 { write(&mut group, 0, frame); } - group.close().unwrap(); + group.finish().unwrap(); for frame in 0..4 { assert_eq!(next(&mut rx).await, (0, payload(0, frame)), "{version}"); } - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); write(&mut group, 1, 0); write(&mut group, 1, 1); assert_eq!(next(&mut rx).await, (1, payload(1, 0)), "{version}"); @@ -755,12 +754,12 @@ async fn lagging_route_dies(version: Version) { // P moves on while A is still behind. write(&mut group, 1, 2); write(&mut group, 1, 3); - group.close().unwrap(); - let mut group = track.append_next().unwrap(); + group.finish().unwrap(); + let mut group = track.append_group(None).unwrap(); for frame in 0..FRAMES { write(&mut group, 2, frame); } - let group = group.close().unwrap(); + let group = group.finish().unwrap(); a_r.server.abort(Error::Cancel); a_r.client.abort(Error::Cancel); @@ -851,7 +850,7 @@ async fn undetected_outage(budget: Duration) -> BTreeMap> { } kio::clock::sleep(STEP).await; } - group.close().unwrap(); + group.finish().unwrap(); if key == O_NOTICES { o_m1.server.abort(Error::Cancel); o_m1.client.abort(Error::Cancel); @@ -985,7 +984,7 @@ async fn redundant_pair_follows_the_next_instance(version: &str, loss: Loss) { tagged(replica.name, key, 0), ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } }; write(&mut replicas, 0); @@ -1101,7 +1100,7 @@ async fn replaced_behind_a_relay(version: &str) { let mut dead = None; for key in 0..3 { for replica in &mut replicas { - replica.group = Some(replica.track.append_next().unwrap()); + replica.group = Some(replica.track.append_group(None).unwrap()); } for frame in 0..FRAMES { if key == 1 && frame == FRAMES / 2 { @@ -1123,7 +1122,7 @@ async fn replaced_behind_a_relay(version: &str) { } } for replica in &mut replicas { - replica.group.take().unwrap().close().unwrap(); + replica.group.take().unwrap().finish().unwrap(); } } settle().await; @@ -1222,12 +1221,12 @@ async fn compression_changes_behind_a_relay(compress: bool) { settle().await; } for replica in &mut replicas { - let mut group = replica.track.append_next().unwrap(); + let mut group = replica.track.append_group(None).unwrap(); for frame in 0..FRAMES { let timestamp = Timestamp::from_micros(1_000_000 + key * 100_000 + frame * 1_000).unwrap(); group.write_frame(timestamp, tagged(replica.name, key, frame)).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } if compress || dead.is_none() { for frame in 0..FRAMES { @@ -1308,13 +1307,13 @@ async fn producer_replaced(version: &str) { let first = producers.next().await.unwrap(); for key in 0..2 { - let mut group = first.append_next().unwrap(); + let mut group = first.append_group(None).unwrap(); assert_eq!(group.start, key, "{version}"); for frame in 0..FRAMES { group.write_frame(group.at_start(), payload(key, frame)).unwrap(); assert_eq!(next(&mut rx).await, (key, payload(key, frame)), "{version}"); } - group.close().unwrap(); + group.finish().unwrap(); } // The encoder restarts: the old producer goes away mid-broadcast, and the resumed @@ -1331,7 +1330,7 @@ async fn producer_replaced(version: &str) { group.write_frame(group.at_start(), payload(2, frame)).unwrap(); assert_eq!(next(&mut rx).await, (2, payload(2, frame)), "{version}"); } - group.close().unwrap(); + group.finish().unwrap(); settle().await; assert!( diff --git a/rs/moq-net/tests/integration/route_cluster.rs b/rs/moq-net/tests/integration/route_cluster.rs index e0147ba7721..bf16fabd94a 100644 --- a/rs/moq-net/tests/integration/route_cluster.rs +++ b/rs/moq-net/tests/integration/route_cluster.rs @@ -240,7 +240,7 @@ impl Publisher { let timestamp = Timestamp::from_micros(1_000_000 + key * 100_000 + frame * 1_000).unwrap(); group.write_frame(timestamp, tagged(self.name, key, frame)).unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); } } diff --git a/rs/moq-net/tests/integration/route_failover.rs b/rs/moq-net/tests/integration/route_failover.rs index cecf4ac3df8..521607dbb16 100644 --- a/rs/moq-net/tests/integration/route_failover.rs +++ b/rs/moq-net/tests/integration/route_failover.rs @@ -152,7 +152,7 @@ impl Feed { let index = self.written.len() as u64; if index.is_multiple_of(FRAMES) { if let Some(group) = self.group.take() { - group.close().unwrap(); + group.finish().unwrap(); } self.group = Some(self.track.append_group(index / FRAMES).unwrap()); } diff --git a/rs/moq-net/tests/integration/route_health.rs b/rs/moq-net/tests/integration/route_health.rs index c1039dcc981..c09e9ab3a63 100644 --- a/rs/moq-net/tests/integration/route_health.rs +++ b/rs/moq-net/tests/integration/route_health.rs @@ -12,7 +12,6 @@ use super::route_change::{Delivery, link, payload, priced_link, produce_origin, use std::collections::BTreeSet; use std::time::Duration; -use crate::support::AppendNext; use futures::channel::mpsc; use moq_net::{Error, StreamError, Timestamp, Version, origin, track}; @@ -109,7 +108,7 @@ async fn silent_kill(budget: Duration, detect: Duration) -> Vec { m1_e.client.abort(Error::Cancel); } } - group.close().unwrap(); + group.finish().unwrap(); } settle().await; drain(&mut rx, &mut seen); @@ -230,14 +229,14 @@ async fn payload_stall(stall: Stall, span: Duration) -> (Observed, Observed) { let mut write = async |groups: u64| { for _ in 0..groups { let key = tick / FRAMES; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); for frame in 0..FRAMES { let timestamp = Timestamp::from_millis(tick * STEP.as_millis() as u64).unwrap(); group.write_frame(timestamp, payload(key, frame)).unwrap(); kio::clock::sleep(STEP).await; tick += 1; } - group.close().unwrap(); + group.finish().unwrap(); } }; write(2).await; diff --git a/rs/moq-net/tests/integration/segmented_frame.rs b/rs/moq-net/tests/integration/segmented_frame.rs index 971dd6741c9..d2ce743d6c8 100644 --- a/rs/moq-net/tests/integration/segmented_frame.rs +++ b/rs/moq-net/tests/integration/segmented_frame.rs @@ -8,7 +8,6 @@ use std::time::Duration; use bytes::Bytes; use moq_net::{Timestamp, Version, frame, origin, track}; -use crate::support::AppendNext; use crate::support::harness::{MockConnectOptions, connect_mock, spawn, subscribed}; const TIMEOUT: Duration = Duration::from_secs(10); @@ -52,7 +51,7 @@ async fn a_segmented_frame_crosses_whole() { subscribed(&track).await; // Two frames: one read whole, one streamed. - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); for _ in 0..2 { let mut frame = group .create_frame(frame::Info { @@ -65,7 +64,7 @@ async fn a_segmented_frame_crosses_whole() { } group = frame.finish().unwrap(); } - group.close().unwrap(); + group.finish().unwrap(); let mut group = kio::clock::timeout(TIMEOUT, sub.recv_group()) .await diff --git a/rs/moq-net/tests/integration/session_close.rs b/rs/moq-net/tests/integration/session_close.rs index a1f02df019d..f019dc8eb7a 100644 --- a/rs/moq-net/tests/integration/session_close.rs +++ b/rs/moq-net/tests/integration/session_close.rs @@ -6,7 +6,6 @@ //! Deterministic: simulated time over the mock transport. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -154,9 +153,9 @@ async fn close_delivers_a_finished_track_for(version: &str) { pair, track, reader, .. } = setup(version).await; - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"last".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let started = kio::clock::now(); @@ -298,9 +297,9 @@ async fn close_tail_for(version: &str) { } = setup(version).await; pair.client_transport.ack_fins(); pair.client_transport.hold_unis(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"last".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let close = kio::clock::sim::spawn(pair.client.close()); kio::clock::sleep(Duration::from_millis(100)).await; @@ -336,9 +335,9 @@ async fn close_requires_subscriber_fin_for(version: &str) { } = setup(version).await; pair.client_transport.ack_fins(); pair.server_transport.withhold_bidi_fins(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"last".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); let started = kio::clock::now(); let res = pair.client.close().await; @@ -369,9 +368,9 @@ async fn peer_close_reads_buffered_tail(version: &str) { // Delivery to the transport acknowledges the FIN before the receiving // protocol driver has consumed the buffered stream. pair.client_transport.ack_fins(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"last".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _track = track.finish().unwrap(); pair.client.close().await.expect("released draft still drains on ACKs"); let (got, _) = reader.await.unwrap(); @@ -395,9 +394,9 @@ async fn peer_close_before_receiver_poll_keeps_buffered_tail() { } = setup_with_gate(version, Some(gate.consume())).await; *gate.write().ok().expect("receiver gate remains open") = false; pair.client_transport.ack_fins(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"last".as_slice()).unwrap(); - group.close().unwrap(); + group.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. diff --git a/rs/moq-net/tests/integration/settled_end_survives_abort.rs b/rs/moq-net/tests/integration/settled_end_survives_abort.rs index af5063ee4d3..5d62d75b92e 100644 --- a/rs/moq-net/tests/integration/settled_end_survives_abort.rs +++ b/rs/moq-net/tests/integration/settled_end_survives_abort.rs @@ -6,7 +6,6 @@ //! consumer that has not read them yet still gets them, then the clean end. use crate::support; -use support::AppendNext; use support::AtStart; use moq_net::Error; @@ -43,11 +42,11 @@ async fn round(abort: bool, ordered: bool) -> (Vec, Option) { let mut consumer = track.subscribe(subscription); for _ in 0..GROUPS { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"frame".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } - track.finish_at(moq_net::track::Position::group(GROUPS), None).unwrap(); + track.finish_at(moq_net::track::Position::group(GROUPS)).unwrap(); // Every group below the end is finished: the end has settled and the track is // complete. Nothing has been read yet. if abort { diff --git a/rs/moq-net/tests/integration/slow_joiner.rs b/rs/moq-net/tests/integration/slow_joiner.rs index e660527eb4e..6a3c71ee731 100644 --- a/rs/moq-net/tests/integration/slow_joiner.rs +++ b/rs/moq-net/tests/integration/slow_joiner.rs @@ -73,7 +73,7 @@ async fn stalled_read(version: Version, budget: Duration) -> BTreeSet { group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); kio::clock::sleep(Duration::from_secs(1)).await; } let _source = source.finish().unwrap(); diff --git a/rs/moq-net/tests/integration/socket.rs b/rs/moq-net/tests/integration/socket.rs index 5b91e4351c9..71aed98bf0a 100644 --- a/rs/moq-net/tests/integration/socket.rs +++ b/rs/moq-net/tests/integration/socket.rs @@ -9,7 +9,6 @@ use moq_net::broadcast::TracksEvent; use moq_net::socket::{Endpoint, TrackStream}; use moq_net::{Error, StreamError, Version, group, origin, track}; -use crate::support::AppendNext; use crate::support::harness::{MockConnectOptions, MockPair, connect_mock, spawn}; const TIMEOUT: Duration = Duration::from_secs(10); @@ -98,11 +97,11 @@ async fn connect_track(dialer: &Endpoint, acceptor: &Endpoint) -> (TrackStream, /// Write `payload` as one message of a session: one group. fn send(track: &track::Producer, payload: &'static [u8]) { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::unscaled(group.start), payload) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// Read the next message from a session, or `None` once the peer finished. @@ -182,7 +181,7 @@ async fn track_messages_are_read_in_key() { group .write_frame(moq_net::Timestamp::unscaled(group.start), payload) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; write(1, b"second"); // Let the later message arrive first. @@ -212,7 +211,7 @@ async fn a_lost_track_message_does_not_block_later_ones() { group .write_frame(moq_net::Timestamp::unscaled(group.start), payload) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); }; // Message 0 is never written: message 1 waits out the budget, then is read. write(1, b"one"); diff --git a/rs/moq-net/tests/integration/source_errors.rs b/rs/moq-net/tests/integration/source_errors.rs index eba457f7a62..9dbee3086f5 100644 --- a/rs/moq-net/tests/integration/source_errors.rs +++ b/rs/moq-net/tests/integration/source_errors.rs @@ -7,7 +7,6 @@ //! moq-transport's PUBLISH_DONE registry has no code for either error. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -137,9 +136,9 @@ async fn track_in_flight_through_a_dead_upstream_is_unroutable() { let setup = relayed(version).await; let track = setup.broadcast.broadcast().create_track("video", timed()).unwrap(); let mut sub = setup.remote.track("video").unwrap().subscribe(None).await.unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"head".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); kio::clock::timeout(TIMEOUT, sub.recv_group()) .await .expect("group timeout") @@ -165,9 +164,9 @@ async fn withdrawn_broadcast_keeps_the_source_error() { let setup = relayed(version).await; let track = setup.broadcast.broadcast().create_track("video", timed()).unwrap(); let mut sub = setup.remote.track("video").unwrap().subscribe(None).await.unwrap(); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"head".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); kio::clock::timeout(TIMEOUT, sub.recv_group()) .await .expect("group timeout") diff --git a/rs/moq-net/tests/integration/stream_credit.rs b/rs/moq-net/tests/integration/stream_credit.rs index 3cc3118418c..fba2bc2b206 100644 --- a/rs/moq-net/tests/integration/stream_credit.rs +++ b/rs/moq-net/tests/integration/stream_credit.rs @@ -7,7 +7,6 @@ use std::time::Duration; use moq_net::{Version, origin, track}; -use crate::support::AppendNext; use crate::support::AtStart; use crate::support::harness::{MockConnectOptions, connect_mock, spawn}; @@ -64,9 +63,9 @@ async fn one_stream_credit_serves_every_backlogged_group() { for _ in 0..4 { for track in &tracks { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"x".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } } for subscriber in &mut subscribers { @@ -124,7 +123,7 @@ async fn a_newer_group_resets_an_unfinished_older_one() { let mut subscriber = remote.track("0").unwrap().subscribe(prefs).await.unwrap(); // Never finished, so its stream holds the only credit. - let mut older = track.append_next().unwrap(); + let mut older = track.append_group(None).unwrap(); older.write_frame(older.at_start(), b"old".as_slice()).unwrap(); let first = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) .await @@ -133,9 +132,9 @@ async fn a_newer_group_resets_an_unfinished_older_one() { .unwrap(); assert_eq!(first.start, 0, "{version}"); - let mut newer = track.append_next().unwrap(); + let mut newer = track.append_group(None).unwrap(); newer.write_frame(newer.at_start(), b"new".as_slice()).unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); let group = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) .await .unwrap_or_else(|_| panic!("{version}: the newer group waits behind the older one")) @@ -187,7 +186,7 @@ async fn a_reset_group_resumes_without_loss() { let mut subscriber = remote.track("0").unwrap().subscribe(prefs).await.unwrap(); // Unfinished, so its stream holds the only credit until the newer group resets it. - let mut older = track.append_next().unwrap(); + let mut older = track.append_group(None).unwrap(); older.write_frame(older.at_start(), b"a".as_slice()).unwrap(); let mut paused = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) .await @@ -201,9 +200,9 @@ async fn a_reset_group_resumes_without_loss() { .unwrap(); assert_eq!(first.map(|frame| frame.payload), Some(bytes::Bytes::from_static(b"a"))); - let mut newer = track.append_next().unwrap(); + let mut newer = track.append_group(None).unwrap(); newer.write_frame(newer.at_start(), b"new".as_slice()).unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); let group = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) .await .expect("the newer group takes the older one's credit") @@ -214,7 +213,7 @@ async fn a_reset_group_resumes_without_loss() { // Written after the reset: a continuation carries them, behind the frame already held. older.write_frame(older.at_start(), b"b".as_slice()).unwrap(); older.write_frame(older.at_start(), b"c".as_slice()).unwrap(); - older.close().unwrap(); + older.finish().unwrap(); let mut rest = Vec::new(); while let Some(frame) = kio::clock::timeout(Duration::from_secs(5), paused.read_frame()) .await @@ -263,7 +262,7 @@ async fn a_reset_group_finishing_without_more_frames_ends_cleanly() { .with_delay(track::Delay::default().with_max(Duration::from_secs(30))); let mut subscriber = remote.track("0").unwrap().subscribe(prefs).await.unwrap(); - let mut older = track.append_next().unwrap(); + let mut older = track.append_group(None).unwrap(); older.write_frame(older.at_start(), b"a".as_slice()).unwrap(); let mut paused = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) .await @@ -276,9 +275,9 @@ async fn a_reset_group_finishing_without_more_frames_ends_cleanly() { .unwrap(); assert_eq!(first.map(|frame| frame.payload), Some(bytes::Bytes::from_static(b"a"))); - let mut newer = track.append_next().unwrap(); + let mut newer = track.append_group(None).unwrap(); newer.write_frame(newer.at_start(), b"new".as_slice()).unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); let group = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) .await .expect("the newer group takes the older one's credit") @@ -287,7 +286,7 @@ async fn a_reset_group_finishing_without_more_frames_ends_cleanly() { assert_eq!(group.start, 1); // No frame follows the reset: the group just ends. - older.close().unwrap(); + older.finish().unwrap(); let end = kio::clock::timeout(Duration::from_secs(5), paused.read_frame()) .await .expect("the paused group continues"); @@ -343,7 +342,7 @@ async fn a_waiting_continuation_lets_a_newer_group_through() { let mut groups = Vec::new(); let mut readers = Vec::new(); for key in 0..2 { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"a".as_slice()).unwrap(); let reader = next!(); assert_eq!(reader.start, key); @@ -352,15 +351,15 @@ async fn a_waiting_continuation_lets_a_newer_group_through() { } // The newest outranks group 1's stream, so it resets that one too. - let mut newest = track.append_next().unwrap(); + let mut newest = track.append_group(None).unwrap(); newest.write_frame(newest.at_start(), b"new".as_slice()).unwrap(); - newest.close().unwrap(); + newest.finish().unwrap(); assert_eq!(next!().start, 2, "the newest group waits behind a continuation"); // The paused groups continue highest-ranked first: newest first in descending order. for (mut group, mut reader) in groups.into_iter().zip(readers).rev() { group.write_frame(group.at_start(), b"b".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut frames = Vec::new(); while let Some(frame) = kio::clock::timeout(Duration::from_secs(5), reader.read_frame()) .await @@ -425,9 +424,9 @@ async fn a_subscription_past_the_credit_is_served_once_credit_returns() { .await .unwrap_or_else(|_| panic!("{version}: the waiting subscription never got credit")) .unwrap_or_else(|err| panic!("{version}: the waiting subscription failed: {err}")); - let mut group = second.append_next().unwrap(); + let mut group = second.append_group(None).unwrap(); group.write_frame(group.at_start(), b"x".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let group = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) .await .unwrap_or_else(|_| panic!("{version}: no group after credit returned")) @@ -488,9 +487,9 @@ async fn an_abandoned_setup_returns_credit_with_the_publisher_still_live() { .await .unwrap_or_else(|_| panic!("{version}: the waiting subscription never got credit")) .unwrap_or_else(|err| panic!("{version}: the waiting subscription failed: {err}")); - let mut group = third.append_next().unwrap(); + let mut group = third.append_group(None).unwrap(); group.write_frame(group.at_start(), b"x".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let group = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) .await .unwrap_or_else(|_| panic!("{version}: no group after credit returned")) @@ -500,9 +499,9 @@ async fn an_abandoned_setup_returns_credit_with_the_publisher_still_live() { drop(group); drop(subscriber); let mut resumed = remote.track("second").unwrap().subscribe(None).await.unwrap(); - let mut group = second.append_next().unwrap(); + let mut group = second.append_group(None).unwrap(); group.write_frame(group.at_start(), b"still live".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let group = kio::clock::timeout(Duration::from_secs(5), resumed.recv_group()) .await .unwrap() @@ -568,11 +567,11 @@ async fn a_waiting_late_group_lets_a_newer_group_through() { // Late and below the held stream: it waits for credit it cannot make room for. let mut late = track.create_group(moq_net::group::Info { start: 0 }).unwrap(); late.write_frame(late.at_start(), b"late".as_slice()).unwrap(); - late.close().unwrap(); + late.finish().unwrap(); let mut newer = track.create_group(moq_net::group::Info { start: 3 }).unwrap(); newer.write_frame(newer.at_start(), b"new".as_slice()).unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); assert_eq!(next!("the newer group waits behind the late one").start, 3, "{version}"); drop(held); } @@ -633,12 +632,12 @@ async fn a_shed_late_group_lets_a_newer_group_through() { for key in [1, 0] { let mut late = track.create_group(moq_net::group::Info { start: key }).unwrap(); late.write_frame(late.at_start(), b"late".as_slice()).unwrap(); - late.close().unwrap(); + late.finish().unwrap(); } let mut newer = track.create_group(moq_net::group::Info { start: 4 }).unwrap(); newer.write_frame(newer.at_start(), b"new".as_slice()).unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); assert_eq!( next!("the newer group waits behind the late ones").start, 4, @@ -695,18 +694,18 @@ async fn an_ascending_backlog_waits_behind_a_waiting_group() { } // Unfinished, so its stream holds the only credit, and outranks every newer group. - let mut held = track.append_next().unwrap(); + let mut held = track.append_group(None).unwrap(); held.write_frame(held.at_start(), b"held".as_slice()).unwrap(); assert_eq!(next!("the held group arrives").start, 0, "{version}"); for _ in 0..3 { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"x".as_slice()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } // Let the publisher take what it would before credit returns. kio::clock::sleep(Duration::from_millis(100)).await; - held.close().unwrap(); + held.finish().unwrap(); let mut received = Vec::new(); while received.len() < 3 { @@ -757,7 +756,7 @@ async fn a_paused_group_given_up_while_it_waits_is_dropped() { let mut groups = Vec::new(); let mut readers = Vec::new(); for start in 0..3 { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"a".as_slice()).unwrap(); let mut reader = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) .await @@ -826,7 +825,7 @@ async fn a_closing_stream_does_not_rank_a_waiting_group() { // Group 7 finishes, so its stream waits for the acknowledgement; group 10 holds the other. let mut closing = track.create_group(moq_net::group::Info { start: 7 }).unwrap(); closing.write_frame(closing.at_start(), b"closing".as_slice()).unwrap(); - closing.close().unwrap(); + closing.finish().unwrap(); let mut held = track.create_group(moq_net::group::Info { start: 10 }).unwrap(); held.write_frame(held.at_start(), b"held".as_slice()).unwrap(); kio::clock::sleep(SETTLE).await; @@ -834,12 +833,12 @@ async fn a_closing_stream_does_not_rank_a_waiting_group() { // Ranked above group 7 but below group 10: it can only wait for group 7's credit. let mut late = track.create_group(moq_net::group::Info { start: 8 }).unwrap(); late.write_frame(late.at_start(), b"late".as_slice()).unwrap(); - late.close().unwrap(); + late.finish().unwrap(); kio::clock::sleep(SETTLE).await; let mut newer = track.create_group(moq_net::group::Info { start: 11 }).unwrap(); newer.write_frame(newer.at_start(), b"new".as_slice()).unwrap(); - newer.close().unwrap(); + newer.finish().unwrap(); loop { let group = kio::clock::timeout(Duration::from_secs(5), subscriber.recv_group()) diff --git a/rs/moq-net/tests/integration/subscribe_ranges.rs b/rs/moq-net/tests/integration/subscribe_ranges.rs index 36b901cf566..66523b69ed3 100644 --- a/rs/moq-net/tests/integration/subscribe_ranges.rs +++ b/rs/moq-net/tests/integration/subscribe_ranges.rs @@ -37,7 +37,7 @@ fn write_group(track: &moq_net::track::Producer, key: u64) { group .write_frame(Timestamp::from_millis(key).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } /// The next group's key, or `None` once the track ends or nothing arrives in time. @@ -238,7 +238,7 @@ async fn range_fixture_history(version: &str, relay: bool, history: u64) -> Rang group .write_frame(Timestamp::from_millis(key).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let relay_origin = produce_origin(2); let subscriber = produce_origin(3); @@ -373,7 +373,7 @@ async fn draft22_updates_both_bounds_across_cached_groups() { group .write_frame(Timestamp::from_millis(6).unwrap(), b"later".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(next(&mut reader).await, Some(6), "relay={relay}"); } } @@ -470,7 +470,7 @@ async fn draft22_can_widen_while_the_current_group_is_quiet() { let mut got = [next(&mut history).await.unwrap(), next(&mut history).await.unwrap()]; got.sort_unstable(); assert_eq!(got, [0, 1], "relay={relay}"); - quiet.close().unwrap(); + quiet.finish().unwrap(); assert!( kio::clock::timeout(TIMEOUT, current.read_frame()) .await @@ -532,7 +532,7 @@ async fn draft18_updates_narrow_then_widen() { group .write_frame(Timestamp::from_millis(key).unwrap(), key.to_be_bytes().as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } reader.update(initial).unwrap(); let mut seen = Vec::new(); @@ -584,7 +584,7 @@ async fn empty_ranges_retire_the_wire_and_can_widen_again() { group .write_frame(Timestamp::from_millis(6).unwrap(), b"sibling".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(next(&mut sibling).await, Some(6), "{version} relay={relay}"); reader.update(live.clone()).unwrap(); assert_eq!(next(&mut reader).await, Some(6)); @@ -613,7 +613,7 @@ async fn empty_ranges_retire_the_wire_and_can_widen_again() { group .write_frame(Timestamp::from_millis(7).unwrap(), b"resumed".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); reader.update(live).unwrap(); assert_eq!(next(&mut reader).await, Some(7), "{version} relay={relay}"); } @@ -662,7 +662,7 @@ async fn draft22_cold_widening_finishes_the_largest_group() { group .write_frame(Timestamp::from_millis(key).unwrap(), key.to_be_bytes().as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } reader .update(initial.clone().with_ranges([support::keys(start..)])) @@ -802,7 +802,7 @@ async fn holes_through_a_relay(version: &str, budget: Option) { group .write_frame(Timestamp::from_millis(key).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } // Warm the relay's cache with groups 1 and 5 alone, one-group runs every wire fills. @@ -843,7 +843,7 @@ async fn holes_through_a_relay(version: &str, budget: Option) { group .write_frame(Timestamp::from_millis(LIVE_MILLIS).unwrap(), b"x".as_slice()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let _finished = fixture.track.clone().finish().unwrap(); // The read ends only once every key in range was delivered or skipped. loop { diff --git a/rs/moq-net/tests/integration/subscribe_tracks.rs b/rs/moq-net/tests/integration/subscribe_tracks.rs index b48c4aa4284..e051a82d196 100644 --- a/rs/moq-net/tests/integration/subscribe_tracks.rs +++ b/rs/moq-net/tests/integration/subscribe_tracks.rs @@ -5,7 +5,6 @@ //! Deterministic: paused time and a single-threaded runtime over the mock transport. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -95,9 +94,9 @@ async fn setup(version: Version) -> Setup { } async fn deliver(setup: &mut Setup, payload: &'static [u8]) { - let mut group = setup.track.append_next().unwrap(); + let mut group = setup.track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let got = kio::clock::timeout(TIMEOUT, setup.frames.next()) .await .expect("frame timed out") diff --git a/rs/moq-net/tests/integration/subscribe_with_track.rs b/rs/moq-net/tests/integration/subscribe_with_track.rs index 8a1e088b163..6405591d59f 100644 --- a/rs/moq-net/tests/integration/subscribe_with_track.rs +++ b/rs/moq-net/tests/integration/subscribe_with_track.rs @@ -10,7 +10,6 @@ //! stream and are unchanged. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -76,9 +75,9 @@ async fn first_frame(version: &str, relays: usize, arrival: Arrival) -> Duration moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) .unwrap(); - let mut cached = track.append_next().unwrap(); + let mut cached = track.append_group(None).unwrap(); cached.write_frame(cached.at_start(), b"cached".as_ref()).unwrap(); - cached.close().unwrap(); + cached.finish().unwrap(); broadcast.announce().unwrap(); let consumer = nodes.last().unwrap().consume(); @@ -123,10 +122,10 @@ async fn first_frame(version: &str, relays: usize, arrival: Arrival) -> Duration let elapsed = kio::clock::now() - start; assert_eq!(frame.payload.as_ref(), b"cached", "{label}"); - let mut live = track.append_next().unwrap(); + let mut live = track.append_group(None).unwrap(); live.write_frame(Timestamp::from_millis(1).unwrap(), b"live".as_ref()) .unwrap(); - live.close().unwrap(); + live.finish().unwrap(); let mut group = kio::clock::timeout(TIMEOUT, subscriber.recv_group()) .await .unwrap_or_else(|_| panic!("{label}: the live group did not arrive")) diff --git a/rs/moq-net/tests/integration/subscriber_max_age.rs b/rs/moq-net/tests/integration/subscriber_max_age.rs index cd829ed8c0d..0f1c08154c5 100644 --- a/rs/moq-net/tests/integration/subscriber_max_age.rs +++ b/rs/moq-net/tests/integration/subscriber_max_age.rs @@ -6,7 +6,6 @@ use std::time::Duration; use moq_net::{Version, origin, track}; -use crate::support::AppendNext; use crate::support::AtStart; use crate::support::harness::{peer, spawn}; @@ -51,9 +50,9 @@ async fn relay_forwards_the_most_tolerant_subscriber_max_age() { track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) .unwrap(); - let mut group = source.append_next().unwrap(); + let mut group = source.append_group(None).unwrap(); group.write_frame(group.at_start(), b"catalog").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); broadcast.announce().unwrap(); let consumer = viewer.consume(); let remote = consumer @@ -126,9 +125,9 @@ async fn relay_forwards_the_smallest_stated_min_delay() { track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) .unwrap(); - let mut group = source.append_next().unwrap(); + let mut group = source.append_group(None).unwrap(); group.write_frame(group.at_start(), b"catalog").unwrap(); - group.close().unwrap(); + group.finish().unwrap(); broadcast.announce().unwrap(); let cache = |origin: &origin::Producer| { diff --git a/rs/moq-net/tests/integration/subscription_end_integrity.rs b/rs/moq-net/tests/integration/subscription_end_integrity.rs index 31912620a1c..37b8c245c6b 100644 --- a/rs/moq-net/tests/integration/subscription_end_integrity.rs +++ b/rs/moq-net/tests/integration/subscription_end_integrity.rs @@ -20,7 +20,6 @@ //! send" step is an idle-advance rather than a race. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -120,11 +119,11 @@ async fn round(drop_session: bool) -> (Vec>, Option) { .expect("no subscriber appeared") .unwrap(); - let mut head = track.append_next().unwrap(); + let mut head = track.append_group(None).unwrap(); for payload in HEAD { head.write_frame(head.at_start(), payload).unwrap(); } - head.close().unwrap(); + head.finish().unwrap(); kio::clock::timeout(TIMEOUT, drained_rx) .await .expect("the head group never arrived") @@ -133,7 +132,7 @@ async fn round(drop_session: bool) -> (Vec>, Option) { // The final group opens and its first frame is sent, then the track's end is // declared: SUBSCRIBE_FINISH reaches the subscriber with the group still open, as it // does whenever a finish races a group still in flight. - let mut tail = track.append_next().unwrap(); + let mut tail = track.append_group(None).unwrap(); tail.write_frame(tail.at_start(), TAIL[0]).unwrap(); let track = track.finish().unwrap(); settle().await; @@ -141,7 +140,7 @@ async fn round(drop_session: bool) -> (Vec>, Option) { // The rest of the group, its clean end, and the disconnect happen with no await in // between, so the session has sent none of it when it closes. tail.write_frame(tail.at_start(), TAIL[1]).unwrap(); - tail.close().unwrap(); + tail.finish().unwrap(); drop(track); let server = if drop_session { drop(server); @@ -272,7 +271,7 @@ async fn killed(version: &str, kill: Kill) -> (Option, Option moq_net::Result; -} - -impl AppendNext for track::Producer { - fn append_next(&self) -> moq_net::Result { - self.append_group(self.largest().map_or(0, |largest| largest.group + 1)) - } -} - /// A frame time for tests whose frames carry no time of their own. #[allow(dead_code, reason = "shared by several test binaries, each using only part of it")] pub trait AtStart { @@ -35,6 +21,15 @@ impl AtStart for group::Producer { } } +/// A fill the test expects to name groups rather than look up a time. +#[allow(dead_code, reason = "shared by several test binaries, each using only part of it")] +pub fn groups(fill: track::Fill) -> track::FillGroups { + let track::Fill::Groups(fill) = fill else { + panic!("a run of groups, not a time lookup"); + }; + fill +} + /// The groups from the one containing `keys`' start through the one containing its end, as /// time anchors: on a track whose groups start at consecutive keys, the groups with those keys. /// diff --git a/rs/moq-net/tests/integration/track_abort_over_session.rs b/rs/moq-net/tests/integration/track_abort_over_session.rs index 2a173063982..9fda5cb6f5b 100644 --- a/rs/moq-net/tests/integration/track_abort_over_session.rs +++ b/rs/moq-net/tests/integration/track_abort_over_session.rs @@ -4,7 +4,6 @@ //! subscriber on the far side of one session. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -51,7 +50,7 @@ async fn after_abort(version: &str, hops: u32) { .unwrap() .unwrap(); let mut sub = remote.track("video").unwrap().subscribe(None).await.unwrap(); - let mut open = track.append_next().unwrap(); + let mut open = track.append_group(None).unwrap(); open.write_frame(open.at_start(), b"head".as_ref()).unwrap(); let mut group = sub.recv_group().await.unwrap().unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload, b"head".as_ref()); diff --git a/rs/moq-net/tests/integration/track_stream_demand.rs b/rs/moq-net/tests/integration/track_stream_demand.rs index 9e8c64b3bdc..8ae6dfb1324 100644 --- a/rs/moq-net/tests/integration/track_stream_demand.rs +++ b/rs/moq-net/tests/integration/track_stream_demand.rs @@ -9,7 +9,6 @@ //! `used` with a round trip per hop in between. use crate::support; -use support::AppendNext; use support::AtStart; use std::{cell::RefCell, rc::Rc, time::Duration}; @@ -98,7 +97,7 @@ async fn one_used_edge(version: &str, relays: usize, reorder: bool) { .get_or_insert_with(|| record_track!(request.demand())); kio::clock::sleep(STARTUP).await; let track = request.accept(timed()); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"key".as_ref()).unwrap(); served.0.borrow_mut().push((track, group)); } @@ -191,7 +190,7 @@ async fn bare_handle_is_lazy(version: &str, relays: usize) { let publisher = kio::clock::sim::spawn(async move { while let Ok(request) = dynamic.requested_track().await { let track = request.accept(timed()); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), b"key".as_ref()).unwrap(); served.borrow_mut().push((track, group)); } diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index ffab22ecc21..b0d6612703d 100644 --- a/rs/moq-net/tests/integration/track_tail.rs +++ b/rs/moq-net/tests/integration/track_tail.rs @@ -12,7 +12,6 @@ //! Time is paused, so the one-second grace for a group that never arrives is free. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -163,13 +162,11 @@ async fn round(version: &str, late: Late, final_key: u64, max_delay: Option 0 { - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), PAYLOAD).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } - track - .finish_at(moq_net::track::Position::group(final_key), None) - .unwrap(); + track.finish_at(moq_net::track::Position::group(final_key)).unwrap(); drop(track); if final_key > 0 { @@ -312,9 +309,9 @@ async fn draft18_a_join_reaching_a_finished_track_keeps_its_head() { _keep, } = connect("moq-transport-18").await; pair.client_transport.set_latency(RTT / 2); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), PAYLOAD).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let reader = kio::clock::sim::spawn(async move { let mut sub = remote @@ -380,9 +377,9 @@ async fn ietf_leaving_cancels_a_blocked_end_of_track() { .await .expect("no subscriber appeared"); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), PAYLOAD).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = kio::clock::timeout(TIMEOUT, sub.recv_group()) .await .expect("group timeout") @@ -447,8 +444,8 @@ async fn a_group_whose_first_frame_trails_its_header_is_delivered() { .await .expect("no subscriber appeared"); - track.finish_at(moq_net::track::Position::group(2), None).unwrap(); - let groups = [track.append_next().unwrap(), track.append_next().unwrap()]; + track.finish_at(moq_net::track::Position::group(2)).unwrap(); + let groups = [track.append_group(None).unwrap(), track.append_group(None).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; @@ -459,7 +456,7 @@ async fn a_group_whose_first_frame_trails_its_header_is_delivered() { for mut group in groups { group.write_frame(group.at_start(), PAYLOAD).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut groups = kio::clock::timeout(TIMEOUT, reader) .await diff --git a/rs/moq-net/tests/integration/tracks.rs b/rs/moq-net/tests/integration/tracks.rs index 4fdfbdca865..d96c6da3ae5 100644 --- a/rs/moq-net/tests/integration/tracks.rs +++ b/rs/moq-net/tests/integration/tracks.rs @@ -5,7 +5,6 @@ //! after the sync is new at the source. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -141,11 +140,11 @@ async fn a_listed_track_serves_its_cached_group() { assert_eq!(next(&mut tracks).await, "synced"); let late = broadcast.broadcast().create_track("late", None).unwrap(); - let mut group = late.append_next().unwrap(); + let mut group = late.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::unscaled(group.start), &b"first"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(next(&mut tracks).await, "+late"); let mut sub = kio::clock::timeout(TIMEOUT, remote.track("late").unwrap().subscribe(None)) diff --git a/rs/moq-net/tests/integration/tracks_ietf.rs b/rs/moq-net/tests/integration/tracks_ietf.rs index 368b4a3c54f..7d4e352d7ba 100644 --- a/rs/moq-net/tests/integration/tracks_ietf.rs +++ b/rs/moq-net/tests/integration/tracks_ietf.rs @@ -8,7 +8,6 @@ //! Deterministic: paused time and a single-threaded runtime over the mock transport. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -117,11 +116,11 @@ async fn a_listing_of_our_own_peer_fails_alone() { .await .expect("never subscribed") .unwrap(); - let mut group = video.append_next().unwrap(); + let mut group = video.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::unscaled(group.start), &b"before"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(read(&mut sub).await, Some((0, b"before".to_vec())), "{version}"); assert_eq!(opened(&pair, SUBSCRIBE_TRACKS), 0, "{version}: listed unasked"); @@ -131,11 +130,11 @@ async fn a_listing_of_our_own_peer_fails_alone() { assert!(failed.starts_with("error:"), "{version}: {failed}"); assert_eq!(opened(&pair, SUBSCRIBE_TRACKS), 1, "{version}"); - let mut group = video.append_next().unwrap(); + let mut group = video.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::unscaled(group.start), &b"after"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert_eq!(read(&mut sub).await, Some((1, b"after".to_vec())), "{version}"); assert_eq!(subscribes(&pair), 1, "{version}"); } diff --git a/rs/moq-net/tests/integration/untimed.rs b/rs/moq-net/tests/integration/untimed.rs index e4358c73251..07125299ab5 100644 --- a/rs/moq-net/tests/integration/untimed.rs +++ b/rs/moq-net/tests/integration/untimed.rs @@ -8,7 +8,6 @@ //! track's time. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -127,7 +126,7 @@ async fn frame_through(hops: &[&str], info: track::Info) -> (Timestamp, track::I group .write_frame(moq_net::Timestamp::unscaled(group.start), &b"frame"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } } let received = next_frame(&mut subscriber).await; @@ -201,11 +200,11 @@ async fn an_explicit_start_holds_on_an_untimed_track() { let producer = broadcast.broadcast().create_track("data", untimed()).unwrap(); broadcast.announce().unwrap(); for _ in 0..5 { - let mut group = producer.append_next().unwrap(); + let mut group = producer.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::unscaled(group.start), &b"untimed"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } kio::clock::sleep(Duration::from_secs(1)).await; @@ -299,7 +298,9 @@ async fn a_fetched_untimed_frame_arrives_untimed() { let groups = request.requests(); let _track = request.accept(untimed()); let request = match futures::future::select(std::pin::pin!(groups.requested_fill()), &mut waiting).await { - futures::future::Either::Left((request, _)) => request.expect("the fetch reaches the publisher"), + futures::future::Either::Left((request, _)) => { + support::groups(request.expect("the fetch reaches the publisher")) + } futures::future::Either::Right(_) => panic!("nothing answered the fetch"), }; let mut group = request.accept(3, timed()).unwrap(); @@ -309,7 +310,7 @@ async fn a_fetched_untimed_frame_arrives_untimed() { Bytes::from_static(b"segment"), ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut fetched = waiting.await.unwrap(); let frame = fetched.read_frame().await.unwrap().unwrap(); diff --git a/rs/moq-net/tests/integration/warm_backfill.rs b/rs/moq-net/tests/integration/warm_backfill.rs index de452a21369..4aaaf4b9787 100644 --- a/rs/moq-net/tests/integration/warm_backfill.rs +++ b/rs/moq-net/tests/integration/warm_backfill.rs @@ -86,7 +86,7 @@ async fn a_newcomer_on_a_warm_relay_gets_the_backfill() { group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } broadcast.announce().unwrap(); @@ -120,7 +120,7 @@ async fn a_refused_transport_backfill_keeps_delivering_live() { group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } broadcast.announce().unwrap(); let mut subscriber = kio::clock::timeout(TIMEOUT, subscribe(&relay)).await.unwrap(); @@ -130,7 +130,7 @@ async fn a_refused_transport_backfill_keeps_delivering_live() { group .write_frame(Timestamp::from_millis(GROUPS * 1000).unwrap(), &b"live"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let got = kio::clock::timeout(TIMEOUT, subscriber.recv_group()) .await .unwrap() diff --git a/rs/moq-net/tests/integration/wide_key.rs b/rs/moq-net/tests/integration/wide_key.rs index c582bea81c6..afe901a1318 100644 --- a/rs/moq-net/tests/integration/wide_key.rs +++ b/rs/moq-net/tests/integration/wide_key.rs @@ -3,7 +3,6 @@ //! Group key boundaries, directly and through a forwarding origin. use crate::support; -use support::AppendNext; use std::time::Duration; @@ -52,7 +51,7 @@ async fn largest_quic_key_reaches_the_subscriber() { let timestamp = Timestamp::from_micros(key.min((1 << 61) - 1)).unwrap(); let mut group = track.create_group(moq_net::group::Info { start: key }).unwrap(); group.write_frame(timestamp, b"ladder".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut got = kio::clock::timeout(Duration::from_secs(5), sub.recv_group()) .await .unwrap_or_else(|_| panic!("{alpn} relayed={relayed} key={key} hung")) @@ -108,7 +107,7 @@ async fn wide_key_fails_only_its_subscription() { broadcast.announce().unwrap(); let mut group = wide.create_group(moq_net::group::Info { start: WIDE }).unwrap(); group.write_frame(latest(), b"wide".as_ref()).unwrap(); - let mut group = narrow.append_next().unwrap(); + let mut group = narrow.append_group(None).unwrap(); group.write_frame(Timestamp::ZERO, b"narrow".as_ref()).unwrap(); let mut options = MockConnectOptions::new("moq-lite-07-wip".parse::().unwrap()); @@ -175,9 +174,9 @@ async fn a_later_wide_group_fails_only_that_subscription() { let wide = broadcast.broadcast().create_track("wide", timed()).unwrap(); let narrow = broadcast.broadcast().create_track("narrow", timed()).unwrap(); broadcast.announce().unwrap(); - let mut group = wide.append_next().unwrap(); + let mut group = wide.append_group(None).unwrap(); group.write_frame(Timestamp::ZERO, b"first".as_ref()).unwrap(); - let mut group = narrow.append_next().unwrap(); + let mut group = narrow.append_group(None).unwrap(); group.write_frame(Timestamp::ZERO, b"narrow".as_ref()).unwrap(); let mut options = MockConnectOptions::new("moq-lite-07-wip".parse::().unwrap()); diff --git a/rs/moq-net/tests/integration/widened_max_age.rs b/rs/moq-net/tests/integration/widened_max_age.rs index e9ee5ef36fa..f3917f4f0b9 100644 --- a/rs/moq-net/tests/integration/widened_max_age.rs +++ b/rs/moq-net/tests/integration/widened_max_age.rs @@ -98,7 +98,7 @@ impl Chain { group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } } @@ -318,7 +318,7 @@ async fn wider_newcomers_after_the_first_pull_nothing_upstream() { group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } broadcast.announce().unwrap(); @@ -379,7 +379,7 @@ async fn a_legacy_viewer_beating_a_relay_copy_joins_at_the_live_edge() { group .write_frame(Timestamp::from_millis(key * 1000).unwrap(), &b"x"[..]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let consumer = viewer.consume(); diff --git a/rs/moq-net/tests/integration/zero_copy.rs b/rs/moq-net/tests/integration/zero_copy.rs index 16a7993f6e1..b14865db1c5 100644 --- a/rs/moq-net/tests/integration/zero_copy.rs +++ b/rs/moq-net/tests/integration/zero_copy.rs @@ -6,7 +6,6 @@ //! frame never keeps a larger receive allocation alive. use crate::support; -use support::AppendNext; use support::AtStart; use std::time::Duration; @@ -73,9 +72,9 @@ async fn frames_cross_without_a_copy() { subscribed(&track).await; let payload = Bytes::from(vec![7u8; 64 * 1024]); - let mut group = track.append_next().unwrap(); + let mut group = track.append_group(None).unwrap(); group.write_frame(group.at_start(), payload.clone()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut group = kio::clock::timeout(TIMEOUT, sub.recv_group()) .await diff --git a/rs/moq-relay/src/fetch.rs b/rs/moq-relay/src/fetch.rs index 165edef0689..9d555120b44 100644 --- a/rs/moq-relay/src/fetch.rs +++ b/rs/moq-relay/src/fetch.rs @@ -32,16 +32,12 @@ mod test { fn the_newest_group_can_be_empty() { let broadcast = moq_net::broadcast::Info::default().produce(); let track = broadcast.create_track("t", moq_net::track::Info::default()).unwrap(); - let mut first = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut first = track.append_group(None).unwrap(); first .write_frame(moq_net::Timestamp::unscaled(first.start), &b"a"[..]) .unwrap(); - first.close().unwrap(); - let _open = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + first.finish().unwrap(); + let _open = track.append_group(None).unwrap(); let handle = broadcast.consume().track("t").unwrap(); let group = fetch_group(&handle, None) diff --git a/rs/moq-relay/src/internal.rs b/rs/moq-relay/src/internal.rs index 9aec67fc184..4d737440391 100644 --- a/rs/moq-relay/src/internal.rs +++ b/rs/moq-relay/src/internal.rs @@ -1816,38 +1816,32 @@ mod tests { let bc = egress.request(update.prefix.clone(), None).await.unwrap(); let mut egress_sub = bc.track("video").unwrap().subscribe(None).await.unwrap(); { - let mut group = pub_track - .append_group(pub_track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut group = pub_track.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), vec![0u8; 12]) .unwrap(); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), vec![0u8; 34]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } { - let mut group = pub_track - .append_group(pub_track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut group = pub_track.append_group(None).unwrap(); group .write_frame(Timestamp::from_millis(10_000).unwrap(), vec![0u8; 1234]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let mut group = egress_sub.recv_group().await.unwrap().unwrap(); while group.read_frame().await.unwrap().is_some() {} // Write 56 ingress bytes into the regional-tier broadcast. { - let mut group = sub_track - .append_group(sub_track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut group = sub_track.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), vec![0u8; 56]) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let body = render_metrics(&stats.snapshot(), &[], &[]); @@ -1907,13 +1901,11 @@ mod tests { let bc = egress.request("demo/x", None).await.unwrap(); readers.push(bc.track("catalog.json").unwrap().subscribe(None).await.unwrap()); } - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), payload.clone()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); for reader in &mut readers { let mut group = reader.recv_group().await.unwrap().unwrap(); assert_eq!(group.read_frame().await.unwrap().unwrap().payload, payload.as_bytes()); diff --git a/rs/moq-relay/src/web.rs b/rs/moq-relay/src/web.rs index 30252983034..fbde1e1789a 100644 --- a/rs/moq-relay/src/web.rs +++ b/rs/moq-relay/src/web.rs @@ -1258,14 +1258,12 @@ mod tests { moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) .unwrap(); - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut group = track.append_group(None).unwrap(); const PAYLOAD: &[u8] = b""; group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), PAYLOAD) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut refused = Web::new( auth::Auth::refuse("test"), cluster.clone(), @@ -1500,13 +1498,11 @@ mod tests { moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI), ) .unwrap(); - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"hello".as_ref()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let state = Web::new(auth, cluster, certificates, Config::default()).state; for tier in ["first", "second"] { for selector in [FetchGroup::Num(0), FetchGroup::Latest] { @@ -1620,7 +1616,7 @@ mod tests { group .write_frame(moq_net::Timestamp::from_millis(millis).unwrap(), b"frame".as_ref()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); } let state = Web::new(auth, cluster, certificates, Config::default()).state; let status = serve_fetch( diff --git a/rs/moq-relay/tests/drills.rs b/rs/moq-relay/tests/drills.rs index 098b04c812a..96b8e69c2f4 100644 --- a/rs/moq-relay/tests/drills.rs +++ b/rs/moq-relay/tests/drills.rs @@ -345,13 +345,11 @@ fn dial() -> moq_tokio::connect::Config { /// Append one finished group carrying `payload`. fn write_group(track: &mut moq_net::track::Producer, payload: &[u8]) { - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), payload) .expect("write frame"); - group.close().expect("finish group"); + group.finish().expect("finish group"); } /// Read the next group's first frame, failing the drill on a timeout, a clean @@ -610,9 +608,7 @@ async fn relay_killed_mid_group_aborts_then_resumes(lane: Lane) { // a second: the kill lands mid-group rather than in the quiet between them. // Nothing more is written, so what the reader is waiting for cannot arrive // ahead of the kill and turn this into a race. - let mut open = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut open = track.append_group(None).expect("append group"); open.write_frame(moq_net::Timestamp::from_millis(open.start).unwrap(), b"read".as_ref()) .expect("write frame"); let mut open_reader = kio::clock::timeout(TIMEOUT, reader.groups.recv_group()) @@ -663,7 +659,7 @@ async fn relay_killed_mid_group_aborts_then_resumes(lane: Lane) { // Resumed delivery through the same subscriber origin: the reconnected // publisher re-announced, and a fresh subscribe rides the new session. - open.close().expect("finish the interrupted group"); + open.finish().expect("finish the interrupted group"); write_group(&mut track, b"after"); let mut reader = subscribe(&subscribed, "live").await; read_until(&mut reader, b"after", "after the restart").await; @@ -1532,22 +1528,18 @@ async fn subscriber_max_age_skips_bufferbloat(version: &str) { assert!(path.overflowed() > 0, "the finite queue did not drop overflow"); // 5.12Mb/s of media behind a 64kb/s link, for a second. for sequence in 2..22 { - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut group = track.append_group(None).unwrap(); group .write_frame(moq_net::Timestamp::from_millis(sequence * 50).unwrap(), payload.clone()) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); kio::clock::sleep(Duration::from_millis(50)).await; } - let mut newest = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut newest = track.append_group(None).unwrap(); newest .write_frame(moq_net::Timestamp::from_millis(1100).unwrap(), b"snapshot") .unwrap(); - newest.close().unwrap(); + newest.finish().unwrap(); // No successor means this snapshot must survive even after its budget elapsed. kio::clock::sleep(Duration::from_millis(500)).await; let sequence = kio::clock::timeout(TIMEOUT, async { diff --git a/rs/moq-relay/tests/integration/auth_lifetime.rs b/rs/moq-relay/tests/integration/auth_lifetime.rs index f18e41163f2..ccd7485be5e 100644 --- a/rs/moq-relay/tests/integration/auth_lifetime.rs +++ b/rs/moq-relay/tests/integration/auth_lifetime.rs @@ -301,13 +301,11 @@ async fn connect_and_round_trip(url: &url::Url) -> (moq_tokio::Connection, moq_t .broadcast() .create_track("video", timed()) .expect("create track"); - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"hello".as_ref()) .expect("write frame"); - group.close().expect("finish group"); + group.finish().expect("finish group"); let pub_session = kio::clock::timeout( TIMEOUT, @@ -748,13 +746,11 @@ async fn a_moved_tier_retags_the_live_session() { let mut track_sub = bc.track("video").unwrap().subscribe(None).await.expect("subscribe"); let mut round_trip = async |payload: &'static [u8]| { - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), payload) .expect("write frame"); - group.close().expect("finish group"); + group.finish().expect("finish group"); let mut group = kio::clock::timeout(TIMEOUT, track_sub.recv_group()) .await .expect("recv_group timeout") @@ -891,14 +887,11 @@ async fn a_rechecked_grant_resizes_live_sessions() { ); } let send = |index: usize, sequence: u64| { - let mut group = tracks[index] - .1 - .append_group(tracks[index].1.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = tracks[index].1.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"media".as_ref()) .expect("write frame"); - let group = group.close().expect("finish group"); + let group = group.finish().expect("finish group"); assert_eq!(group.start, sequence); }; for (index, sub) in subs.iter_mut().enumerate() { @@ -1045,9 +1038,7 @@ async fn http_routes_hold_a_lease() { .broadcast() .create_track("video", timed()) .expect("create track"); - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"hello".as_ref()) .expect("write frame"); @@ -1948,16 +1939,14 @@ async fn in_band_tokens_widen_and_withdraw_live_prefixes() { .unwrap() .unwrap(); let mut b_sub = b_read.track("video").unwrap().subscribe(None).await.unwrap(); - let mut group = b_track - .append_group(b_track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut group = b_track.append_group(None).unwrap(); group .write_frame( moq_net::Timestamp::from_millis(group.start).unwrap(), b"new prefix".as_ref(), ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert!( kio::clock::timeout(TIMEOUT, b_sub.recv_group()) .await @@ -1977,16 +1966,14 @@ async fn in_band_tokens_widen_and_withdraw_live_prefixes() { "{scheme}: {:?}", ended.as_ref().err() ); - let mut group = a_track - .append_group(a_track.largest().map_or(0, |largest| largest.group + 1)) - .unwrap(); + let mut group = a_track.append_group(None).unwrap(); group .write_frame( moq_net::Timestamp::from_millis(group.start).unwrap(), b"original prefix".as_ref(), ) .unwrap(); - group.close().unwrap(); + group.finish().unwrap(); assert!( kio::clock::timeout(TIMEOUT, a_sub.recv_group()) .await diff --git a/rs/moq-relay/tests/integration/bitrate_caps.rs b/rs/moq-relay/tests/integration/bitrate_caps.rs index 3e0a5669311..f6911f12219 100644 --- a/rs/moq-relay/tests/integration/bitrate_caps.rs +++ b/rs/moq-relay/tests/integration/bitrate_caps.rs @@ -166,13 +166,11 @@ async fn transfer( .expect("subscribe"); let start = kio::clock::now(); - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), vec![7u8; FRAME]) .expect("write frame"); - group.close().expect("finish group"); + group.finish().expect("finish group"); let mut group = kio::clock::timeout(TIMEOUT, subscription.recv_group()) .await .expect("recv_group timeout") diff --git a/rs/moq-relay/tests/integration/cluster_unknown.rs b/rs/moq-relay/tests/integration/cluster_unknown.rs index c9e5fc5dc57..773ee0e7640 100644 --- a/rs/moq-relay/tests/integration/cluster_unknown.rs +++ b/rs/moq-relay/tests/integration/cluster_unknown.rs @@ -96,13 +96,11 @@ async fn publish_version(relay: &cluster::Cluster, auth: &auth::Auth, version: & let running = streaming.clone(); let streamer = kio::clock::sim::spawn(async move { while running.load(std::sync::atomic::Ordering::Relaxed) { - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"hello".as_ref()) .expect("write frame"); - group.close().expect("finish group"); + group.finish().expect("finish group"); kio::clock::sleep(Duration::from_millis(100)).await; } let _track = track; diff --git a/rs/moq-relay/tests/integration/connection.rs b/rs/moq-relay/tests/integration/connection.rs index 0d113f9f831..1012c93b5f8 100644 --- a/rs/moq-relay/tests/integration/connection.rs +++ b/rs/moq-relay/tests/integration/connection.rs @@ -57,7 +57,7 @@ async fn largest_quic_sequence_reaches_the_subscriber() { let timestamp = moq_net::Timestamp::from_micros(sequence.min((1 << 61) - 1)).unwrap(); let mut group = track.create_group(moq_net::group::Info { start: sequence }).unwrap(); group.write_frame(timestamp, b"ladder".as_ref()).unwrap(); - group.close().unwrap(); + group.finish().unwrap(); let mut got = kio::clock::timeout(TIMEOUT, sub.recv_group()) .await .unwrap_or_else(|_| panic!("{alpn} sequence={sequence} hung")) @@ -90,13 +90,11 @@ fn publish( .expect("create broadcast"); let info = moq_net::track::Info::default().with_timescale(moq_net::Timescale::MILLI); let track = broadcast.broadcast().create_track("video", info).expect("create track"); - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), name.as_bytes()) .expect("write frame"); - group.close().expect("finish group"); + group.finish().expect("finish group"); (origin, broadcast, track) } diff --git a/rs/moq-relay/tests/integration/embed.rs b/rs/moq-relay/tests/integration/embed.rs index 179f118a32a..8a48df1c532 100644 --- a/rs/moq-relay/tests/integration/embed.rs +++ b/rs/moq-relay/tests/integration/embed.rs @@ -279,13 +279,11 @@ async fn embed_and_stop(mut config: Config) { .broadcast() .create_track("video", timed()) .expect("create track"); - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"hello".as_ref()) .expect("write frame"); - group.close().expect("finish group"); + group.finish().expect("finish group"); let url: url::Url = format!("https://{quic}/").parse().expect("parse url"); let subscriber_origin = moq_tokio::origin::spawn(); diff --git a/rs/moq-relay/tests/integration/goaway_cluster.rs b/rs/moq-relay/tests/integration/goaway_cluster.rs index c19e9a6c4da..3d8b8a9bc44 100644 --- a/rs/moq-relay/tests/integration/goaway_cluster.rs +++ b/rs/moq-relay/tests/integration/goaway_cluster.rs @@ -174,9 +174,7 @@ async fn cluster_continues_a_group_split_by_goaway_inner() { } // The first group is open, its first frame read, when A redirects to B. - let mut split = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut split = track.append_group(None).expect("append group"); write(&mut split, "a"); let mut reading = within("recv the split group", sub.recv_group()) .await @@ -218,15 +216,13 @@ async fn cluster_continues_a_group_split_by_goaway_inner() { .await; write(&mut split, "b"); - split.close().expect("finish"); + split.finish().expect("finish"); assert_eq!(read(&mut reading).await, (0, Some("b".into()))); assert_eq!(read(&mut reading).await, (0, None)); - let mut after = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut after = track.append_group(None).expect("append group"); write(&mut after, "c"); - after.close().expect("finish"); + after.finish().expect("finish"); let mut next = within("recv the next group", sub.recv_group()) .await .expect("recv") @@ -273,13 +269,11 @@ async fn cluster_migrates_on_upstream_goaway_inner() { .await .expect("subscribe"); - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"g0".as_ref()) .expect("write frame"); - group.close().expect("finish"); + group.finish().expect("finish"); let mut g0 = within("recv g0", sub.recv_group()) .await @@ -310,13 +304,11 @@ async fn cluster_migrates_on_upstream_goaway_inner() { // New content lands after the swap (both siblings serve the same // origin, so B has it). - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"g1".as_ref()) .expect("write frame"); - group.close().expect("finish"); + group.finish().expect("finish"); let mut g1 = within("recv g1", sub.recv_group()) .await @@ -462,15 +454,13 @@ async fn cluster_diamond_goaway_seamless_failover_inner() { // ── group 0 flows through the MID-A leg (all frames verified) ── const FRAMES_PER_GROUP: u64 = 3; - let mut g = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut g = track.append_group(None).expect("append group"); for f in 0..FRAMES_PER_GROUP { let payload = format!("diamond_g0_f{f}"); g.write_frame(moq_net::Timestamp::from_millis(g.start).unwrap(), payload.as_bytes()) .expect("write frame"); } - g.close().expect("finish"); + g.finish().expect("finish"); let mut seen = BTreeSet::new(); collect_group(&mut sub, &mut seen, FRAMES_PER_GROUP, "pre-failover (via MID-A)").await; @@ -482,15 +472,13 @@ async fn cluster_diamond_goaway_seamless_failover_inner() { const LAST_GROUP: u64 = 20; let publisher = kio::clock::sim::spawn(async move { for seq in 1..=LAST_GROUP { - let mut g = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut g = track.append_group(None).expect("append group"); for f in 0..FRAMES_PER_GROUP { let payload = format!("diamond_g{seq}_f{f}"); g.write_frame(moq_net::Timestamp::from_millis(g.start).unwrap(), payload.as_bytes()) .expect("write frame"); } - g.close().expect("finish"); + g.finish().expect("finish"); kio::clock::sleep(Duration::from_millis(50)).await; } // Hand the track back so the post-drain phase can keep publishing. @@ -539,15 +527,13 @@ async fn cluster_diamond_goaway_seamless_failover_inner() { const POST_DRAIN_LAST: u64 = LAST_GROUP + 40; let post_publisher = kio::clock::sim::spawn(async move { for seq in (LAST_GROUP + 1)..=POST_DRAIN_LAST { - let mut g = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut g = track.append_group(None).expect("append group"); for f in 0..FRAMES_PER_GROUP { let payload = format!("diamond_g{seq}_f{f}"); g.write_frame(moq_net::Timestamp::from_millis(g.start).unwrap(), payload.as_bytes()) .expect("write frame"); } - g.close().expect("finish"); + g.finish().expect("finish"); kio::clock::sleep(Duration::from_millis(50)).await; } }); diff --git a/rs/moq-relay/tests/integration/public_rules.rs b/rs/moq-relay/tests/integration/public_rules.rs index c3504c771a3..5d22391e5e3 100644 --- a/rs/moq-relay/tests/integration/public_rules.rs +++ b/rs/moq-relay/tests/integration/public_rules.rs @@ -66,9 +66,7 @@ async fn publish(url: url::Url, name: &str) -> Box { .broadcast() .create_track("video", timed()) .expect("create track"); - let mut group = track - .append_group(track.largest().map_or(0, |largest| largest.group + 1)) - .expect("append group"); + let mut group = track.append_group(None).expect("append group"); group .write_frame(moq_net::Timestamp::from_millis(group.start).unwrap(), b"hello".as_ref()) .expect("write frame"); diff --git a/rs/moq-relay/tests/integration/quic_sim.rs b/rs/moq-relay/tests/integration/quic_sim.rs index a861683fcc5..1093644b3d6 100644 --- a/rs/moq-relay/tests/integration/quic_sim.rs +++ b/rs/moq-relay/tests/integration/quic_sim.rs @@ -162,7 +162,7 @@ async fn deliver(network: &Network, publish: &Relay, subscribe: &Relay) -> Vec