diff --git a/c/moq/MIGRATE.md b/c/moq/MIGRATE.md index a7fe99980a3..226fa0d1ac7 100644 --- a/c/moq/MIGRATE.md +++ b/c/moq/MIGRATE.md @@ -86,6 +86,7 @@ Publish a replacement under a new name, and expect a finished track's demand ter `moq_origin_dynamic` takes no route, and `moq_origin_dynamic_update` is gone. `moq_broadcast_request_accept` is replaced by `moq_broadcast_request_prepare`, which returns a prepared answer: fill its broadcast, then `moq_broadcast_prepared_publish` announces it at the exact path under a fresh instance of its own. +To answer with a broadcast you already hold, `moq_broadcast_request_serve(request, consumer)` serves it under the prefix route without announcing an exact route; the consumer stays yours to free. `moq_broadcast_prepared_free` refuses an answer you will not publish. ### `moq_track_info` gains `compress` (#5928) diff --git a/dart/moq/MIGRATE.md b/dart/moq/MIGRATE.md index f4a5f95ab7e..d7b9e221f46 100644 --- a/dart/moq/MIGRATE.md +++ b/dart/moq/MIGRATE.md @@ -146,6 +146,7 @@ Publish a replacement under a new name, and expect a finished track's demand wat `origin.dynamic_(prefix:)` takes no route, and `update` is gone. Replace `request.accept(broadcast:)` with `request.prepare()`, which returns a `BroadcastPrepared`: fill its `broadcast()`, then `publish()` announces it at the exact path under a fresh instance of its own and returns its producer. +To answer with a broadcast you already hold, `request.serve(broadcast: producer.consume())` serves it under the prefix route without announcing an exact route. ### Anchors can name a time (#6074) diff --git a/dart/moq_ffi/lib/src/moq.dart b/dart/moq_ffi/lib/src/moq.dart index b704af4ce14..8acaae2bb92 100644 --- a/dart/moq_ffi/lib/src/moq.dart +++ b/dart/moq_ffi/lib/src/moq.dart @@ -12444,6 +12444,7 @@ abstract class MoqBroadcastRequestInterface { String path(); MoqBroadcastPrepared prepare(); void reject({required int errorCode}); + void serve({required MoqBroadcastConsumer broadcast}); } final _MoqBroadcastRequestFinalizer = Finalizer>((ptr) { @@ -12514,6 +12515,16 @@ class MoqBroadcastRequest implements MoqBroadcastRequestInterface { ); }, moqExceptionErrorHandler); } + + void serve({required MoqBroadcastConsumer broadcast}) { + return rustCall((status) { + uniffi_moq_ffi_fn_method_moqbroadcastrequest_serve( + uniffiClonePointer(), + FfiConverterMoqBroadcastConsumer.lower(broadcast), + status, + ); + }, moqExceptionErrorHandler); + } } class FfiConverterMoqBroadcastRequest { @@ -19506,6 +19517,15 @@ external void uniffi_moq_ffi_fn_method_moqbroadcastrequest_reject( Pointer uniffiStatus, ); +@Native, Pointer, Pointer)>( + assetId: _uniffiAssetId, +) +external void uniffi_moq_ffi_fn_method_moqbroadcastrequest_serve( + Pointer ptr, + Pointer broadcast, + Pointer uniffiStatus, +); + @Native Function(Pointer, Pointer)>( assetId: _uniffiAssetId, ) @@ -21378,6 +21398,9 @@ external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_prepare(); @Native(assetId: _uniffiAssetId) external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_reject(); +@Native(assetId: _uniffiAssetId) +external int uniffi_moq_ffi_checksum_method_moqbroadcastrequest_serve(); + @Native(assetId: _uniffiAssetId) external int uniffi_moq_ffi_checksum_method_moqfollowing_available(); @@ -22105,6 +22128,9 @@ void _checkApiChecksums() { if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_reject() != 9727) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } + if (uniffi_moq_ffi_checksum_method_moqbroadcastrequest_serve() != 16802) { + throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); + } if (uniffi_moq_ffi_checksum_method_moqfollowing_available() != 39867) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } @@ -22134,7 +22160,7 @@ void _checkApiChecksums() { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } if (uniffi_moq_ffi_checksum_method_moqoriginrequests_requested_broadcast() != - 31253) { + 47029) { throw UniffiInternalError.panicked("UniFFI API checksum mismatch"); } if (uniffi_moq_ffi_checksum_method_moqpublication_announce() != 60624) { diff --git a/dart/moq_ffi/lib/src/uniffi_runtime.dart b/dart/moq_ffi/lib/src/uniffi_runtime.dart index 3b7dd9cf392..66b9e185973 100644 --- a/dart/moq_ffi/lib/src/uniffi_runtime.dart +++ b/dart/moq_ffi/lib/src/uniffi_runtime.dart @@ -8,6 +8,7 @@ import "dart:ffi"; import "dart:io" show Platform, File, Directory; import "dart:isolate"; import "dart:typed_data"; + import "package:ffi/ffi.dart"; class UniffiInternalError implements Exception { @@ -252,6 +253,7 @@ mixin FfiConverterPrimitive on FfiConverter { @override T lower(T value) => value; } + Uint8List createUint8ListFromInt(int value) { int length = value.bitLength ~/ 8 + 1; if (length != 4 && length != 8) { diff --git a/doc/concept/identity.md b/doc/concept/identity.md index 3e626bd79a0..15ff9b99a01 100644 --- a/doc/concept/identity.md +++ b/doc/concept/identity.md @@ -157,10 +157,17 @@ demand, which has none until a worker answers. ## Work on demand -A worker can advertise a prefix it serves on demand, such as a transcoder -claiming `transcode`. A claim promises capability, not content. Each requested -path is a separate job, announced at its exact path under a fresh instance of -its own. +A worker can advertise a prefix it serves on demand and answer with a +broadcast it already holds. This announces no exact route: the answer belongs +to the prefix route's instance at that path. Every answer there must continue +one sequence space with the same bytes. To serve different content at a path +already served, start a new prefix route. Its first subscription stays on +the prefix route without a restart. + +A job that may restart independently, such as a transcoder claiming +`transcode`, instead prepares and publishes each requested path. A claim +promises capability, not content. Each requested path is a separate job, +announced at its exact path under a fresh instance of its own. ```rust let claim = origin.requests("transcode")?; diff --git a/doc/lib/layers.md b/doc/lib/layers.md index d6be6df64f7..a9ec70893c3 100644 --- a/doc/lib/layers.md +++ b/doc/lib/layers.md @@ -42,6 +42,12 @@ Sessions, origins, broadcasts, tracks, and groups: `Client`, `Server`, | C++ | `moq::` | `moq::BroadcastProducer` | | C | `moq_session_*`, `moq_origin_*`, `moq_publish_track_*`, `moq_consume_track_*` | `moq_publish_track` | +On-demand broadcast requests in every binding can answer with held content +without announcing an exact route. The answer uses the prefix route's +continuous sequence space at that path. Use a fresh publication for a job +that may restart independently; see [work on demand](/concept/identity#work-on-demand) +and the [Go](/lib/go/) and [C](/lib/c/) binding references. + ## media The catalog, encoded-media imports, and container-decoded reads, merging diff --git a/go/wrapper/MIGRATE.md b/go/wrapper/MIGRATE.md index ab7c8e208af..a353d0fde53 100644 --- a/go/wrapper/MIGRATE.md +++ b/go/wrapper/MIGRATE.md @@ -140,6 +140,7 @@ Publish a replacement under a new name, and expect a finished track's demand wat `OriginProducer.Dynamic(prefix)` takes no route, and `OriginDynamic.Update` is gone. Replace `request.Accept(broadcast)` with `request.Prepare()`, which returns a `*BroadcastPrepared`: fill its `Broadcast()`, then `Publish()` announces it at the exact path under a fresh instance of its own and returns its producer. +To answer with a broadcast you already hold, `request.Serve(consumer)` serves it under the prefix route without announcing an exact route; the consumer stays yours to close. Where you rejected a request after a failed setup, `Close()` the prepared answer instead. ### `TrackInfo` gains `Compress` (#5928) diff --git a/go/wrapper/origin.go b/go/wrapper/origin.go index 91c73aec3cb..0123431e09d 100644 --- a/go/wrapper/origin.go +++ b/go/wrapper/origin.go @@ -142,6 +142,12 @@ func (r *BroadcastRequest) Prepare() (*BroadcastPrepared, error) { return &BroadcastPrepared{inner: inner}, nil } +// Serve answers with held content under the prefix route's continuous sequence space, +// without announcing an exact route. The broadcast remains the caller's to release. +func (r *BroadcastRequest) Serve(broadcast *BroadcastConsumer) error { + return r.inner.Serve(broadcast.inner) +} + // Reject fails the request with an application error code. func (r *BroadcastRequest) Reject(errorCode uint16) error { return r.inner.Reject(errorCode) diff --git a/go/wrapper/publish.go b/go/wrapper/publish.go index 6608d494210..4ad723616a2 100644 --- a/go/wrapper/publish.go +++ b/go/wrapper/publish.go @@ -17,8 +17,9 @@ type BroadcastProducer struct { } // NewBroadcastProducer creates a standalone broadcast, not attached to any -// origin: use it to serve a dynamic request ([BroadcastRequest.Accept]) or for -// local pub/sub. To publish at a path, use [OriginProducer.CreateBroadcast]. +// origin: pass its [BroadcastProducer.Consume] result to [BroadcastRequest.Serve] +// for a dynamic request, or use it for local pub/sub. To publish at a path, use +// [OriginProducer.CreateBroadcast]. func NewBroadcastProducer() (*BroadcastProducer, error) { inner, err := ffi.NewMoqBroadcastProducer() if err != nil { diff --git a/js/net/MIGRATE.md b/js/net/MIGRATE.md index 8dbad0d2958..cea6519e29d 100644 --- a/js/net/MIGRATE.md +++ b/js/net/MIGRATE.md @@ -135,7 +135,8 @@ Only `publish` announces it: `prepared.broadcast` has no announcement methods. `Prepared.reject(err)` is replaced by idempotent `close()` and `[Symbol.dispose]()`; either refuses the unpublished answer as `Unroutable` and closes its broadcast. Closing that broadcast also refuses the request. `using` handles normal scope exit and exceptions; after `publish()`, disposal leaves the returned publication and its fill producer live. Use `request.reject(err)` to refuse before preparing. A retained, unclosed `Prepared` keeps its request pending; garbage collection provides no prompt cleanup guarantee. Construct a `Prepared` only with `request.prepare()`. Its constructor and the `Request.publisher`, `publishPrepared`, and `rejectPrepared` completion hooks are no longer public. -`Dynamic.update` is no longer part of the public API, and `Request` has no `accept` (#6496): only the built-in sessions answer with a broadcast they already hold. +`Dynamic.update` is no longer part of the public API (#6496). +`Request.serve(broadcast)` additively exposes the former private answer path: serve held content without announcing an exact route. The prefix route promises the same bytes and continuous sequences at each served path; start a new prefix route for different content, or prepare and publish an independent job. Close the claim and claim again to change it, and close an answer's producer to end that output. ### `largest()` reports within a reader's `setGroups` bounds diff --git a/js/net/api/index.api.md b/js/net/api/index.api.md index e3db0dc361f..c4ea1ab5d4c 100644 --- a/js/net/api/index.api.md +++ b/js/net/api/index.api.md @@ -445,6 +445,7 @@ export namespace Origin { readonly path: Path.Valid; prepare(): Origin.Prepared; reject(err: Error): void; + serve(source: Broadcast.Producer | Broadcast.Consumer): void; } export interface RequestOptions { instance?: Instance.Valid; diff --git a/js/net/bench/broadcasts.ts b/js/net/bench/broadcasts.ts index a81c31e215d..befb87f20f6 100644 --- a/js/net/bench/broadcasts.ts +++ b/js/net/bench/broadcasts.ts @@ -6,7 +6,6 @@ import { Producer as BroadcastProducer } from "../src/broadcast.ts"; import { BroadcastCache } from "../src/consume.ts"; import { HopSchema, Route } from "../src/hop.ts"; import * as Instance from "../src/instance.ts"; -import { hooks } from "../src/internal.ts"; import { AnnounceRequest } from "../src/lite/announce.ts"; import { Publisher } from "../src/lite/publisher.ts"; import { Subscriber } from "../src/lite/subscriber.ts"; @@ -243,7 +242,7 @@ for (const pathCount of routeCounts) { const broadcasts = Array.from({ length: pathCount }, () => new BroadcastProducer()); for (const broadcast of broadcasts) { const request = (await pending.next()).value; - if (request) hooks.acceptRequest(request, broadcast); + if (request) request.serve(broadcast); } await Promise.resolve(); const before = requests.map((request) => request.active.peek()); diff --git a/js/net/bench/requests.ts b/js/net/bench/requests.ts index 0be36fca0ee..5bd6a4fa82e 100644 --- a/js/net/bench/requests.ts +++ b/js/net/bench/requests.ts @@ -10,7 +10,6 @@ import { } from "../src/ietf/subscribe_namespace"; import { ALPN, Version } from "../src/ietf/version"; import * as Instance from "../src/instance.ts"; -import { hooks } from "../src/internal"; import { createMockTransportPair } from "../src/mock"; import { Producer } from "../src/origin"; import * as Path from "../src/path"; @@ -149,7 +148,7 @@ for (const failovers of [0, 1, 16, 128]) const source = new Broadcast(); sources.push(source); const answer = (await ar.next()).value; - if (answer) hooks.acceptRequest(answer, source); + if (answer) answer.serve(source); await settle(); entries.push({ primary, ar, br, held }); } @@ -186,7 +185,7 @@ for (const failovers of [0, 1, 16, 128]) for (let i = 0; i < entries.length; i++) { const source = new Broadcast(); sources.push(source); - hooks.acceptRequest(pending[i], source); + pending[i].serve(source); await settle(); if (!readsFrom(entries[i].held.active.peek(), source)) throw new Error("lost failover"); } diff --git a/js/net/src/connection/forward.ts b/js/net/src/connection/forward.ts index fa1ab2f6ebd..b93b9f55bad 100644 --- a/js/net/src/connection/forward.ts +++ b/js/net/src/connection/forward.ts @@ -8,7 +8,7 @@ import { Milli, Nano } from "@moq/clock"; import { type Dispose, race } from "@moq/signals"; import type * as Announce from "../announced.ts"; import { type Route, routesEqual } from "../hop.ts"; -import { coveringPrefixes, hooks } from "../internal.ts"; +import { coveringPrefixes } from "../internal.ts"; import type { Producer as OriginProducer, RequestSlot, Requests } from "../origin.ts"; import * as Path from "../path.ts"; import { after } from "../util/timer.ts"; @@ -293,7 +293,7 @@ async function drive(handle: Requests, conn: Established): Promise { const session = wireOf(conn); try { for await (const request of handle.requested()) { - hooks.acceptRequest(request, session.consume(request.path)); + request.serve(session.consume(request.path)); } } catch { handle.close(); diff --git a/js/net/src/group-id.test.ts b/js/net/src/group-id.test.ts index b59474e114d..812c4aba7ef 100644 --- a/js/net/src/group-id.test.ts +++ b/js/net/src/group-id.test.ts @@ -4,7 +4,6 @@ import { expect, test } from "bun:test"; import { type Consumer as BroadcastConsumer, Producer as BroadcastProducer } from "./broadcast.ts"; import { accept, connect } from "./connection/index.ts"; import * as Ietf from "./ietf/index.ts"; -import { hooks } from "./internal.ts"; import * as Lite from "./lite/index.ts"; import { createMockTransportPair } from "./mock.ts"; import { Producer as OriginProducer } from "./origin.ts"; @@ -87,7 +86,7 @@ for (const wire of WIRES) { for await (const request of dynamic.requested()) { const input = wireOf(ingest).consume(request.path); inputs.push(input); - hooks.acceptRequest(request, await forward(input)); + request.serve(await forward(input)); } })(); diff --git a/js/net/src/ietf/publisher.test.ts b/js/net/src/ietf/publisher.test.ts index 16656baffa7..983494d2998 100644 --- a/js/net/src/ietf/publisher.test.ts +++ b/js/net/src/ietf/publisher.test.ts @@ -306,7 +306,7 @@ test("TRACK_STATUS finished at once is answered on every draft", async () => { finish(); const served = new BroadcastProducer(); served.createTrack("video"); - hooks.acceptRequest(pending, served); + pending.serve(served); await task; expect(await wire().u53()).toBe(TrackStatusOk.id); @@ -439,7 +439,7 @@ test("a cancelled TRACK_STATUS releases its demand on every draft", async () => expect(early.written).toEqual([]); // Withdrawn, so a late answer is closed rather than served. const answer = new SessionBroadcast(); - hooks.acceptRequest(pending, answer); + pending.serve(answer); expect(answer.closed.peek()).toBeNull(); // The broadcast resolves, but its track is never answered. @@ -449,7 +449,7 @@ test("a cancelled TRACK_STATUS releases its demand on every draft", async () => if (!request) throw new Error("no request for room/late"); const served = new BroadcastProducer(); const trackRequest = wireOf(served).requested(); - hooks.acceptRequest(request, served); + request.serve(served); const track = await trackRequest; expect(track?.name).toBe("video"); late.cancel(); @@ -491,7 +491,7 @@ test("a SUBSCRIBE withdrawn during setup releases its demand on every draft", as expect(early.written).toEqual([]); // Withdrawn, so a late answer is closed rather than served. const answer = new SessionBroadcast(); - if (pending) hooks.acceptRequest(pending, answer); + if (pending) pending.serve(answer); expect(answer.closed.peek()).toBeNull(); // The broadcast resolves, but its track is never answered. @@ -501,7 +501,7 @@ test("a SUBSCRIBE withdrawn during setup releases its demand on every draft", as if (!request) throw new Error("no request for room/late"); const served = new BroadcastProducer(); const trackRequest = wireOf(served).requested(); - hooks.acceptRequest(request, served); + request.serve(served); const track = await trackRequest; if (!track) throw new Error("no request for video"); expect(track.name).toBe("video"); diff --git a/js/net/src/integration.test.ts b/js/net/src/integration.test.ts index a31250c8ff7..6182be54407 100644 --- a/js/net/src/integration.test.ts +++ b/js/net/src/integration.test.ts @@ -2770,42 +2770,75 @@ test("create then announce is discoverable on the wire", async () => { origin.close(); }); -test("a handle serves a request under live/** over the wire", async () => { - const pair = createMockTransportPair(Lite.ALPN_06); - const origin = new OriginProducer(); - const handle = origin.requestsRoute(Path.from("live")); - - const serving = (async () => { - for await (const request of handle.requested()) { - const produced = new BroadcastProducer(); - produced.createTrack("chat", { timescale: Timescale.MILLI }).writeFrame(textFrame("hello")); - hooks.acceptRequest(request, produced); - } - })(); - - const [client, server] = await Promise.all([ - connect(url, { transport: pair.client }), - accept(pair.server, url, { publish: origin.consume() }), - ]); - - const announced = client.announced(); - const entry = await announced.next(); - expect(entry?.prefix).toBe("live" as Path.Valid); - expect(entry?.kind).toBe("start"); - - const remote = wireOf(client).consume(Path.from("live/cam")); - const track = remote.track("chat").subscribe().ordered(); - expect(await track.readString()).toBe("hello"); +test.each([Lite.ALPN_06, Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_18, Ietf.ALPN.DRAFT_22])( + "a held answer's first subscribe succeeds on %s without an exact route", + async (protocol) => { + const pair = createMockTransportPair(protocol); + const origin = new OriginProducer(); + const consumer = new OriginProducer(); + const handle = origin.requests(Path.empty()); + const held = new BroadcastProducer(); + held.createTrack("chat", { timescale: Timescale.MILLI }).writeFrame(textFrame("hello")); + const serving = (async () => { + for await (const request of handle.requested()) request.serve(held.consume()); + })(); + const [client, server] = await Promise.all([ + connect(url, { transport: pair.client, consume: consumer }), + accept(pair.server, url, { publish: origin.consume() }), + ]); + const requested = consumer.request(Path.from("live/cam")); + const remote = await waitFor(requested.active, (broadcast) => broadcast !== undefined); + if (!remote) throw new Error("request did not resolve"); + const track = remote.track("chat").subscribe().ordered(); + expect(await track.readString()).toBe("hello"); + expect(wireOf(origin.consume()).advertised.peek()?.has(Path.from("live/cam"))).toBe(false); + track.close(); + requested.close(); + handle.close(); + await serving; + held.close(); + client.abort(); + server.abort(); + origin.close(); + consumer.close(); + }, +); - track.close(); - remote.close(); - announced.close(); - handle.close(); - await serving; - client.abort(); - server.abort(); - origin.close(); -}); +test.each([Lite.ALPN_06, Lite.ALPN_07_WIP, Ietf.ALPN.DRAFT_18, Ietf.ALPN.DRAFT_22])( + "publishing a job still resets its first subscribe on %s", + async (protocol) => { + const pair = createMockTransportPair(protocol); + const origin = new OriginProducer(); + const consumer = new OriginProducer(); + const handle = origin.requests(Path.empty()); + const serving = (async () => { + const requests = handle.requested(); + const request = (await requests.next()).value; + if (!request) throw new Error("missing job request"); + const prepared = request.prepare(); + prepared.broadcast.createTrack("chat", { timescale: Timescale.MILLI }).writeFrame(textFrame("job")); + return prepared.publish(); + })(); + const [client, server] = await Promise.all([ + connect(url, { transport: pair.client, consume: consumer }), + accept(pair.server, url, { publish: origin.consume() }), + ]); + const requested = consumer.request(Path.from("live/cam")); + const remote = await waitFor(requested.active, (broadcast) => broadcast !== undefined); + if (!remote) throw new Error("request did not resolve"); + const track = remote.track("chat").subscribe().ordered(); + await expect(track.readString()).rejects.toBeInstanceOf(Error); + const publication = await serving; + track.close(); + requested.close(); + handle.close(); + publication.broadcast.close(); + client.abort(); + server.abort(); + origin.close(); + consumer.close(); + }, +); // The peer's close code a killed session carries. const DEATH = SessionCode(71); diff --git a/js/net/src/internal.ts b/js/net/src/internal.ts index 0be942d71c1..b870a29bc15 100644 --- a/js/net/src/internal.ts +++ b/js/net/src/internal.ts @@ -14,7 +14,6 @@ import { toStreamCode } from "./error.ts"; import type { Frame, FrameConsumer, Consumer as GroupConsumer, Producer as GroupProducer } from "./group.ts"; import { isAnonymous, type Route } from "./hop.ts"; import type * as Instance from "./instance.ts"; -import type { Request as OriginRequest } from "./origin.ts"; import * as Path from "./path.ts"; import type { Timestamp } from "./time.ts"; import type { Delay, Demand, Groups, Info, Position, Producer, Request, Subscriber, Subscription } from "./track.ts"; @@ -699,11 +698,6 @@ export const hooks: { stampUnlisted: (target: BroadcastConsumer) => void; /** Whether a broadcast handle was {@link stampUnlisted marked unlisted}. */ unlisted: (target: BroadcastConsumer) => boolean; - /** - * Resolve a session-forwarded request with its peer's routed broadcast. An application - * claim answers through `prepare` and `publish` instead. Assigned by `origin.ts`. - */ - acceptRequest: (request: OriginRequest, source: BroadcastProducer | BroadcastConsumer) => void; } = { endTrack: () => { throw new Error("track.ts not loaded"); @@ -964,9 +958,6 @@ export const hooks: { unlisted: () => { throw new Error("broadcast.ts not loaded"); }, - acceptRequest: () => { - throw new Error("origin.ts not loaded"); - }, }; /** FNV-1a 64 of `path`, then `bytes`. The seed is the draft's Spread Hash offset basis. */ diff --git a/js/net/src/lite/publisher.test.ts b/js/net/src/lite/publisher.test.ts index 1a311ecfec6..9b21ade6ff6 100644 --- a/js/net/src/lite/publisher.test.ts +++ b/js/net/src/lite/publisher.test.ts @@ -721,7 +721,7 @@ async function servedSubscription( front.serve(broadcast.consume()); const dynamic = origin.requestsRoute(Path.from("test")); void (async () => { - for await (const request of dynamic.requested()) hooks.acceptRequest(request, front.consumer); + for await (const request of dynamic.requested()) request.serve(front.consumer); })(); routed = { front, dynamic }; } else { @@ -2809,7 +2809,7 @@ test("lite draft-06: a grant that shrinks while a TRACK resolves refuses it", as const request = await requests.next(); if (request.done) throw new Error("the handler never saw the request"); grant.set(grantOf("other")); - hooks.acceptRequest(request.value, produced); + request.value.serve(produced); await serving; expect(unauthorizedResets(resets)).toContain("unauthorized: live/cam"); @@ -2865,7 +2865,7 @@ test("lite draft-06: a grant that shrinks while TRACK_INFO is blocked resets it" const serving = publisher.runTrackInfo(new TrackMessage(Path.from("live/cam"), "video"), stream); const request = await requests.next(); if (request.done) throw new Error("the handler never saw the request"); - hooks.acceptRequest(request.value, produced); + request.value.serve(produced); await writing; grant.set(grantOf("other")); @@ -2914,7 +2914,7 @@ test("lite draft-06: a grant that shrinks while the broadcast resolves resets th if (request.done) throw new Error("the handler never saw the request"); grant.set(grantOf("other")); await Promise.resolve(); - hooks.acceptRequest(request.value, produced); + request.value.serve(produced); await serving; expect(unauthorizedResets(resets)).toContain("unauthorized: live/cam"); diff --git a/js/net/src/lite/tracks.test.ts b/js/net/src/lite/tracks.test.ts index ea5061fd47d..c35c7780250 100644 --- a/js/net/src/lite/tracks.test.ts +++ b/js/net/src/lite/tracks.test.ts @@ -7,7 +7,6 @@ import { accept, connect } from "../connection/index.ts"; import { fromTransport, NotFound, SessionCode, StreamCode, StreamError } from "../error.ts"; import { randomHop } from "../hop.ts"; import * as Instance from "../instance.ts"; -import { hooks } from "../internal.ts"; import { createMockTransportPair } from "../mock.ts"; import { Producer as OriginProducer } from "../origin.ts"; import * as Path from "../path.ts"; @@ -414,7 +413,7 @@ test("a path served through a covering prefix route is NOT_FOUND", async () => { for await (const request of dynamic.requested()) { const served = new BroadcastProducer(); served.createTrack("video"); - hooks.acceptRequest(request, served); + request.serve(served); } })(); const { list } = publisher(origin); @@ -431,7 +430,7 @@ test("a local read through a covering prefix route is NOT_FOUND, and through its for await (const request of dynamic.requested()) { const served = new BroadcastProducer(); served.createTrack("video"); - hooks.acceptRequest(request, served); + request.serve(served); } })(); } @@ -531,7 +530,7 @@ test("a front pinned to a named instance served through a covering prefix route for await (const request of dynamic.requested()) { const served = new BroadcastProducer(); served.createTrack("video"); - hooks.acceptRequest(request, served); + request.serve(served); } })(); const request = origin.consume().request(Path.from("room/alice")); diff --git a/js/net/src/order.test.ts b/js/net/src/order.test.ts index f97da7f0e4b..ea3ba400207 100644 --- a/js/net/src/order.test.ts +++ b/js/net/src/order.test.ts @@ -271,7 +271,7 @@ test("ietf keeps a closing group stream ranked until it settles", async () => { }); // One track fanned out to an ascending and a descending subscriber, the shape a relay serves -// from one upstream request (a JS app does not proxy, so the track is local here). The +// from one upstream request (the track is local here). The // aggregate a wire would request upstream turns descending once the descending subscriber // joins, so it is never held behind the other's backlog, and each session still serves its // own subscriber in its own order. diff --git a/js/net/src/origin-demand.test.ts b/js/net/src/origin-demand.test.ts index e55a6fe25d9..018a10d7679 100644 --- a/js/net/src/origin-demand.test.ts +++ b/js/net/src/origin-demand.test.ts @@ -6,7 +6,6 @@ import { NativeSession } from "./ietf/session.ts"; import { Subscribe as IetfSubscribe } from "./ietf/subscribe.ts"; import { Version as IetfVersion } from "./ietf/version.ts"; import * as Instance from "./instance.ts"; -import { hooks } from "./internal.ts"; import { Fetch } from "./lite/fetch.ts"; import { Publisher as LitePublisher } from "./lite/publisher.ts"; import { Subscribe as LiteSubscribe } from "./lite/subscribe.ts"; @@ -129,11 +128,11 @@ test("last cancellation finishes the internal wait and discards a late consumer" const keeper = source.consume(); const late = source.consume(); const close = spyOn(late, "close"); - hooks.acceptRequest(old, late); + old.serve(late); expect(close).toHaveBeenCalledTimes(1); close.mockRestore(); expect(source.closed.peek()).toBeUndefined(); - hooks.acceptRequest(fresh, source); + fresh.serve(source); await settle(); expect(next.active.peek()?.instance).toBe(dynamic.route.instance); next.close(); @@ -171,7 +170,7 @@ test.each([true, false])( } await settle(); const late = new SessionBroadcast(); - hooks.acceptRequest(old, late); + old.serve(late); expect(late.closed.peek()).toBeNull(); const next = origin.request(path); const fresh = (await requests.next()).value; @@ -210,7 +209,7 @@ test.each([ try { hold.abort(); await first; - hooks.acceptRequest(request, source); + request.serve(source); await settle(); if (other === "peer") expect((await second)?.closed).toBe(source.closed); else expect(local?.active.peek()?.instance).toBe(dynamics[routes > 1 ? 1 : 0].route.instance); @@ -258,7 +257,7 @@ test.each(["accept", "reject", "cancel"] as const)( const request = (await requests.next()).value; if (!request) throw new Error("expected a pending request"); try { - if (action === "accept") hooks.acceptRequest(request, source); + if (action === "accept") request.serve(source); if (action === "reject") request.reject(new Error("denied")); if (action === "cancel") hold.abort(); const result = await wait; @@ -266,9 +265,9 @@ test.each(["accept", "reject", "cancel"] as const)( hold.abort(); if (action === "accept") { expect(result?.closed).toBe(source.closed); - hooks.acceptRequest(request, source); + request.serve(source); request.reject(new Error("late")); - } else hooks.acceptRequest(request, source); + } else request.serve(source); expect(source.closed.peek()).toBeUndefined(); } finally { remove.mockRestore(); @@ -296,9 +295,9 @@ test("a pending local request changing routes withdraws the old route's work", a const late = source.consume(); const close = spyOn(late, "close"); try { - hooks.acceptRequest(old, late); + old.serve(late); expect(close).toHaveBeenCalledTimes(1); - hooks.acceptRequest(fresh, source); + fresh.serve(source); await settle(); expect(local.active.peek()?.instance).toBe(second.route.instance); } finally { @@ -332,7 +331,7 @@ test("cancelling an old instance waiter does not decrement a new instance's dema const source = new Broadcast(); try { old.reject(new Error("obsolete")); - hooks.acceptRequest(fresh, source); + fresh.serve(source); expect((await after)?.closed).toBe(source.closed); } finally { origin.close(); @@ -353,7 +352,7 @@ test.each(["answer", "release"] as const)( const br = b.requested(); const held = origin.request(path); const source = new Broadcast(); - hooks.acceptRequest((await ar.next()).value, source); + (await ar.next()).value.serve(source); await settle(); // Another instance wins new requests. The old handle stays on its own instance. const c = origin.requestsRoute(prefix, { instance: Instance.random(), cost: 0n }); @@ -378,7 +377,7 @@ test.each(["answer", "release"] as const)( const front = late.consume(); const close = spyOn(front, "close"); try { - hooks.acceptRequest(pending, front); + pending.serve(front); await settle(); if (action === "release") expect(close).toHaveBeenCalledTimes(1); else { @@ -415,7 +414,7 @@ test.each([0, 1])( const held = origin.request(path); const source = new Broadcast(); sources.push(source); - hooks.acceptRequest((await ar.next()).value, source); + (await ar.next()).value.serve(source); await settle(); entries.push({ primary, ar, br, held }); } @@ -439,9 +438,9 @@ test.each([0, 1])( // The slot is still detached until its microtask runs, but no longer owns demand. entries[released].held.close(); hold.abort(); - hooks.acceptRequest(pending[released], front); + pending[released].serve(front); expect(close).toHaveBeenCalledTimes(1); - hooks.acceptRequest(pending[1 - released], replacement); + pending[1 - released].serve(replacement); await wait; expect(readsFrom(entries[1 - released].held.active.peek(), replacement)).toBe(true); } finally { @@ -514,7 +513,7 @@ test.each(["accept", "reject"] as const)( const denied = new Error("denied"); try { hold.abort(cancelled); - if (answer === "accept") hooks.acceptRequest(request, source); + if (answer === "accept") request.serve(source); else request.reject(denied); expect(await first).toBe(cancelled); const result = await second; @@ -544,7 +543,7 @@ test.each([true, false])("last waiter cancellation and accept in one turn (cance const close = spyOn(front, "close"); try { if (cancelFirst) hold.abort(cancelled); - hooks.acceptRequest(request, front); + request.serve(front); if (!cancelFirst) hold.abort(cancelled); expect(await wait).toBe(cancelled); expect(close).toHaveBeenCalledTimes(cancelFirst ? 1 : 0); @@ -554,7 +553,7 @@ test.each([true, false])("last waiter cancellation and accept in one turn (cance const fresh = (await requests.next()).value; expect(fresh).not.toBe(request); if (!fresh) throw new Error("expected fresh request"); - hooks.acceptRequest(fresh, source); + fresh.serve(source); } const answer = await next; expect(answer?.closed).toBe(source.closed); @@ -589,7 +588,7 @@ test.each([true, false])("local demand survives same-turn cancellation only when const replacement = rejoin ? origin.request(path) : undefined; try { await settle(); - hooks.acceptRequest(request, front); + request.serve(front); expect(close).toHaveBeenCalledTimes(rejoin ? 0 : 1); if (replacement) { await settle(); @@ -599,7 +598,7 @@ test.each([true, false])("local demand survives same-turn cancellation only when const next = (await requests.next()).value; expect(next).not.toBe(request); if (!next) throw new Error("expected fresh request"); - hooks.acceptRequest(next, source); + next.serve(source); await settle(); expect(fresh.active.peek()?.instance).toBe(dynamic.route.instance); fresh.close(); diff --git a/js/net/src/origin-request.test.ts b/js/net/src/origin-request.test.ts index 9f490a0622d..9d9af2064a1 100644 --- a/js/net/src/origin-request.test.ts +++ b/js/net/src/origin-request.test.ts @@ -3,8 +3,7 @@ import { Producer as BroadcastProducer } from "./broadcast"; import { StreamCode, StreamError } from "./error"; import { Route } from "./hop"; import * as Instance from "./instance.ts"; -import { hooks } from "./internal.ts"; -import { type Following, Producer, type Publication, type Request, type Requesting } from "./origin"; +import { type Following, Producer, type Publication, type Requesting } from "./origin"; import * as Path from "./path"; import { wireOf } from "./wire"; @@ -170,7 +169,7 @@ test("followers track the serving prefix, ignoring descendants and re-prices", a const keeper = source.consume(); const prefix = origin.requestsRoute(Path.from("pool")); const serving = (async () => { - for await (const request of prefix.requested()) hooks.acceptRequest(request, source.consume()); + for await (const request of prefix.requested()) request.serve(source.consume()); })(); const request = origin.follow(Path.from("pool/job")); await settle(); @@ -226,7 +225,7 @@ test("a follower tracks a route replaced by an identical one", async () => { const serve = (source: BroadcastProducer) => { const route = origin.requestsRoute(path); void (async () => { - for await (const request of route.requested()) hooks.acceptRequest(request, source.consume()); + for await (const request of route.requested()) request.serve(source.consume()); })(); return route; }; @@ -257,7 +256,7 @@ test("an origin closing settles a follower a served route resolved", async () => const source = new BroadcastProducer(); const route = origin.requestsRoute(path); void (async () => { - for await (const request of route.requested()) hooks.acceptRequest(request, source.consume()); + for await (const request of route.requested()) request.serve(source.consume()); })(); const request = origin.follow(path); await settle(); @@ -307,7 +306,7 @@ for (const received of [false, true]) { const source = new BroadcastProducer(); const route = received ? wireOf(origin).receive(path, Route.default) : origin.requestsRoute(path); void (async () => { - for await (const request of route.requested()) hooks.acceptRequest(request, source.consume()); + for await (const request of route.requested()) request.serve(source.consume()); })(); const request = origin.request(path); @@ -372,20 +371,56 @@ test("a prepared answer cannot announce itself before publish", async () => { origin.close(); }); -test("an application claim cannot accept an arbitrary broadcast", async () => { +test("an application serves held content without an exact route", async () => { const origin = new Producer(); const claim = origin.requests(Path.from("room")); const requests = claim.requested(); const request = origin.request(Path.from("room/alice")); - const pending: Request | undefined = (await requests.next()).value; + const pending = (await requests.next()).value; if (!pending) throw new Error("expected a request"); - // @ts-expect-error Only sessions accept a request; an application prepares and publishes. - expect(pending.accept).toBeUndefined(); + const source = new BroadcastProducer(); + source.createTrack("data").writeFrame({ payload: new TextEncoder().encode("held") }); + pending.serve(source.consume()); + await settle(); + const reader = request.active.peek()?.track("data").subscribe().ordered(); + expect(await reader?.readString()).toBe("held"); + expect(wireOf(origin.consume()).advertised.peek()?.has(Path.from("room/alice"))).toBe(false); + reader?.close(); request.close(); claim.close(); + source.close(); origin.close(); }); +for (const withdraw of ["unannounce", "replace"] as const) { + test(`a published answer is not cached after ${withdraw}`, async () => { + const origin = new Producer(); + const claim = origin.requests(Path.from("room")); + const requests = claim.requested(); + const path = Path.from("room/alice"); + const first = origin.request(path); + const pending = (await requests.next()).value; + if (!pending) throw new Error("expected a request"); + const publication = pending.prepare().publish(); + await settle(); + const held = first.active.peek()?.clone(); + if (withdraw === "unannounce") publication.unannounce(); + else origin.createBroadcast(path).broadcast.close(); + const next = origin.request(path); + await settle(); + expect(next.active.peek()).toBeUndefined(); + const fresh = (await requests.next()).value; + if (!fresh) throw new Error("expected another request"); + fresh.reject(new Error("no replacement")); + held?.close(); + next.close(); + first.close(); + publication.broadcast.close(); + claim.close(); + origin.close(); + }); +} + test("closing a prepared answer refuses the request and closes its broadcast", async () => { const origin = new Producer(); const claim = origin.requests(Path.from("room")); @@ -578,7 +613,7 @@ test("an instance-pinned follower resumes when its instance returns after a gap" const serve = (instance: Instance.Valid, broadcast: BroadcastProducer) => { const route = origin.requestsRoute(path, { instance: instance }); void (async () => { - for await (const request of route.requested()) hooks.acceptRequest(request, broadcast.consume()); + for await (const request of route.requested()) request.serve(broadcast.consume()); })(); return route; }; @@ -731,7 +766,7 @@ test("a pending request retries a route gap and never retargets after resolving" if (!pending) throw new Error("replacement route was not requested"); const source = new BroadcastProducer(); const keeper = source.consume(); - hooks.acceptRequest(pending, source.consume()); + pending.serve(source.consume()); await settle(); expect(requested.active.peek()?.instance).toBe(second.route.instance); const replacement = origin.createBroadcast(path); @@ -780,7 +815,7 @@ test.each(["request", "follow"] as const)("a %s pinned to a losing instance reso const pending = (await asked.next()).value; if (!pending) throw new Error("the pinned instance's route was not asked"); const source = new BroadcastProducer(); - hooks.acceptRequest(pending, source.consume()); + pending.serve(source.consume()); await settle(); expect(requested.closed.peek()).toBeUndefined(); expect(requested.active.peek()?.instance).toBe(pinned); @@ -792,7 +827,7 @@ test.each(["request", "follow"] as const)("a %s pinned to a losing instance reso const answer = (await winning.requested().next()).value; if (!answer) throw new Error("the winning route was not asked"); const other = new BroadcastProducer(); - hooks.acceptRequest(answer, other.consume()); + answer.serve(other.consume()); await settle(); expect(plain.active.peek()?.instance).toBe(winning.route.instance); diff --git a/js/net/src/origin.test.ts b/js/net/src/origin.test.ts index fc27871eb74..a26e5198008 100644 --- a/js/net/src/origin.test.ts +++ b/js/net/src/origin.test.ts @@ -6,7 +6,7 @@ import { type Consumer as BroadcastConsumer, Producer as BroadcastProducer } fro import { StreamCode, StreamError } from "./error.ts"; import { HopSchema, Route } from "./hop.ts"; import * as Instance from "./instance.ts"; -import { chainHash, hooks, presented, spreadHash } from "./internal.ts"; +import { chainHash, presented, spreadHash } from "./internal.ts"; import { SessionBroadcast, textFrame } from "./mock.ts"; import type { Consumer, Table } from "./origin.ts"; import { Producer } from "./origin.ts"; @@ -33,7 +33,7 @@ function serve(origin: Producer, prefix: Path.Valid, consume: () => BroadcastCon void (async () => { try { for await (const request of handle.requested()) { - hooks.acceptRequest(request, consume()); + request.serve(consume()); } } catch { handle.close(); @@ -1117,7 +1117,7 @@ test("a handle serves a request under live", async () => { const produced = new BroadcastProducer(); produced.createTrack("video", { timescale: Timescale.MILLI }); - hooks.acceptRequest(req, produced); + req.serve(produced); await settle(); expect(request.active.peek()).toBeDefined(); @@ -1131,7 +1131,7 @@ test("a handle serves a request under live", async () => { origin.close(); }); -test("an originated route refuses a broadcast a session delivered", async () => { +test("an originated route serves held content a session delivered", async () => { const origin = new Producer(); const handle = origin.requestsRoute(Path.from("live")); const it = handle.requested(); @@ -1142,15 +1142,10 @@ test("an originated route refuses a broadcast a session delivered", async () => // What lite and IETF do when a session hands back a consumed broadcast. const foreign = new BroadcastProducer().consume(); overrideBroadcastWire(foreign, {}); - expect(() => hooks.acceptRequest(req, foreign)).toThrow("origin cannot serve a broadcast it did not produce"); - - const produced = new BroadcastProducer(); - produced.createTrack("video"); - hooks.acceptRequest(req, produced.consume()); + req.serve(foreign); expect(await pending).toBeDefined(); handle.close(); - produced.close(); foreign.close(); origin.close(); }); @@ -1197,7 +1192,7 @@ test("an accepted dynamic broadcast is retired when it closes, and its handle re const first = await it.next(); const produced = new BroadcastProducer(); produced.createTrack("video", { timescale: Timescale.MILLI }); - hooks.acceptRequest(first.value, produced); + first.value.serve(produced); await settle(); const held = request.active.peek(); expect(held?.track("video").subscribe()).toBeDefined(); @@ -1210,7 +1205,7 @@ test("an accepted dynamic broadcast is retired when it closes, and its handle re expect(second.value?.path).toBe(path); const replacement = new BroadcastProducer(); replacement.createTrack("video", { timescale: Timescale.MILLI }); - hooks.acceptRequest(second.value, replacement); + second.value.serve(replacement); await settle(); expect(request.active.peek()).toBe(held); expect(readsFrom(held, replacement)).toBe(true); @@ -1249,7 +1244,7 @@ test("a peer is offered and served the cheapest originated route", async () => { const pending = wireOf(consumer).demand(Path.from("live/cam")); const { value: req } = await cheap.requested().next(); const upstream = new BroadcastProducer(); - hooks.acceptRequest(req, upstream.consume()); + req.serve(upstream.consume()); expect(await pending).toBeDefined(); // An exact-path local broadcast competes with them on cost too. @@ -1309,7 +1304,7 @@ test("a request refusal does not keep demand from asking again", async () => { const { value: second } = await it.next(); expect(second?.path).toBe(Path.from("live/cam")); const produced = new BroadcastProducer(); - hooks.acceptRequest(second, produced); + second.serve(produced); await expect(pending).resolves.toBeDefined(); handle.close(); @@ -1333,7 +1328,7 @@ test("advancing requested without settling rejects the previous request", async await expect(firstDemand).rejects.toMatchObject({ code: StreamCode.Unroutable }); const produced = new BroadcastProducer(); - hooks.acceptRequest(second.value, produced); + second.value.serve(produced); await expect(secondDemand).resolves.toBeDefined(); handle.close(); @@ -1399,7 +1394,7 @@ test("an outranked route keeps serving until its replacement answers", async () // Once it answers, the request's tracks read it, under the same broadcast. const replacement = new BroadcastProducer(); const { value: req } = await asked; - hooks.acceptRequest(req, replacement.consume()); + req.serve(replacement.consume()); await settle(); expect(request.active.peek()).toBe(first); expect(readsFrom(first, replacement)).toBe(true); @@ -1736,7 +1731,7 @@ test("a refusal from a superseded route does not end the request", async () => { expect(request.closed.peek()).toBeUndefined(); const produced = new BroadcastProducer(); - hooks.acceptRequest(req, produced); + req.serve(produced); await settle(); expect(request.active.peek()).toBeDefined(); @@ -1788,7 +1783,7 @@ test("close rejects queued requests as unroutable", async () => { expect((await handle.requested().next()).done).toBe(true); expect(request.active.peek()).toBeUndefined(); - hooks.acceptRequest(req, new BroadcastProducer()); + req.serve(new BroadcastProducer()); await settle(); expect(request.active.peek()).toBeUndefined(); @@ -1858,7 +1853,7 @@ test("announced filters before rooting and retains lifecycle, routing and watch const request = reader.request(Path.from("cam")); const incoming = await broad.requested().next(); if (!incoming.value) throw new Error("missing served request"); - hooks.acceptRequest(incoming.value, source.consume()); + incoming.value.serve(source.consume()); await new Promise((resolve) => setImmediate(resolve)); expect(request.active.peek()).toBeDefined(); request.close(); @@ -1908,7 +1903,7 @@ test("an equal-cost pool spreads its paths the same way on every node", async () void (async () => { for await (const request of handle.requested()) { served.set(request.path, hop); - hooks.acceptRequest(request, new BroadcastProducer()); + request.serve(new BroadcastProducer()); } })(); return handle; @@ -1947,7 +1942,7 @@ test("an equal-cost replacement at its own path wins whatever its hop", async () void (async () => { for await (const request of handle.requested()) { served.push(hop); - hooks.acceptRequest(request, new BroadcastProducer()); + request.serve(new BroadcastProducer()); } })(); return handle; @@ -2169,7 +2164,7 @@ test("a scoped dynamic only serves allowed paths and presents relative requests" await new Promise((resolve) => setImmediate(resolve)); expect(pending.value?.path).toBe(Path.from("room/alice/chat")); const broadcast = new BroadcastProducer(); - hooks.acceptRequest(pending.value, broadcast); + pending.value.serve(broadcast); await new Promise((resolve) => setImmediate(resolve)); expect(request.active.peek()).toBeDefined(); dynamic.updateRoute({ cost: 2n }); @@ -2307,7 +2302,7 @@ test("broadcast handles carry the path they were created or requested at", async const request = origin.request(Path.from("live/bob")); const pending = await dynamic.requested().next(); const served = new BroadcastProducer(); - hooks.acceptRequest(pending.value, served); + pending.value.serve(served); expect(request.active.peek()?.path).toBe(Path.from("live/bob")); clone?.close(); @@ -2332,7 +2327,7 @@ test("a higher epoch of a dynamic route supersedes a cheaper local broadcast of const request = origin.consume().request(path); const asked = await requests.next(); expect(asked.value?.path).toBe(path); - hooks.acceptRequest(asked.value, served); + asked.value.serve(served); await settle(); expect(readsFrom(request.active.peek(), served)).toBe(true); request.close(); @@ -2356,7 +2351,7 @@ test("a higher epoch that is not the best route still supersedes a local broadca const request = origin.consume().request(path); // The stale local broadcast is ineligible, so the cheapest eligible route answers. const asked = await requests.next(); - hooks.acceptRequest(asked.value, served); + asked.value.serve(served); await settle(); expect(readsFrom(request.active.peek(), served)).toBe(true); request.close(); @@ -2463,12 +2458,12 @@ test("demand held across an instance change asks again, unless it named the old // Another instance now serves the route: the old handler's answer is for the old one. handle.updateRoute({ ...handle.route, instance: NEWER }); - hooks.acceptRequest(req, new BroadcastProducer().consume()); + req.serve(new BroadcastProducer().consume()); await expect(pinned).rejects.toThrow("unroutable"); const next = new BroadcastProducer(); const track = next.createTrack("video"); - hooks.acceptRequest((await it.next()).value, next); + (await it.next()).value.serve(next); const subscription = (await unpinned)?.track("video").subscribe(); track.createGroup(7n); expect((await subscription?.recvGroup())?.sequence).toBe(7n); @@ -2512,11 +2507,11 @@ test("demand held across an instance round trip still asks again", async () => { // Released by the first change; the instance coming back does not undo that. handle.updateRoute({ ...handle.route, instance: NEWER }); handle.updateRoute({ ...handle.route, instance: INSTANCE }); - hooks.acceptRequest(req, new BroadcastProducer().consume()); + req.serve(new BroadcastProducer().consume()); const next = new BroadcastProducer(); const track = next.createTrack("video"); - hooks.acceptRequest((await it.next()).value, next); + (await it.next()).value.serve(next); const subscription = (await demanded)?.track("video").subscribe(); track.createGroup(7n); expect((await subscription?.recvGroup())?.sequence).toBe(7n); @@ -2606,13 +2601,13 @@ test("a request held across an instance change asks again and never takes the ol const old = (await requests.next()).value; dynamic.updateRoute({ ...dynamic.route, instance: NEWER }); const current = origin.consume().request(path, { instance: NEWER }); - hooks.acceptRequest(old, new BroadcastProducer().consume()); + old.serve(new BroadcastProducer().consume()); await settle(); expect(pinned.active.peek()).toBeUndefined(); expect(unpinned.active.peek()).toBeUndefined(); expect(current.active.peek()).toBeUndefined(); const next = (await requests.next()).value; - hooks.acceptRequest(next, new BroadcastProducer().consume()); + next.serve(new BroadcastProducer().consume()); await settle(); expect(unpinned.active.peek()?.instance).toBe(NEWER); expect(current.active.peek()?.instance).toBe(NEWER); @@ -2645,7 +2640,7 @@ test.each([ const held = origin.consume().request(path); const old = new BroadcastProducer(); const oldTrack = old.createTrack("video"); - hooks.acceptRequest((await requests.next()).value, old); + (await requests.next()).value.serve(old); await settle(); const resolved = held.active.peek(); expect(resolved?.instance).toBe(from); @@ -2682,7 +2677,7 @@ test.each([ const demanded = wireOf(origin.consume()).demand(path); const next = new BroadcastProducer(); const nextTrack = next.createTrack("video"); - hooks.acceptRequest((await requests.next()).value, next); + (await requests.next()).value.serve(next); await settle(); expect(fresh.active.peek()?.instance).toBe(to); const subscription = fresh.active.peek()?.track("video").subscribe(); @@ -2723,7 +2718,7 @@ test("an instance update does not retain an answer that already closed", async ( const requests = dynamic.requested(); const held = origin.consume().request(path); const old = new BroadcastProducer(); - hooks.acceptRequest((await requests.next()).value, old); + (await requests.next()).value.serve(old); old.close(); // The server's closure callback has not removed the answer yet. dynamic.updateRoute({ instance: NEWER }); @@ -2732,7 +2727,7 @@ test("an instance update does not retain an answer that already closed", async ( expect(held.active.peek()).toBeUndefined(); const fresh = origin.consume().request(path); const next = new BroadcastProducer(); - hooks.acceptRequest((await requests.next()).value, next); + (await requests.next()).value.serve(next); expect(fresh.active.peek()?.instance).toBe(NEWER); fresh.close(); next.close(); @@ -2751,7 +2746,7 @@ test("an unread resolved request retains its broadcast until its last handle clo const requests = dynamic.requested(); const held = origin.consume().request(path); const old = new SessionBroadcast(); - hooks.acceptRequest((await requests.next()).value, old); + (await requests.next()).value.serve(old); // Change instances before the active getter or its subscription can clone the answer. dynamic.updateRoute({ instance: NEWER }); expect(old.closed.peek()).toBeUndefined(); @@ -2773,14 +2768,14 @@ test("a session's re-request after an instance update asks the handler again", a const before = wire.demand(path); const old = new BroadcastProducer(); - hooks.acceptRequest((await requests.next()).value, old); + (await requests.next()).value.serve(old); expect(await before).toBeDefined(); dynamic.updateRoute({ ...dynamic.route, instance: NEWER }); const after = wire.demand(path); const next = new BroadcastProducer(); const track = next.createTrack("video"); - hooks.acceptRequest((await requests.next()).value, next); + (await requests.next()).value.serve(next); const subscription = (await after)?.track("video").subscribe(); track.createGroup(7n); expect((await subscription?.recvGroup())?.sequence).toBe(7n); @@ -2804,7 +2799,7 @@ test("an update does not override route selection: another claim at the instance const held = origin.consume().request(path); const answer = new BroadcastProducer(); - hooks.acceptRequest((await firstRequests.next()).value, answer); + (await firstRequests.next()).value.serve(answer); await settle(); expect(held.active.peek()?.instance).toBe(INSTANCE); @@ -2815,7 +2810,7 @@ test("an update does not override route selection: another claim at the instance const fresh = origin.consume().request(path); const replacement = new BroadcastProducer(); const track = replacement.createTrack("video"); - hooks.acceptRequest((await secondRequests.next()).value, replacement); + (await secondRequests.next()).value.serve(replacement); await settle(); expect(held.active.peek()?.instance).toBe(INSTANCE); expect(fresh.active.peek()?.instance).toBe(INSTANCE); diff --git a/js/net/src/origin.ts b/js/net/src/origin.ts index ce31ad0afba..d73ea0cc001 100644 --- a/js/net/src/origin.ts +++ b/js/net/src/origin.ts @@ -364,13 +364,10 @@ class ServeState { readonly root: Path.Valid; /** The prefix the route claims; every served path is at or beneath it. */ readonly prefix: Path.Valid; - /** False when a session announced the route: it may serve that session's broadcast. */ - readonly originated: boolean; - constructor(root: Path.Valid, prefix: Path.Valid, originated: boolean) { + constructor(root: Path.Valid, prefix: Path.Valid) { this.root = root; this.prefix = prefix; - this.originated = originated; } queue = new Signal(new Set()); @@ -1472,7 +1469,7 @@ export class Producer implements Table { return this.#insertRoute(prefix, Route.default, true, true); } - /** Insert an originated claim with route metadata that answers through `hooks.acceptRequest`, for tests and benches. @internal */ + /** Insert an originated claim with route metadata that answers through `Request.serve`, for tests and benches. @internal */ requestsRoute( prefix: Path.Valid, route: @@ -1514,7 +1511,7 @@ export class Producer implements Table { // A handle that names no instance serves one of its own. if (route.instance === undefined) route = { ...route, instance: Instance.random(), epoch: 0n }; publishPath(prefix); - const server = new ServeState(this.#scope.root, prefix, originated); + const server = new ServeState(this.#scope.root, prefix); server.onChange = (path) => this.#state.refresh(path); const entry: RouteEntry = { identity: {}, @@ -2626,8 +2623,9 @@ export class Requests { * A pending request for a broadcast to be served on demand. * * Yielded by {@link Requests.requested}. {@link prepare} then {@link Prepared.publish} - * resolves it with a new exact-path broadcast; {@link reject} resolves it with an error. - * Advancing the iterator or closing it without either rejects the request. + * resolves it with a new exact-path broadcast; {@link serve} answers with a held broadcast; + * {@link reject} resolves it with an error. + * Advancing the iterator or closing it without answering rejects the request. * * @public */ @@ -2652,10 +2650,11 @@ export class Request { }; publishPrepared = (request, publication) => { if (!request.#server.has(request)) throw new Error("request is closed"); - // The exact route usually settles the request on its own, resolving its waiters - // through the answer's fresh instance; answer it directly if it is still pending. publication.announce(); - if (request.#server.has(request)) request.#server.accept(request, publication.broadcast.consume()); + // Its exact route owns availability: never cache a published job under the + // prefix, which would keep serving it after that exact route is withdrawn. + request.#server.forget(Path.join(request.#server.root, request.path), request); + request.#server.settled.update((n) => n + 1); return publication; }; rejectPrepared = (request, err) => request.#server.reject(request, err); @@ -2664,7 +2663,6 @@ export class Request { request.#withdrawn = true; void err; }; - hooks.acceptRequest = (request, source) => request.#accept(source); } /** Start answering as a new stream under a fresh instance, hidden until published. */ @@ -2678,22 +2676,21 @@ export class Request { return makePrepared(this, publication); } - // Resolve a session-forwarded request with its peer's routed broadcast, through - // `hooks.acceptRequest`. The caller keeps producing into `source`; repeat requests for - // the path share it for as long as it stays live. Throws when handed a broadcast a - // session delivered to an originated claim, leaving the request open: it would go out - // labeled with this origin's hop. - #accept(source: broadcast.Producer | broadcast.Consumer): void { + /** + * Serve a held broadcast under this prefix route without announcing an exact route. + * + * Takes ownership of a consumer; a producer stays the caller's. Every answer at this + * path belongs to the prefix route's instance and must continue the same sequences and + * bytes. Start a new prefix route for different content, or use {@link prepare} and + * {@link Prepared.publish} for a job that can restart independently. + */ + serve(source: broadcast.Producer | broadcast.Consumer): void { if (this.#done) { // A withdrawn request takes no answer. Only the handed-off consumer is ours; // the application still owns its producer and any other consumers. if (this.#withdrawn && source instanceof broadcast.Consumer) source.close(); return; } - if (this.#publisher) throw new Error("claim answers must be prepared and published"); - if (this.#server.originated && !(source instanceof broadcast.Producer) && wireOf(source).fromSession) { - throw new Error("origin cannot serve a broadcast it did not produce"); - } this.#done = true; const front = source instanceof broadcast.Producer ? source.consume() : source; this.#server.accept(this, front); diff --git a/js/net/src/resume.model.test.ts b/js/net/src/resume.model.test.ts index 1e0add73d51..f4e56b67cd4 100644 --- a/js/net/src/resume.model.test.ts +++ b/js/net/src/resume.model.test.ts @@ -458,10 +458,7 @@ class Model { const producer = broadcast.createTrack("video", { timescale: Timescale.MILLI }); void (async () => { for await (const request of serving.requested()) { - hooks.acceptRequest( - request, - Upstream.of(broadcast, (sequence, local) => this.fill(instance, slot, sequence, local)), - ); + request.serve(Upstream.of(broadcast, (sequence, local) => this.fill(instance, slot, sequence, local))); } })(); publisher.routes[slot] = { track: producer, serving, broadcast, groups: new Map(), givenUp: new Set() }; diff --git a/js/net/src/resume.test.ts b/js/net/src/resume.test.ts index c3458c25619..31c098ccddc 100644 --- a/js/net/src/resume.test.ts +++ b/js/net/src/resume.test.ts @@ -41,7 +41,7 @@ async function isPending(promise: Promise): Promise { function serve(origin: Producer, source: BroadcastProducer, cost: bigint) { const handle = wireOf(origin).receive(path, Route.normalize({ instance: INSTANCE, cost })); void (async () => { - for await (const request of handle.requested()) hooks.acceptRequest(request, source.consume()); + for await (const request of handle.requested()) request.serve(source.consume()); })(); return () => handle.close(); } @@ -994,7 +994,7 @@ test("between routes a reader keeps reading the copy it has", async () => { expect(drain(sub)).toEqual([1n]); const { value: pending } = await asked.next(); - hooks.acceptRequest(pending, b.consume()); + pending.serve(b.consume()); await settle(); await settle(); tb.write(1n); @@ -1473,19 +1473,6 @@ test("a datagram reader lets go of the copies a swap replaced", async () => { b.close(); }); -test("a front remembers it served a session's broadcast between routes", () => { - const front = new Front(); - const a = new BroadcastProducer(); - const session = a.consume(); - overrideBroadcastWire(session, {}); - front.serve(session); - expect(front.fromSession).toBe(true); - front.park(); - expect(front.fromSession).toBe(true); - front.consumer.close(); - a.close(); -}); - test("a failed group on a route whose replacement was refused ends with the refusal", async () => { const front = new Front(); const a = new BroadcastProducer(); diff --git a/js/net/src/resume.ts b/js/net/src/resume.ts index 770361aa7f4..5eeb0f98130 100644 --- a/js/net/src/resume.ts +++ b/js/net/src/resume.ts @@ -152,14 +152,11 @@ class Source { readonly wire: BroadcastWire; /** The table's handle this was served from, so serving it again is a no-op. */ readonly from: broadcast.Consumer; - /** Whether a session delivered it, read from the handle served rather than the clone. */ - readonly fromSession: boolean; #consumer: broadcast.Consumer; #holds = 0; constructor(from: broadcast.Consumer) { this.from = from; - this.fromSession = wireOf(from).fromSession === true; this.#consumer = from.clone(); this.wire = wireOf(this.#consumer); } @@ -1591,8 +1588,6 @@ export class Front { #concluded = false; /** The tracks each source was checked against the recorded properties for; see #verify. */ #verified = new WeakMap>(); - /** Whether any source it served came from a session, kept between routes. */ - #fromSession = false; constructor() { this.consumer = makeFrontConsumer(this); @@ -1738,7 +1733,6 @@ export class Front { if (this.#concluded || this.#source?.from === from) return; const source = new Source(from); source.retain(); - this.#fromSession ||= source.fromSession; const previous = this.#source; this.#source = source; this.#retired(); @@ -1773,14 +1767,6 @@ export class Front { this.#retire = new AbortController(); } - /** - * Whether a broadcast it served came from a session; see {@link BroadcastWire.fromSession}. - * Sticky, since the front can move back onto a session's route at any time. - */ - get fromSession(): boolean { - return this.#fromSession; - } - // Splice `source`'s copy of a track in, once it claims the same content as the copies before. #splice(route: Route, source: Source): void { const recorded = this.#info.get(route.name); @@ -2061,9 +2047,6 @@ class FrontConsumer extends broadcast.Consumer { resolveTrackInfo: (name, hold) => front.resolveTrackInfo(name, hold), largest: (name) => front.largest(name), fetchGroup: (name, sequence, options) => front.fetchGroup(name, sequence, options), - get fromSession() { - return front.fromSession; - }, }); } diff --git a/js/net/src/untimed.test.ts b/js/net/src/untimed.test.ts index 8339b7cec7c..2ec52a88be1 100644 --- a/js/net/src/untimed.test.ts +++ b/js/net/src/untimed.test.ts @@ -5,7 +5,6 @@ import { expect, test } from "bun:test"; import { type Consumer as BroadcastConsumer, Producer as BroadcastProducer } from "./broadcast.ts"; import { accept, connect } from "./connection/index.ts"; import * as Ietf from "./ietf/index.ts"; -import { hooks } from "./internal.ts"; import * as Lite from "./lite/index.ts"; import { createMockTransportPair } from "./mock.ts"; import { Producer as OriginProducer } from "./origin.ts"; @@ -129,15 +128,15 @@ test("a forwarded untimed track stays untimed", async () => { } })(); - // Serve the downstream session from the upstream one. A JS origin refuses to serve a - // broadcast a session delivered, so the forwarding node republishes a copy it produced. + // Serve the downstream session from the upstream one through a copy the forwarding + // node produces. const dynamic = relay.requestsRoute(Path.from("test")); const inputs: BroadcastConsumer[] = []; const forwarding = (async () => { for await (const request of dynamic.requested()) { const input = wireOf(ingest).consume(request.path); inputs.push(input); - hooks.acceptRequest(request, await republish(input)); + request.serve(await republish(input)); } })(); diff --git a/js/net/src/wire.ts b/js/net/src/wire.ts index 6946d5fbd5b..f56f2c2adca 100644 --- a/js/net/src/wire.ts +++ b/js/net/src/wire.ts @@ -32,11 +32,6 @@ export interface Broadcast { tracks(owner?: object): Tracks; /** Answer the broadcast's listings, as a session does with its peer's; throws while another answers. */ lister(): Lister; - /** - * A session delivered this broadcast. An originated route refuses to serve it: - * publishing it would name this origin's hop for upstream content. - */ - fromSession?: boolean; } /** Receives one change to the watched prefixes: `prefix` is now (or no longer) wanted. */ @@ -153,19 +148,14 @@ export function registerWire(handle: object, view: View): void { views.set(handle, view); } -/** - * Replace selected operations on a broadcast's package-private view. - * - * Only a session-delivered broadcast does this, so the replacement is marked. - * An origin refuses to serve that broadcast on a route it originated. - */ +/** Replace selected operations on a broadcast's package-private view. */ export function overrideBroadcastWire( handle: broadcast.Consumer, overrides: Partial>, ): void { const view = views.get(handle); if (!view) throw new Error("broadcast has no wire view"); - views.set(handle, { ...(view as Broadcast), ...overrides, fromSession: true }); + views.set(handle, { ...(view as Broadcast), ...overrides }); } export function wireOf(handle: broadcast.Producer): Produced; diff --git a/kt/moq/MIGRATE.md b/kt/moq/MIGRATE.md index 98257b6dad4..3e7674ae770 100644 --- a/kt/moq/MIGRATE.md +++ b/kt/moq/MIGRATE.md @@ -137,6 +137,7 @@ Publish a replacement under a new name, and expect a finished track's demand wat `OriginProducer.dynamic(prefix)` takes no route, and `OriginDynamic.update` is gone. Replace `request.accept(broadcast)` with `request.prepare()`, which returns a `BroadcastPrepared`: fill its `broadcast()`, then `publish()` announces it at the exact path under a fresh instance of its own and returns its producer. +To answer with a broadcast you already hold, `request.serve(producer.consume())` serves it under the prefix route without announcing an exact route. ### Anchors can name a time (#6074) diff --git a/py/moq-rs/MIGRATE.md b/py/moq-rs/MIGRATE.md index aad98da3ea3..1bed9bfd7d1 100644 --- a/py/moq-rs/MIGRATE.md +++ b/py/moq-rs/MIGRATE.md @@ -134,6 +134,7 @@ Publish a replacement under a new name, and expect a finished track's demand wat `OriginProducer.dynamic(prefix)` takes no route, and `OriginDynamic.update` is gone. Replace `request.accept(broadcast)` with `prepared = request.prepare()`, fill `prepared.broadcast`, then `prepared.publish()`, which announces it at the exact path under a fresh instance of its own and returns its producer. +To answer with a broadcast you already hold, `request.serve(producer.consume())` serves it under the prefix route without announcing an exact route. ### Anchors can name a time (#6074) diff --git a/py/moq-rs/README.md b/py/moq-rs/README.md index a14ba3aabf9..6442e1e0935 100644 --- a/py/moq-rs/README.md +++ b/py/moq-rs/README.md @@ -259,7 +259,7 @@ Every handle whose cleanup is `cancel()` is an async context manager, so exiting - `.broadcast → BroadcastProducer`. The broadcast to fill. - `.announce(route=None)`, `.unannounce()`. Advertise or retract its exact path; both raise `Closed` once the broadcast closed. - **`OriginRequests`**. Async source of broadcasts requested by consumers. - - `await .requested_broadcast() → BroadcastRequest`. Call `.prepare()`, fill its `.broadcast`, then `.publish() → Publication` to serve it as a new stream under a fresh instance, or `.reject(code)` to fail the requester. + - `await .requested_broadcast() → BroadcastRequest`. Call `.serve(consumer)` to answer with held content under the prefix route's continuous sequence space, `.prepare()` then fill its `.broadcast` and `.publish() → Publication` for an independently restarting job under a fresh instance, or `.reject(code)` to fail the requester. - Async iterator yielding `BroadcastRequest` - **`OriginConsumer`**. Discover broadcasts. - `.announced(prefix, filter=None) → AnnounceConsumer` (async iterator of `AnnounceEvent`: `AnnounceEventStart`, `AnnounceEventUpdate`, `AnnounceEventEnd`, `AnnounceEventRestart`, or `AnnounceEventTakeover`, each carrying an `Announce` whose `.route.instance` names the stream; on a restart, request the path again; a takeover continues what the route at `.predecessor` served); `filter` is a pattern relative to the literal prefix, while each `Announce.prefix` stays origin-relative and `.captures` is a required list of wildcard matches, empty without wildcards diff --git a/py/moq-rs/moq/origin.py b/py/moq-rs/moq/origin.py index aa1d145d149..751735b1aea 100644 --- a/py/moq-rs/moq/origin.py +++ b/py/moq-rs/moq/origin.py @@ -124,6 +124,10 @@ def prepare(self) -> BroadcastPrepared: """Start answering as a new stream under a fresh instance, hidden until published.""" return BroadcastPrepared(self._inner.prepare()) + def serve(self, broadcast: BroadcastConsumer) -> None: + """Serve held content under the prefix route's continuous sequence space, without an exact route.""" + self._inner.serve(broadcast._inner) + def reject(self, error_code: int) -> None: """Reject the request with an application error code.""" self._inner.reject(error_code) diff --git a/py/moq-rs/tests/test_local.py b/py/moq-rs/tests/test_local.py index 6ba6d0b4cd6..814bc5b7cf4 100644 --- a/py/moq-rs/tests/test_local.py +++ b/py/moq-rs/tests/test_local.py @@ -802,6 +802,27 @@ async def test_dynamic_broadcast_request(): served.broadcast.close() +async def test_dynamic_serves_held_content_without_an_exact_route(): + origin = moq.OriginProducer() + dynamic = origin.requests("live") + held = moq.BroadcastProducer() + track = held.publish_track("status", moq.TrackInfo(timescale=1_000_000)) + source = held.consume() + requesting = asyncio.create_task(origin.consume().request("live/cam")) + request = await dynamic.requested_broadcast() + request.serve(source) + with pytest.raises(Exception): + request.serve(source) + broadcast = await requesting + reader = await broadcast.subscribe_track("status") + track.write_frame(b"held", moq.Timestamp(1, 1_000_000)) + frame = await reader.read_frame() + assert frame is not None and frame.payload == b"held" + track.finish() + held.close() + dynamic.cancel() + + async def test_dynamic_broadcast_request_can_reject(): origin = moq.OriginProducer() dynamic = origin.requests("") diff --git a/quest/m1/announce-takeover.md b/quest/m1/announce-takeover.md index 0a55f9850f3..494d1e33023 100644 --- a/quest/m1/announce-takeover.md +++ b/quest/m1/announce-takeover.md @@ -62,7 +62,7 @@ this quest removes the predecessor machinery and grows to [XL]. [One Route handle](/quest/m1/api-audit/route/handle.md) creates the path's exact route under the prefix route's instance by default, and the answer it gives the waiting request is that route's broadcast. A job - that serves a held broadcast through [serve](/quest/m1/api-audit/route/serve.md) + that serves a held broadcast through `Request::serve` never announces an exact route, so it needs none of this. - **One stream per path and instance.** A claim may answer a path under its instance only while that stream is live. Once the job's route ends, diff --git a/quest/m1/api-audit/route/README.md b/quest/m1/api-audit/route/README.md index 03feacbbf08..a89b75f086d 100644 --- a/quest/m1/api-audit/route/README.md +++ b/quest/m1/api-audit/route/README.md @@ -37,7 +37,7 @@ resets is serving a held broadcast with no separate exact route. The user's "it worked before #6496" did not reproduce on any older tree, including one before [moq-dev/moq#5678](https://github.com/moq-dev/moq/pull/5678). Their proposed `accept_published(&Publication)` would not avoid the reset, -so it was dropped. Their relay instead gets [serve](/quest/m1/api-audit/route/serve.md). +so it was dropped. Their relay instead uses `Request::serve` for its held broadcast. The maintainer then asked for an audit of the origin, claim and epoch API. Four read-only audits covered the Rust surface, JS and the bindings, the @@ -167,7 +167,6 @@ stale, including `doc/concept/identity.md`. ## Required -- [Serve a held broadcast](/quest/m1/api-audit/route/serve.md) - a prefix route's request can be answered with a broadcast the app already holds, and the first subscribe succeeds on every wire - [One Route handle](/quest/m1/api-audit/route/handle.md) - `Publication`, `Prepared`, `Announcer` and `Requests` become one `Route` that owns its broadcast, with app options separate from transit facts - [Listing and follow](/quest/m1/api-audit/route/events.md) - apps read a path listing plus `follow`/`request`, and route metadata moves to a relay-level stream diff --git a/quest/m1/api-audit/route/handle.md b/quest/m1/api-audit/route/handle.md index f666d58cf61..8f400b5c6e1 100644 --- a/quest/m1/api-audit/route/handle.md +++ b/quest/m1/api-audit/route/handle.md @@ -62,7 +62,7 @@ JS and the bindings identical. prefix route's `serve`, as today, where a standalone broadcast cannot be announced. - **Prefix routes.** A prefix route yields requests, and each one is - answered by `serve(consumer)` (from [serve](/quest/m1/api-audit/route/serve.md)), + answered by `serve(consumer)`, by `route(options)`, or by `reject`. `route(options)` creates the path's exact `Route`, which inherits the prefix route's instance by default so that the reader continues (see [announce takeover](/quest/m1/announce-takeover.md)). @@ -106,10 +106,6 @@ Run `just check` and `just test interop --all`. Public API: breaking across moq-net, @moq/net, moq-ffi, moq-c and the wrappers. Wire: none. -## Required - -- [Serve a held broadcast](/quest/m1/api-audit/route/serve.md) - the served answer this handle carries over - ## Related - No constructible internal handles - the same JS hygiene rule diff --git a/quest/m1/api-audit/route/serve.md b/quest/m1/api-audit/route/serve.md deleted file mode 100644 index ef485cbefd1..00000000000 --- a/quest/m1/api-audit/route/serve.md +++ /dev/null @@ -1,54 +0,0 @@ -# [M] Serve a held broadcast - -## Goal - -An application answering a prefix route's request can hand over a broadcast -it already holds: `request.serve(consumer)` in Rust and -`request.serve(broadcast)` in JS, mirrored in moq-ffi, moq-c and the -wrappers. The answer is served under the prefix route's own instance and -announces no exact route. A client's first subscribe through it succeeds -over moq-transport-18, moq-transport-22, moq-lite-06 and moq-lite-07-wip. - -Non-goals: the route handle rename ([One Route handle](/quest/m1/api-audit/route/handle.md) -carries `serve` over), and removing the reset for answers that announce a -per-path route ([announce takeover](/quest/m1/announce-takeover.md)). - -## Plan - -Decided 2026-10-30 (maintainer); see the [epic](/quest/m1/api-audit/route/README.md). -This lands first, on today's `origin::Requests`/`Request`, so moq.pro's -sync-ingest mirror (`rs/edge/src/sync/ingest.rs`, which calls -`request.accept`) and the external relay operator have a supported answer -before the larger rework. - -- Make the crate-private `Request::accept` (`rs/moq-net/src/model/origin.rs`) - public as `serve`, for application claims as well as sessions. Replace the - `compile_fail,E0624` doctest with usage docs. In JS, expose `#accept` as - `serve` and drop `hooks.acceptRequest` if nothing else needs it. -- Contract, in rustdoc and `doc/concept/identity.md`: a served answer is - part of the prefix route's stream at that path. Today that means its - instance; after [Instance and epoch](https://github.com/moq-dev/moq/pull/7489), - its instance, which promises one continuous sequence space per path. To - serve different bytes at a path that was already served, start a new - prefix route rather than serving new bytes under the old one. A job that - may restart per path answers with `prepare`/`publish`, and takes the - cold-start reset until [announce takeover](/quest/m1/announce-takeover.md). -- Served-answer cache: an answer that `prepare`/`publish` stored in the - prefix route's served cache must not serve a later request once its - exact route is withdrawn. Check `ServeState`'s cache on withdrawal, fix - it if the answer survives, and test it. -- Tests: turn the reproduction from planning into an integration test in - `rs/moq-net-tests/tests/integration/`. A server origin `requests("")` - linked over `transport::memory`; the handler serves a held broadcast; the - client's first `request` plus `subscribe` reads a frame on every version - above. Keep the prepare/publish case asserting today's reset, so - takeover's change to it is visible. Mirror it in `js/net`. -- `MIGRATE.md` (rs/moq-net, js/net): mention `serve` beside the existing - #6496 entry. It is additive. - -Public API: additive `Request::serve` in Rust, JS and the bindings. Wire: -none. - -## Related - -- [moq-dev/moq#6496](https://github.com/moq-dev/moq/pull/6496) - made `accept` crate-private; this reopens it under a stated contract diff --git a/rs/moq-c/MIGRATE.md b/rs/moq-c/MIGRATE.md index e09b312af74..8fd4a8cf325 100644 --- a/rs/moq-c/MIGRATE.md +++ b/rs/moq-c/MIGRATE.md @@ -128,6 +128,7 @@ Publish a replacement under a new name, and expect a finished track's demand ter `moq_origin_dynamic` takes no route, and `moq_origin_dynamic_update` is gone. `moq_broadcast_request_accept` is replaced by `moq_broadcast_request_prepare`, which returns a prepared answer: fill its broadcast, then `moq_broadcast_prepared_publish` announces it at the exact path under a fresh instance of its own. +To answer with a broadcast you already hold, `moq_broadcast_request_serve(request, consumer)` serves it under the prefix route without announcing an exact route; the consumer stays yours to free. `moq_broadcast_prepared_free` refuses an answer you will not publish. ### `moq_track_info` gains `compress` (#5928) diff --git a/rs/moq-c/src/api.rs b/rs/moq-c/src/api.rs index eefa5157a81..6cdc4aba6c2 100644 --- a/rs/moq-c/src/api.rs +++ b/rs/moq-c/src/api.rs @@ -2085,8 +2085,9 @@ pub extern "C" fn moq_origin_requests_cancel(dynamic: u32) -> i32 { /// The path of a broadcast request delivered to a [moq_origin_requests] callback. /// -/// The destination borrows the request's storage: copy it out before accept, -/// reject, or [moq_broadcast_request_free]. +/// The destination borrows the request's storage: copy it out before +/// [moq_broadcast_request_serve], [moq_broadcast_request_prepare], +/// [moq_broadcast_request_reject], or [moq_broadcast_request_free]. /// /// Returns a zero on success, or a negative code on failure. /// @@ -2101,6 +2102,27 @@ pub unsafe extern "C" fn moq_broadcast_request_path(request: u32, dst: *mut moq_ }) } +/// Serve a held consumer under the prefix route's instance without announcing an exact route. +/// +/// Every answer at this path must continue the same sequences and bytes. Start a new +/// prefix route for different content, or prepare and publish a job with its own instance. +/// Consumes the request handle; the consumer remains owned by the caller. +/// Returns zero on success, or a negative error. +#[unsafe(no_mangle)] +pub extern "C" fn moq_broadcast_request_serve(request: u32, broadcast: u32) -> i32 { + ffi::enter(move || { + let request = ffi::parse_id(request)?; + let broadcast = ffi::parse_id(broadcast)?; + let mut state = State::lock(); + let broadcast = state.consume.broadcast(broadcast)?; + let (request, driver) = state.origin.broadcast_request_take(request)?; + driver.check()?; + request.serve(broadcast); + driver.check()?; + Ok(()) + }) +} + /// Start a broadcast request answer as a new stream under a fresh instance, hidden until /// published. /// diff --git a/rs/moq-c/src/consume.rs b/rs/moq-c/src/consume.rs index 7425bd95484..2d628601c1d 100644 --- a/rs/moq-c/src/consume.rs +++ b/rs/moq-c/src/consume.rs @@ -253,6 +253,15 @@ pub struct Consume { } impl Consume { + /// Borrow held content for an on-demand answer without consuming the caller's handle. + pub fn broadcast(&self, id: Id) -> Result { + let context = self.broadcast.get(id).ok_or(Error::BroadcastNotFound)?; + if let Some(origin) = &context.origin { + origin.driver.check()?; + } + Ok(context.broadcast.clone()) + } + /// Buffer a broadcast the origin handed out, keeping the cursor that named it so a catalog /// rendition referencing a sibling broadcast resolves through the same origin. pub fn start( diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index 4edfd584bbc..8d195c37169 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -3787,6 +3787,39 @@ fn dynamic_serves_a_request_under_a_prefix() { assert_eq!(moq_origin_close(origin), 0); } +#[test] +fn dynamic_serves_a_held_consumer_without_taking_its_handle() { + let origin = id(moq_origin_create()); + let broadcast = publish_broadcast(origin, b"source"); + let held = consume_local(broadcast); + let cb = Callback::new(); + let dynamic = + id(unsafe { moq_origin_requests(origin, b"live".as_ptr().cast(), 4, Some(channel_callback), cb.ptr) }); + let result = Callback::new(); + let _task = id(unsafe { + moq_origin_request( + origin, + b"live/cam".as_ptr().cast(), + 8, + std::ptr::null(), + 0, + Some(channel_callback), + result.ptr, + ) + }); + let request = id(cb.recv()); + assert_eq!(moq_broadcast_request_serve(request, held), 0); + let served = id(result.recv()); + assert!(moq_broadcast_request_serve(request, held) < 0, "request is consumed"); + assert_eq!(moq_consume_close(held), 0, "source handle remains caller-owned"); + result.recv_terminal(); + assert_eq!(moq_consume_close(served), 0); + assert_eq!(moq_origin_requests_cancel(dynamic), 0); + cb.recv_terminal(); + assert_eq!(moq_publish_close(broadcast), 0); + assert_eq!(moq_origin_close(origin), 0); +} + #[test] fn dynamic_refuses_a_missing_callback() { let origin = id(moq_origin_create()); diff --git a/rs/moq-ffi/src/origin.rs b/rs/moq-ffi/src/origin.rs index dd90da689ed..581c4901c82 100644 --- a/rs/moq-ffi/src/origin.rs +++ b/rs/moq-ffi/src/origin.rs @@ -459,7 +459,7 @@ impl MoqOriginConsumer { impl MoqOriginRequests { /// Wait for the next broadcast requested through this handle's prefix. /// - /// Returns a [`MoqBroadcastRequest`]: accept it with a broadcast producer or reject + /// Returns a [`MoqBroadcastRequest`]: serve a held broadcast, prepare a new one, or reject /// it with an application error code. The requesting consumer stays pending until then. pub async fn requested_broadcast(&self) -> Result, MoqError> { // A call after cancel finds the route retracted, rather than racing the cancel. @@ -530,6 +530,19 @@ impl MoqBroadcastRequest { })) } + /// Serve a held broadcast under the prefix route's instance without announcing an exact route. + /// + /// Every answer at this path must continue the same sequences and bytes. Start a new + /// prefix route for different content, or prepare and publish a job with its own instance. + pub fn serve(&self, broadcast: &Arc) -> Result<(), MoqError> { + let _guard = crate::ffi::enter(); + self.driver.check()?; + broadcast.driver.check()?; + self.take()?.serve(&broadcast.inner); + self.driver.check()?; + Ok(()) + } + /// Reject the request with an application error code. pub fn reject(&self, error_code: u16) -> Result<(), MoqError> { let _guard = crate::ffi::enter(); @@ -646,6 +659,24 @@ impl MoqFollowing { mod supervision_tests { use super::*; + #[tokio::test] + async fn serving_held_content_consumes_only_the_request() { + let origin = MoqOriginProducer::new(Default::default()); + let requests = origin.requests("room".into()).unwrap(); + let source = origin.create_broadcast("source".into()).unwrap().broadcast(); + let held = source.consume().unwrap(); + let consumer = origin.consume(); + let (resolved, ()) = tokio::join!(consumer.request("room/camera".into(), None), async { + let request = requests.requested_broadcast().await.unwrap(); + request.serve(&held).unwrap(); + assert!(matches!(request.serve(&held), Err(MoqError::Closed))); + }); + assert!(resolved.is_ok()); + assert!(!held.inner.is_closed(), "serving leaves the caller's consumer usable"); + requests.cancel(); + source.close().unwrap(); + } + #[tokio::test] async fn a_panicked_origin_task_reaches_the_host_while_another_origin_keeps_working() { let (inner, driver, trigger) = crate::ffi::panicking_origin(); diff --git a/rs/moq-net-tests/tests/integration/ietf_conformance.rs b/rs/moq-net-tests/tests/integration/ietf_conformance.rs index 23e1064c41b..336d8d09ca4 100644 --- a/rs/moq-net-tests/tests/integration/ietf_conformance.rs +++ b/rs/moq-net-tests/tests/integration/ietf_conformance.rs @@ -32,7 +32,7 @@ async fn routing(version: &str, cluster: bool) { kio::clock::sim::spawn(async move { let request = serving.requested_broadcast().await.unwrap(); assert_eq!(request.path().as_str(), NAMESPACE); - moq_net::fuzz::accept(request, answer); + request.serve(answer); }); let mut options = MockConnectOptions::new(version); diff --git a/rs/moq-net-tests/tests/integration/main.rs b/rs/moq-net-tests/tests/integration/main.rs index c8a31acfb55..ea8f634857e 100644 --- a/rs/moq-net-tests/tests/integration/main.rs +++ b/rs/moq-net-tests/tests/integration/main.rs @@ -3,6 +3,7 @@ mod ietf_conformance; mod refresh; mod restart; +mod serve; #[path = "../../../moq-net/tests/integration/support/mod.rs"] mod support; diff --git a/rs/moq-net-tests/tests/integration/restart.rs b/rs/moq-net-tests/tests/integration/restart.rs index 5dd592b221e..e28531445b0 100644 --- a/rs/moq-net-tests/tests/integration/restart.rs +++ b/rs/moq-net-tests/tests/integration/restart.rs @@ -196,7 +196,7 @@ impl Worker { let output = broadcast::Info::new().produce(); let track = output.create_track("video", timed()).unwrap(); write(&track, &format!("{hop}")); - moq_net::fuzz::accept(request, &output); + request.serve(&output); served.borrow_mut().push((output, track)); } })); @@ -318,7 +318,7 @@ impl Claim { while let Ok(request) = handler.requested_broadcast().await { let output = broadcast::Info::new().produce(); let track = output.create_track("video", timed()).unwrap(); - moq_net::fuzz::accept(request, &output); + request.serve(&output); served.borrow_mut().push((output, track)); } })); diff --git a/rs/moq-net-tests/tests/integration/serve.rs b/rs/moq-net-tests/tests/integration/serve.rs new file mode 100644 index 00000000000..3783678f6ff --- /dev/null +++ b/rs/moq-net-tests/tests/integration/serve.rs @@ -0,0 +1,92 @@ +//! A held answer belongs to its prefix route; a published job has its own route. + +use std::time::Duration; + +use moq_net::{Hop, Timestamp, Version, broadcast, origin, track}; + +use crate::support::harness::{MockConnectOptions, connect_mock, spawn}; + +fn origin(hop: u64) -> origin::Producer { + let (origin, driver) = origin::Producer::new(origin::Config::new(Hop::new(hop).unwrap())); + spawn(driver); + origin +} + +async fn first_subscribe(version: &str, publish: bool) { + let version: Version = version.parse().unwrap(); + let server = origin(1); + let client = origin(2); + let requests = server.requests("").unwrap(); + let mut options = MockConnectOptions::new(version); + options.server_publish = Some(server.consume()); + options.client_subscribe = Some(client.clone()); + let _pair = connect_mock(options).await; + + let remote = client.consume().request("camera", None).await.unwrap(); + let read = async { + let mut reader = remote.track("video")?.subscribe(None).await?; + let mut group = reader.recv_group().await?.ok_or(moq_net::Error::Unroutable)?; + let frame = group.read_frame().await?.ok_or(moq_net::Error::Unroutable)?; + Ok::<_, moq_net::Error>(frame.payload) + }; + // A held broadcast needs no origin or announcement of its own. + let held = broadcast::Info::new().produce(); + let held_track = held + .create_track( + "video", + track::Info::default().with_timescale(moq_net::Timescale::MILLI), + ) + .unwrap(); + let mut group = held_track.append_group().unwrap(); + group.write_frame(Timestamp::ZERO, b"held".as_slice()).unwrap(); + group.finish().unwrap(); + let handler = async { + if publish { + let prepared = requests.requested_broadcast().await.unwrap().prepare().unwrap(); + let track = prepared + .broadcast() + .create_track( + "video", + track::Info::default().with_timescale(moq_net::Timescale::MILLI), + ) + .unwrap(); + let mut group = track.append_group().unwrap(); + group.write_frame(Timestamp::ZERO, b"held".as_slice()).unwrap(); + group.finish().unwrap(); + Some((prepared.publish().unwrap(), track)) + } else { + requests.requested_broadcast().await.unwrap().serve(&held); + None + } + }; + let (result, _publication) = futures::join!(read, handler); + if publish && version != "moq-lite-07-wip".parse().unwrap() { + assert!( + result.is_err(), + "{version}: publishing an exact route still resets the first subscribe" + ); + } else { + assert_eq!(result.unwrap().as_ref(), b"held", "{version}"); + } +} + +macro_rules! cases { + ($($name:ident: $version:literal, $publish:literal;)*) => {$( + #[kio::test] + async fn $name() { + kio::clock::timeout(Duration::from_secs(10), first_subscribe($version, $publish)) + .await.expect("first subscribe stalled"); + } + )*}; +} + +cases! { + serve_ietf18: "moq-transport-18", false; + serve_ietf22: "moq-transport-22", false; + serve_lite06: "moq-lite-06", false; + serve_lite07: "moq-lite-07-wip", false; + publish_ietf18: "moq-transport-18", true; + publish_ietf22: "moq-transport-22", true; + publish_lite06: "moq-lite-06", true; + publish_lite07: "moq-lite-07-wip", true; +} diff --git a/rs/moq-net/MIGRATE.md b/rs/moq-net/MIGRATE.md index 2c39bcddc6d..47b9bfd5760 100644 --- a/rs/moq-net/MIGRATE.md +++ b/rs/moq-net/MIGRATE.md @@ -308,7 +308,8 @@ Treat a failed group read as the loss of that group and keep reading the track, Answer each `origin::Request` with `request.prepare()?`, fill `prepared.broadcast()`, then `prepared.publish()?`, which announces the broadcast at the exact path under a fresh instance of its own and returns its producer. Only `publish` announces it: `prepared.broadcast().announce(..)` fails with `Error::Closed`. `Dynamic::update` is gone: drop the claim and claim again to change it, and close an answer's producer to end that output. -`Request::accept`, `Producer::dynamic_route`, and `Dynamic::update_route` are crate-private (#6496): only the built-in sessions answer with a broadcast they already hold. +`Producer::requests_route` and `Requests::update_route` remain crate-private (#6496). +`Request::serve(consumer)` additively exposes the former private `accept`: answer with a held broadcast without announcing an exact route. The prefix route promises the same bytes and continuous sequences at each served path; start a new prefix route for different content, or prepare and publish an independent job. Dropping a `Prepared` unpublished refuses the request, as dropping a `Request` does, and `publish` fails with `Error::Unroutable` once the claim went away. ### Anchors can name a time (#6074) diff --git a/rs/moq-net/benches/origin.rs b/rs/moq-net/benches/origin.rs index 0e0b3eb8935..31a74aa5ed5 100644 --- a/rs/moq-net/benches/origin.rs +++ b/rs/moq-net/benches/origin.rs @@ -878,7 +878,7 @@ fn pool(members: usize, paths: usize, cursors: usize) -> Pool { for member in &members { while let Poll::Ready(request) = member.poll_requested_broadcast(&waiter) { let broadcast = broadcast::Info::new().produce(); - moq_net::fuzz::accept(request.unwrap(), &broadcast); + request.unwrap().serve(&broadcast); producers.push(broadcast); } } diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index 3255184b462..fa17b66a6f6 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -432,11 +432,6 @@ pub fn update_route(dynamic: &crate::origin::Requests, route: crate::origin::Rou dynamic.update_route(route) } -/// Answer a peer claim's request with the broadcast its session already holds. -pub fn accept(request: crate::origin::Request, broadcast: impl crate::Consume) { - request.accept(broadcast) -} - /// A session's snapshot of its peer's initial announcements, for the synced bench. /// Drop it to land the snapshot. pub struct Snapshot(#[allow(dead_code, reason = "held for its drop, which lands the snapshot")] crate::model::Snapshot); diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 3e64c4b9473..c773f9fd1c7 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -9682,7 +9682,7 @@ mod serve_tests { auth.handle().authorize(¬hing()); let output = crate::broadcast::Info::new().produce(); let _track = output.create_track("video", None).unwrap(); - request.accept(&output); + request.serve(&output); answer.await; let code = refusal_code(&h.log.writes.lock().unwrap()[mark..], version); diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 190d3e09d9d..761e14b0159 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -2738,7 +2738,7 @@ impl Subscriber { // The handler exists before the requester sees the source, so a track it asks // for before `run_broadcast` first polls queues instead of failing `NotFound`. let dynamic = source.requests(); - request.accept(&*source); + request.serve(&*source); // The namespace's token closes the source as it is retracted. If it was // retracted since the accept, close it here as that retraction would have, diff --git a/rs/moq-net/src/lite/subscriber.rs b/rs/moq-net/src/lite/subscriber.rs index e0533e90132..a4abb854b00 100644 --- a/rs/moq-net/src/lite/subscriber.rs +++ b/rs/moq-net/src/lite/subscriber.rs @@ -7847,7 +7847,7 @@ impl Announced { // `NotFound`. Accepted before the push, so the requester holds the source // before its serve machine can see it unheld. let dynamic = source.requests(); - request.accept(&source); + request.serve(&source); let _ = subscriber.sources.try_push(MintedSource { path, instance: entry.route.instance.clone(), diff --git a/rs/moq-net/src/model/follow.rs b/rs/moq-net/src/model/follow.rs index 249fa5a35d8..65f0f324d90 100644 --- a/rs/moq-net/src/model/follow.rs +++ b/rs/moq-net/src/model/follow.rs @@ -603,7 +603,7 @@ mod tests { exact.unannounce(); let served = broadcast::Info::new().produce(); let (again, ()) = futures::join!(available(&mut announced), async { - requested(&dynamic).await.accept(&served); + requested(&dynamic).await.serve(&served); }); assert!(again.is_clone(&first), "the route above did not carry the instance on"); } diff --git a/rs/moq-net/src/model/origin.rs b/rs/moq-net/src/model/origin.rs index f87ab6dfa06..616e4691a4a 100644 --- a/rs/moq-net/src/model/origin.rs +++ b/rs/moq-net/src/model/origin.rs @@ -5604,7 +5604,7 @@ impl OriginState { /// One-shot result of a dynamic broadcast request. /// -/// Stays `None` until a handler [`accept`](Request::accept)s (yielding the served +/// Stays `None` until a handler [`serve`](Request::serve)s (yielding the served /// broadcast) or [`reject`](Request::reject)s (yielding an error). The producer is /// dropped right after writing, closing the channel; kio checks the value before the closed /// flag, so an awaiting requester still observes the final result. @@ -5875,12 +5875,7 @@ impl ServeState { producer: &kio::Producer, result: Result, ) -> Option> { - if self.closed { - return None; - } - // Released already (the route changed instance): the answer was for the old one, - // so nothing resolves or caches it. - self.requests.remove_if(path, |p| p.same_channel(producer))?; + self.take(path, producer)?; let state = self; let resolved = match result { Ok(broadcast) => { @@ -5906,6 +5901,15 @@ impl ServeState { Some(resolved) } + /// Admit an answer only while its request still belongs to this route instance. + fn take(&mut self, path: &Path, producer: &kio::Producer) -> Option<()> { + if self.closed { + return None; + } + self.requests.remove_if(path, |p| p.same_channel(producer))?; + Some(()) + } + /// Release every request, queued or handed to a handler, and forget the answers served, /// because the route now names another instance. Returns the released /// requests for the caller to refuse once it holds no lock, since the refusal wakes @@ -5929,14 +5933,14 @@ impl ServeState { /// /// Yielded by [`Requests::poll_requested_broadcast`]. The requester is awaiting inside /// [`Consumer::request`]; [`prepare`](Self::prepare) then [`Prepared::publish`] -/// resolves it with a new exact-path broadcast, and [`reject`](Self::reject) resolves it -/// with an error. Dropping the request without either rejects it. +/// resolves it with a new exact-path broadcast, [`serve`](Self::serve) answers with a held +/// broadcast, and [`reject`](Self::reject) resolves it with an error. Dropping it rejects it. /// -/// Only the built-in sessions answer with a broadcast they already hold: +/// Serve a held broadcast without announcing an exact route: /// -/// ```compile_fail,E0624 +/// ``` /// fn answer(request: moq_net::origin::Request, broadcast: moq_net::broadcast::Consumer) { -/// request.accept(broadcast); +/// request.serve(broadcast); /// } /// ``` pub struct Request { @@ -5947,12 +5951,12 @@ pub struct Request { // this wakes them with the outcome. producer: kio::Producer, - // The queue this request came from, so `accept` can cache the served + // The queue this request came from, so `serve` can cache the served // broadcast for repeat requests. home: kio::Shared, - // Applications publish answers into this origin; session-forwarded claims accept - // their peer's already-routed broadcast directly instead. + // Applications can prepare answers in this origin; a session-forwarded request + // can only serve its peer's already-routed broadcast. publisher: Option, } @@ -5973,9 +5977,13 @@ impl Request { }) } - /// Resolve a session-forwarded claim with its peer's already-routed broadcast. - #[cfg(feature = "async")] - pub(crate) fn accept(self, broadcast: impl Consume) { + /// Serve a held broadcast under this prefix route without announcing an exact route. + /// + /// The answer belongs to the prefix route's instance at this path: every answer for + /// that path must continue the same sequence space and bytes. Start a new prefix + /// route to serve different content there. For a job that may restart independently, + /// use [`Self::prepare`] and [`Prepared::publish`] to announce its own instance. + pub fn serve(self, broadcast: impl Consume) { let broadcast = broadcast.consume(); let _ = ServeState::resolve(&self.home, &self.path, &self.producer, Ok(broadcast)); // `self.producer` drops here, closing the channel; the value is still observable. @@ -6024,7 +6032,13 @@ impl Prepared { // and whatever resolved through the claim's current instance beneath it. Answered // and taken over under one lock, so nothing resolves in between. let admitted = broadcast.announce_withheld(announcer, route, Some(&request.home), || { - resolved = request.home.lock().answer(&request.path, &request.producer, Ok(answer)); + // The exact route owns this answer's availability. Caching it under the + // prefix would keep serving it after that route is withdrawn. + resolved = request + .home + .lock() + .take(&request.path, &request.producer) + .map(|()| Ok(answer)); resolved.is_some() })?; let Some(resolved) = resolved.filter(|_| admitted) else { @@ -6044,7 +6058,7 @@ impl Drop for Request { // producer clone (plus this one) closes the channel, resolving coalesced requesters to // `Unroutable` rather than hanging. // - // The identity guard matters: `accept`/`reject` already removed our entry and released + // The identity guard matters: `serve`/`reject` already removed our entry and released // the lock before we run, so a concurrent request for the same path may have registered // a *new* one here. Removing unconditionally would clobber it, stranding its requesters. ServeState::forget(&self.home, &self.path, &self.producer); @@ -8214,7 +8228,7 @@ mod tests { assert_eq!(request.path().as_str(), ".svc/p1/foo"); assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let through = through.await.expect("resolves"); let direct = direct.await.expect("resolves"); @@ -8830,7 +8844,7 @@ mod tests { let pending = consumer.request("pool/job-0", None); let request = queued(&old).await; let first = broadcast::Info::new().produce(); - request.accept(&first); + request.serve(&first); let resolved = pending.await.expect("the old route resolves"); assert!(new.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); @@ -8840,7 +8854,7 @@ mod tests { let pending = consumer.request("pool/job-0", None); let request = queued(&new).await; let second = broadcast::Info::new().produce(); - request.accept(&second); + request.serve(&second); let replaced = pending.await.expect("the replacement resolves"); assert!(!replaced.is_clone(&resolved)); } @@ -8873,7 +8887,7 @@ mod tests { ); let pending = consumer.request("pool/job-0", None); - queued(&new).await.accept(broadcast::Info::new().produce()); + queued(&new).await.serve(broadcast::Info::new().produce()); pending.await.expect("the replacement resolves"); } } @@ -8904,7 +8918,7 @@ mod tests { async fn hold(consumer: &Consumer, path: &str, server: &Requests) -> (broadcast::Producer, broadcast::Consumer) { let pending = consumer.request(path, None); let answer = broadcast::Info::new().produce(); - queued(server).await.accept(&answer); + queued(server).await.serve(&answer); (answer, pending.await.expect("the request resolves")) } @@ -9252,7 +9266,7 @@ mod tests { let pending = consumer.request("room/alice", None); let request = queued(&server).await; let upstream = broadcast::Info::new().produce(); - request.accept(&upstream); + request.serve(&upstream); pending.await.expect("resolves through the cheaper route"); } @@ -9302,7 +9316,7 @@ mod tests { .unwrap(); let request = queued(&server).await; let upstream = broadcast::Info::new().produce(); - request.accept(&upstream); + request.serve(&upstream); let second = consumer.request("room/alice", None).await.expect("resolves"); assert!(first.is_clone(&second), "the newcomer joins the front"); @@ -9424,7 +9438,7 @@ mod tests { let upstream = broadcast::Info::new().produce(); let _b = upstream.create_track("b", None).unwrap(); let _c = upstream.create_track("c", None).unwrap(); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); assert_eq!(listed(&mut tracks).await, "+c"); assert_eq!(listed(&mut tracks).await, "-a"); @@ -9443,7 +9457,7 @@ mod tests { let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let _a = upstream.create_track("a", None).unwrap(); - queued(&first).await.accept(&upstream); + queued(&first).await.serve(&upstream); let front = pending.await.unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+a"); @@ -9461,7 +9475,7 @@ mod tests { kio::clock::timeout(Duration::from_secs(1), queued(&second)) .await .expect("the front asked the successor") - .accept(&successor); + .serve(&successor); assert_eq!(listed(&mut tracks).await, "+b"); assert!(!front.is_closed()); } @@ -9493,7 +9507,7 @@ mod tests { let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let _a = upstream.create_track("a", None).unwrap(); - queued(&first).await.accept(&upstream); + queued(&first).await.serve(&upstream); let front = pending.await.unwrap(); let mut tracks = front.tracks().unwrap(); assert_eq!(listed(&mut tracks).await, "+a"); @@ -9512,7 +9526,7 @@ mod tests { kio::clock::timeout(Duration::from_secs(1), queued(&last)) .await .expect("the front asked the chain's last route") - .accept(&successor); + .serve(&successor); assert_eq!(listed(&mut tracks).await, "+b", "{links} links, named: {named}"); assert!(!front.is_closed()); // The front carries the last instance, so a request now joins it. @@ -9535,7 +9549,7 @@ mod tests { let first = producer.requests_route("room/alice", route(0), None).unwrap(); let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); - queued(&first).await.accept(&upstream); + queued(&first).await.serve(&upstream); let resolved = pending.await.unwrap(); // Taken over, then renewed, with no yield between. @@ -9548,7 +9562,7 @@ mod tests { kio::clock::timeout(Duration::from_secs(1), queued(&second)) .await .expect("a fresh front asked the renewed route") - .accept(&renewed); + .serve(&renewed); let again = pending.await.unwrap(); assert_eq!(again.info().instance, route(2).instance); assert!( @@ -9568,7 +9582,7 @@ mod tests { let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let _video = upstream.create_track("video", None).unwrap(); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let front = pending.await.unwrap(); let mut tracks = front.tracks().unwrap(); @@ -9768,7 +9782,7 @@ mod tests { let pending = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); let dynamic = upstream.requests(); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let resolved = pending.await.expect("resolves"); (server, upstream, dynamic, resolved) } @@ -9869,7 +9883,7 @@ mod tests { let session = producer.consume().excluding(Hop::random()); let pending = session.request("room/alice", None); if viewer == 0 { - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); } let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -9932,7 +9946,7 @@ mod tests { let fronts = || producer.shared.lock().fronts.len(); let pending = consumer.request("room/alice", None); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); next_group(&mut subscription).await.unwrap().expect("the live group"); @@ -9991,7 +10005,7 @@ mod tests { let fronts = || producer.shared.lock().fronts.len(); let pending = consumer.request("room/alice", None); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let resolved = pending.await.expect("resolves"); let reader = resolved.track("video").unwrap().subscribe(None); settle(|| source.demand().is_wanted()).await; @@ -10067,7 +10081,7 @@ mod tests { let fronts = || producer.shared.lock().fronts.len(); let pending = producer.consume().request("room/alice", None); - queued(&server).await.accept(&upstream); + queued(&server).await.serve(&upstream); let _viewer = pending.await.expect("the plain front resolves"); let peer = producer.consume().excluding(origin(7)); @@ -10104,7 +10118,7 @@ mod tests { let pending = peer.request("room/alice", None); let source = broadcast::Info::new().produce(); - queued(&incumbent).await.accept(&source); + queued(&incumbent).await.serve(&source); let resolved = pending.await.expect("resolves through the incumbent"); // The same publisher, now also reached through the peer, outlives the incumbent. @@ -10119,7 +10133,7 @@ mod tests { drop(source); let replacement = broadcast::Info::new().produce(); - queued(&echo).await.accept(&replacement); + queued(&echo).await.serve(&replacement); resolved.assert_not_closed(); view.expect_next_ended("room").await; } @@ -10154,7 +10168,7 @@ mod tests { let pending = producer.consume().request("room/alice", None); let upstream = broadcast::Info::new().produce(); let mut dynamic = upstream.requests(); - queued(&first_server).await.accept(&upstream); + queued(&first_server).await.serve(&upstream); let resolved = pending.await.unwrap(); #[cfg(feature = "async")] @@ -10212,7 +10226,7 @@ mod tests { .unwrap(); let replacement = broadcast::Info::new().produce(); let mut replacement_dynamic = replacement.requests(); - queued(&replacement_server).await.accept(&replacement); + queued(&replacement_server).await.serve(&replacement); let request = kio::clock::timeout(Duration::from_secs(1), replacement_dynamic.requested_track()) .await .expect("the front asked the replacement") @@ -10710,14 +10724,14 @@ mod tests { let producer = origin(1).produce(); let consumer = producer.consume(); - let server = producer.requests_route("room", Route::default(), None).unwrap(); + let server = producer.requests("room").unwrap(); let pending = consumer.request("room/alice", None); let request = queued(&server).await; assert_eq!(request.path().as_str(), "room/alice"); let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("resolves"); // The handle is named by what the requester asked for. @@ -10743,7 +10757,7 @@ mod tests { assert!(server.poll_requested_broadcast(&kio::Waiter::noop()).is_pending()); let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let first = first.await.expect("resolves"); let second = second.await.expect("resolves"); @@ -10801,7 +10815,7 @@ mod tests { let request = queued(&standby_server).await; let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let resolved = resolving.await.expect("resolves via the standby"); assert_eq!(resolved.info().path.as_str(), "room/alice"); @@ -11333,7 +11347,7 @@ mod tests { let request = queued(&server).await; assert_eq!(request.path().as_str(), "room/bob"); let served = broadcast::Info::new().produce(); - request.accept(&served); + request.serve(&served); pending.await.expect("resolves"); } @@ -11508,6 +11522,29 @@ mod tests { announced.assert_next_wait(); } + /// A published job must stop answering through its claim when its exact route leaves, + /// even while its fill handle and readers keep the broadcast alive. + #[kio::test] + #[cfg(feature = "async")] + async fn a_withdrawn_publication_is_not_a_cached_claim_answer() { + let producer = origin(1).produce(); + let claim = producer.requests("room").unwrap(); + let path = Path::from_static("room/alice"); + let pending = producer.consume().request(path.clone(), None); + let publication = queued(&claim).await.prepare().unwrap().publish().unwrap(); + let held = pending.await.unwrap(); + publication.unannounce(); + assert!( + claim.state.lock().served.get(&path).is_none(), + "withdrawn job still cached" + ); + let next = producer.consume().request(path, None); + let request = queued(&claim).await; + request.reject(Error::App(42)); + assert!(next.await.is_err()); + drop(held); + } + /// A takeover withdrawn before the cursor delivers it may have continued what its /// reader resolved through the claim, so the claim continues nothing more for that /// reader: the next answer is a start. @@ -11640,7 +11677,7 @@ mod tests { let winner = producer.requests_route("room/alice", Route::default(), None).unwrap(); request.reject(Error::NotFound); let source = broadcast::Info::new().produce(); - queued(&winner).await.accept(&source); + queued(&winner).await.serve(&source); let mut result = None; settle(|| { @@ -11694,7 +11731,7 @@ mod tests { } let pending = consumer.request("room/alice", None); - queued(&server).await.accept(&source); + queued(&server).await.serve(&source); let resolved = pending.await.expect("resolves"); let budget = @@ -11756,7 +11793,7 @@ mod tests { assert_eq!(request.path().as_str(), "anything/at/all"); let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("resolves"); assert_eq!(resolved.info().path.as_str(), "anything/at/all"); @@ -12017,7 +12054,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("resolves"); let mut subscription = resolved @@ -12073,7 +12110,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&replacement); + request.serve(&replacement); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"resumed".as_ref()).unwrap(); @@ -12141,14 +12178,14 @@ mod tests { let mut follow = consumer.follow("pool/job-0", None).unwrap(); let (first, ()) = futures::join!(follow.available(), async { - queued(&a).await.accept(broadcast::Info::new().produce()); + queued(&a).await.serve(broadcast::Info::new().produce()); }); let first = first.unwrap(); assert_eq!(first.info().instance, Some("a".parse().unwrap())); drop(a); let (second, ()) = futures::join!(follow.available(), async { - queued(&b).await.accept(broadcast::Info::new().produce()); + queued(&b).await.serve(broadcast::Info::new().produce()); }); let second = second.unwrap(); assert_eq!(second.info().instance, Some("b".parse().unwrap())); @@ -12180,7 +12217,7 @@ mod tests { let mut follow = consumer.follow("pool/job-0", None).unwrap(); let (first, ()) = futures::join!(follow.available(), async { - queued(&a).await.accept(broadcast::Info::new().produce()); + queued(&a).await.serve(broadcast::Info::new().produce()); }); let first = first.unwrap(); let weak = first.weak(); @@ -12202,7 +12239,7 @@ mod tests { drop(a); let (second, ()) = futures::join!(follow.available(), async { - queued(&b).await.accept(broadcast::Info::new().produce()); + queued(&b).await.serve(broadcast::Info::new().produce()); }); assert_eq!(second.unwrap().info().instance, Some("b".parse().unwrap())); } @@ -12230,7 +12267,7 @@ mod tests { let pending = consumer.request("room/alice", None); let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&first).await.accept(&source); + queued(&first).await.serve(&source); let resolved = pending.await.expect("resolves"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); deliver(&track, &mut subscription, b"first").await; @@ -12373,7 +12410,7 @@ mod tests { let new_track = new.create_track("video", crate::track::Info::timed()).unwrap(); let stale = broadcast::Info::new().produce(); let _stale_track = stale.create_track("video", crate::track::Info::timed()).unwrap(); - request.accept(&stale); + request.serve(&stale); let resolved = pending.await.expect("resolves the winner"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -12401,7 +12438,7 @@ mod tests { let _stale_track = stale.create_track("video", crate::track::Info::timed()).unwrap(); let instance = crate::Instance::random(); if answer_first { - request.accept(&stale); + request.serve(&stale); dynamic .update_route(dynamic.route().with_instance(instance.clone(), 0)) .unwrap(); @@ -12409,13 +12446,13 @@ mod tests { dynamic .update_route(dynamic.route().with_instance(instance.clone(), 0)) .unwrap(); - request.accept(&stale); + request.serve(&stale); } let request = queued(&dynamic).await; let fresh = broadcast::Info::new().produce(); let fresh_track = fresh.create_track("video", crate::track::Info::timed()).unwrap(); - request.accept(&fresh); + request.serve(&fresh); let resolved = pending.await.expect("the request carries over to the new instance"); assert_eq!(resolved.info().instance.as_ref(), Some(&instance)); assert!( @@ -12466,7 +12503,7 @@ mod tests { let fresh = broadcast::Info::new().produce(); let fresh_track = fresh.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&dynamic).await.accept(&fresh); + queued(&dynamic).await.serve(&fresh); let resolved = pending.await.expect("the request carries over"); assert_eq!(resolved.info().instance.as_ref(), Some(&instance)); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -12495,11 +12532,11 @@ mod tests { .unwrap(); let stale = broadcast::Info::new().produce(); let _stale_track = stale.create_track("video", crate::track::Info::timed()).unwrap(); - request.accept(&stale); + request.serve(&stale); let fresh = broadcast::Info::new().produce(); let fresh_track = fresh.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&dynamic).await.accept(&fresh); + queued(&dynamic).await.serve(&fresh); let resolved = pending.await.expect("the request carries over"); assert_eq!(resolved.info().instance.as_ref(), Some(&old)); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -12600,7 +12637,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&successor); + request.serve(&successor); rig.incumbent_track.clone().abort(Error::Dropped).unwrap(); assert!( @@ -12656,7 +12693,7 @@ mod tests { rig.incumbent_track.clone().abort(Error::Dropped).unwrap(); let replacement = broadcast::Info::new().produce(); let mut handler = replacement.requests(); - queued(&standby).await.accept(&replacement); + queued(&standby).await.serve(&replacement); let request = handler.requested_track().await.unwrap(); assert_eq!(request.subscription().unwrap().start(), Some(5)); let track = request.accept(crate::track::Info::timed()); @@ -12731,7 +12768,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("resolves through the incumbent"); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -12759,7 +12796,7 @@ mod tests { let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"before".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&replacement); + request.serve(&replacement); let mut group = track.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"resumed".as_ref()).unwrap(); group.finish().unwrap(); @@ -12797,7 +12834,7 @@ mod tests { let mut group = track_a.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"from-a".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&source_a); + request.serve(&source_a); let resolved_a = pending.await.expect("resolves"); let mut sub_a = resolved_a @@ -12849,7 +12886,7 @@ mod tests { let mut group = track_b.append_group().unwrap(); group.write_frame(crate::Timestamp::ZERO, b"from-b".as_ref()).unwrap(); group.finish().unwrap(); - request.accept(&source_b); + request.serve(&source_b); let resolved_b = pending.await.expect("B's front is served immediately"); assert!( @@ -13001,7 +13038,7 @@ mod tests { let again = consumer.request("room/alice", None); let upstream = broadcast::Info::new().produce(); - request.accept(&upstream); + request.serve(&upstream); let first = pending.await.expect("resolves"); let again = again.await.expect("resolves"); assert!( @@ -13073,7 +13110,7 @@ mod tests { let request = queued(&server).await; let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("resolves"); let mut subscription = resolved @@ -13118,7 +13155,7 @@ mod tests { .unwrap(); let pending = producer.consume().request("room/alice", None); let source = broadcast::Info::new().produce(); - queued(&server).await.accept(&source); + queued(&server).await.serve(&source); let resolved = pending.await.unwrap(); source.close(); @@ -13208,7 +13245,7 @@ mod tests { let pending = producer.consume().request("live", None); let source = broadcast::Info::new().produce(); let track = source.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&server).await.accept(&source); + queued(&server).await.serve(&source); let resolved = pending.await.unwrap(); let mut subscription = resolved.track("video").unwrap().subscribe(None).await.unwrap(); @@ -13292,7 +13329,7 @@ mod tests { .requests_route("room", Route::default().with_hops(hops(&[10])), None) .unwrap(); let mid_pending = mid.consume().request("room/alice", None); - queued(&mid_server).await.accept(&leaf_front); + queued(&mid_server).await.serve(&leaf_front); let mid_resolved = mid_pending.await.expect("mid resolves"); let edge = origin(3).produce(); @@ -13300,7 +13337,7 @@ mod tests { .requests_route("room", Route::default().with_hops(hops(&[20])), None) .unwrap(); let edge_pending = edge.consume().request("room/alice", None); - queued(&edge_server).await.accept(&mid_resolved); + queued(&edge_server).await.serve(&mid_resolved); let edge_resolved = edge_pending.await.expect("edge resolves"); let mut subscription = edge_resolved @@ -13438,7 +13475,7 @@ mod tests { let pending = producer.consume().request("room/alice", None); let upstream = broadcast::Info::new().produce(); let old = upstream.create_track("video", crate::track::Info::timed()).unwrap(); - queued(&server).await.accept(&upstream); + 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_group().unwrap(); @@ -13856,7 +13893,7 @@ mod tests { let pending = consumer.request("room/alice", None); let request = queued(&server).await; let source = broadcast::Info::new().produce(); - request.accept(&source); + request.serve(&source); let resolved = pending.await.expect("the dynamic still serves"); drop(resolved); @@ -14391,7 +14428,7 @@ mod tests { let source = producer.requests("project/room").unwrap(); let pending = consumer.request("room/lobby.chat", None); let request = source.requested_broadcast().await.unwrap(); - request.accept(local.consume()); + request.serve(local.consume()); pending.await.unwrap(); } diff --git a/rs/moq-net/src/model/resume_model.rs b/rs/moq-net/src/model/resume_model.rs index 1f2f2128155..8ba675d9c37 100644 --- a/rs/moq-net/src/model/resume_model.rs +++ b/rs/moq-net/src/model/resume_model.rs @@ -459,7 +459,7 @@ impl Model { let upstream = broadcast.consume(); let serving = kio::clock::sim::spawn(async move { while let Ok(request) = kio::wait(|waiter| requests.poll_requested_broadcast(waiter)).await { - request.accept(&upstream); + request.serve(&upstream); } }); self.instances[instance].routes[slot] = Some(Copy { diff --git a/swift/MIGRATE.md b/swift/MIGRATE.md index cc7bd5e5c43..fe4b1f3b4b2 100644 --- a/swift/MIGRATE.md +++ b/swift/MIGRATE.md @@ -129,6 +129,7 @@ Publish a replacement under a new name, and expect a finished track's demand wat `OriginProducer.dynamic(prefix:)` takes no route, and `OriginDynamic.update(route:)` is gone. Replace `request.accept(broadcast:)` with `let prepared = try request.prepare()`, fill `prepared.broadcast`, then `try prepared.publish()`, which announces it at the exact path under a fresh instance of its own and returns its producer. +To answer with a broadcast you already hold, `try request.serve(broadcast: producer.consume())` serves it under the prefix route without announcing an exact route. ### Anchors can name a time (#6074) diff --git a/swift/Sources/Moq/Origin.swift b/swift/Sources/Moq/Origin.swift index 6d5fec99b8f..caed7e9a67b 100644 --- a/swift/Sources/Moq/Origin.swift +++ b/swift/Sources/Moq/Origin.swift @@ -59,6 +59,11 @@ public final class BroadcastRequest: Sendable { BroadcastPrepared(try ffi.prepare()) } + /// Serve held content under the prefix route's continuous sequence space, without an exact route. + public func serve(broadcast: BroadcastConsumer) throws { + try ffi.serve(broadcast: broadcast.ffi) + } + /// Reject the request with an application error code. public func reject(errorCode: UInt16) throws { try ffi.reject(errorCode: errorCode)