From 2cd8dd6f5e82296aa4fa054df31ac32f28dbc554 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 22 Oct 2026 09:24:24 -0700 Subject: [PATCH] fix(net): release losing subscription signal waits Co-Authored-By: GPT-6 --- js/net/src/lite/subscriber.test.ts | 83 +++++++++++++++++++++++++++++- js/net/src/lite/subscriber.ts | 9 +--- 2 files changed, 84 insertions(+), 8 deletions(-) diff --git a/js/net/src/lite/subscriber.test.ts b/js/net/src/lite/subscriber.test.ts index a5739bdc165..c1e371da0e8 100644 --- a/js/net/src/lite/subscriber.test.ts +++ b/js/net/src/lite/subscriber.test.ts @@ -1,6 +1,6 @@ import { expect, jest, spyOn, test } from "bun:test"; import { Manual, Milli, Nano } from "@moq/clock"; -import { Signal } from "@moq/signals"; +import { type Getter, Signal } from "@moq/signals"; import type { Grant } from "../auth.ts"; import type { AuthSession } from "../auth_session.ts"; import type { Probe as ProbeStats } from "../connection/stats.ts"; @@ -16,8 +16,10 @@ import { TimestampMismatch, } from "../error.ts"; import { HopSchema, isAnonymous, MAX_HOPS, Route, UNKNOWN_HOP } from "../hop.ts"; +import { hooks } from "../internal.ts"; import * as Path from "../path.ts"; import { Reader, Writer } from "../stream.ts"; +import type { Producer } from "../track.ts"; import { type AnnounceBroadcast, AnnounceInit, AnnounceOk, encodeAnnounceBroadcast } from "./announce.ts"; import { Group } from "./group.ts"; import { Probe } from "./probe.ts"; @@ -1804,6 +1806,85 @@ test("a local unsubscribe owes no SUBSCRIBE_END", async () => { } }); +// Count the actual source registrations, including promises whose losing race cannot cancel them. +function countChanges(source: Getter) { + const changed = source.changed.bind(source); + let listeners = 0; + const register = (fn: (value: unknown) => void) => { + listeners++; + let live = true; + const release = () => { + if (!live) return; + live = false; + listeners--; + }; + const dispose = changed((value) => { + release(); + fn(value); + }); + return () => { + release(); + dispose(); + }; + }; + const spy = spyOn(source, "changed").mockImplementation(((fn?: (value: unknown) => void) => { + return fn ? register(fn) : new Promise(register); + }) as typeof source.changed); + return { count: () => listeners, restore: () => spy.mockRestore() }; +} + +test.each( + [Version.DRAFT_05, Version.DRAFT_06, Version.DRAFT_07].flatMap((version) => + ["unsubscribe", "reset", "session"].map((stop) => [version, stop] as const), + ), +)("subscription waits release losing signal listeners on %s after %s", async (version, stop) => { + const { quic, streams, opened } = fakeSession(); + const subscriber = new Subscriber(quic, version, HopSchema.parse(1n)); + const counters: ReturnType[] = []; + // Observe the accepted producer before its update loop starts, without exporting a test hook. + const internal = subscriber as unknown as { + runResponses: (stream: unknown, entry: { track: Producer }) => Promise; + }; + const runResponses = internal.runResponses.bind(internal); + const responses = spyOn(internal, "runResponses").mockImplementation((stream, entry) => { + counters.push( + ...[entry.track.subscription, entry.track.demand().wanted, hooks.producerLargest(entry.track)].map( + countChanges, + ), + ); + return runResponses(stream, entry); + }); + const broadcast = subscriber.consume(Path.from("room")); + const track = broadcast.track("video").subscribe(); + try { + await opened(0); + await answerTrackInfo(streams[0], version); + await (await opened(1)).reading; + await drainReactions(); + const before = counters.map((counter) => counter.count()); + expect(before).toHaveLength(3); + expect(before.every((count) => count > 0)).toBe(true); + for (let sequence = 0; sequence < 50; sequence++) { + await subscriber.runGroup(new Group({ subscribe: 0n, sequence }), await groupStream(sequence, version)); + await drainReactions(); + } + // Quiet subscription and demand signals must not retain a listener per received group. + expect(counters.map((counter) => counter.count())).toEqual(before); + if (stop === "unsubscribe") track.close(); + else if (stop === "reset") streams[1].inbound.error(new Error("peer reset")); + else subscriber.close(); + await drainReactions(); + expect(counters.map((counter) => counter.count())).toEqual([0, 0, 0]); + } finally { + track.close(); + broadcast.close(); + subscriber.close(); + await drainReactions(); + responses.mockRestore(); + for (const counter of counters) counter.restore(); + } +}); + // A group stream carrying one frame at `timestamp` (zigzag delta from 0) in the track's scale. async function groupStream(timestamp: number, version: Version = Version.DRAFT_07): Promise { const chunks: Uint8Array[] = []; diff --git a/js/net/src/lite/subscriber.ts b/js/net/src/lite/subscriber.ts index cdffbf67c95..2f280331e2b 100644 --- a/js/net/src/lite/subscriber.ts +++ b/js/net/src/lite/subscriber.ts @@ -1511,13 +1511,8 @@ export class Subscriber { : undefined; const current = track.subscription.peek(); if (current === undefined || (refresh === undefined && this.#sameSubscription(current, lastSent))) { - // Nothing new to send; wait for a change or termination. - const next = await race([ - track.subscription.changed(), - demand.wanted.changed(), - edge.changed(), - stopped, - ]); + // Each wake releases the quiet signals too, including when termination wins. + const next = await race([Signal.race(track.subscription, demand.wanted, edge), stopped]); if (next === null) return; continue; }