Skip to content

Commit 89f9a8e

Browse files
author
Carl
committed
fix(presence): pace busy flights and prioritize late viewer demand
Signed-off-by: Carl <32a2e2c9d428ee08902cab75d956da2c1d235a22d4766b0dd4138bf6e2e5db1d@buzz.block.builderlab.xyz>
1 parent ddbdf93 commit 89f9a8e

5 files changed

Lines changed: 297 additions & 67 deletions

File tree

‎dev/relay-broker-live.test.mjs‎

Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -143,6 +143,74 @@ async function until(check) {
143143
throw new Error("Local HTTP fixture did not reach expected state");
144144
}
145145

146+
test("presence busy skips cross the real broker as null while cooldown keeps its deadline", async () => {
147+
const h = await harness();
148+
const nativeFetch = globalThis.fetch;
149+
const outcomes = [];
150+
let traffic;
151+
let clock = 0; // Integer milliseconds keep ceil-based admission deadlines exact.
152+
try {
153+
vi.spyOn(performance, "now").mockImplementation(() => clock);
154+
vi.stubGlobal("fetch", async (input, init) => {
155+
const response = await nativeFetch(input, {
156+
...init,
157+
headers: {
158+
...init?.headers,
159+
...(init?.method === "POST" ? { Origin: h.base } : {}),
160+
},
161+
});
162+
if (String(input).endsWith("/stream-presence"))
163+
outcomes.push(await response.clone().json());
164+
return response;
165+
});
166+
const transport = await connectBrokerTransport(h.base);
167+
let snapshot;
168+
traffic = transport.subscribe({
169+
receive() {},
170+
established() {},
171+
denied() {},
172+
state(value) {
173+
snapshot = value;
174+
},
175+
});
176+
await until(() => snapshot?.status === "connected");
177+
const first = traffic.publishPresence(
178+
"online",
179+
new AbortController().signal,
180+
);
181+
await until(() => h.publications.length === 1);
182+
clock += 5100; // Gate elapsed; real receipt timer remains held.
183+
expect(
184+
await traffic.publishPresence("away", new AbortController().signal),
185+
).toBeNull();
186+
expect(outcomes).toEqual([{ accepted: null }]);
187+
expect(h.publications).toHaveLength(1);
188+
const { event, socket } = h.publications[0];
189+
await socket.receive([
190+
"OK",
191+
event.id,
192+
false,
193+
"rate-limited: quota exceeded; retry in 3s",
194+
]);
195+
expect(await first).toBe(false);
196+
expect(
197+
await traffic.publishPresence("away", new AbortController().signal),
198+
).toEqual({ retryAfterMs: 4000 });
199+
expect(outcomes.at(-1)).toEqual({ accepted: null, retryAfterMs: 4000 });
200+
clock += 4000;
201+
const next = traffic.publishPresence("away", new AbortController().signal);
202+
await until(() => h.publications.length === 2);
203+
expect(h.publications[1].event.content).toBe("away");
204+
await socket.receive(["OK", h.publications[1].event.id, true, ""]);
205+
expect(await next).toBe(true);
206+
} finally {
207+
traffic?.dispose();
208+
vi.restoreAllMocks();
209+
vi.unstubAllGlobals();
210+
await h.close();
211+
}
212+
});
213+
146214
test("POST replacement and a second stream share server cooldown without pacing healthy starts; response close disposes WS", async () => {
147215
const h = await harness(1);
148216
try {

‎src/features/presence/presence.test.ts‎

Lines changed: 28 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -550,16 +550,34 @@ it("live evidence fences held snapshots and invalidation retires observation", a
550550
owner.dispose();
551551
});
552552

553-
it("always keeps the demanded viewer within the 256 subject cap", async () => {
554-
const h = setup();
555-
for (let i = 3; i < 263; i++) h.owner.subscribe(key(i), () => {}, true);
556-
h.owner.subscribe(h.transport.viewer, () => {}, true);
557-
await vi.advanceTimersByTimeAsync(100);
558-
expect(h.read.mock.calls[0]?.[0]).toHaveLength(256);
559-
expect(h.read.mock.calls[0]?.[0]).toContain(h.transport.viewer);
560-
expect(h.owner.limited(h.transport.viewer)).toBe(false);
561-
h.owner.dispose();
562-
});
553+
it.each([undefined, true])(
554+
"keeps late viewer demand within the 256 subject cap (profile: %s)",
555+
async (profile) => {
556+
const h = setup();
557+
try {
558+
for (let i = 3; i < 259; i++) h.owner.subscribe(key(i), () => {}, true);
559+
await vi.advanceTimersByTimeAsync(100);
560+
expect(h.owner.status(key(258))).toBe("online");
561+
const displaced = vi.fn();
562+
h.owner.subscribe(key(258), displaced, true);
563+
h.owner.subscribe(h.transport.viewer, () => {}, profile);
564+
expect(h.owner.limited(h.transport.viewer)).toBe(false);
565+
expect(h.owner.limited(key(258))).toBe(true);
566+
expect(h.owner.status(key(258))).toBe("unknown");
567+
expect(displaced).toHaveBeenCalled();
568+
await vi.advanceTimersByTimeAsync(5000);
569+
expect(h.read).toHaveBeenCalledTimes(2);
570+
const authors = h.read.mock.lastCall?.[0];
571+
expect(authors).toHaveLength(256);
572+
expect(new Set(authors).size).toBe(256);
573+
expect(authors).toContain(h.transport.viewer);
574+
expect(authors).not.toContain(key(258));
575+
expect(h.owner.status(h.transport.viewer)).toBe("online");
576+
} finally {
577+
h.owner.dispose();
578+
}
579+
},
580+
);
563581

564582
it("starts commands without jitter and retries at the real gate, including same-value commands", async () => {
565583
const h = setup();

‎src/features/presence/presence.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -334,7 +334,8 @@ export function createPresence(
334334
if (subject.profiles) profiles.set(key, subject);
335335
else profiles.delete(key);
336336
if (
337-
(!selected.has(key) && selected.size < 256) ||
337+
(!selected.has(key) &&
338+
(selected.size < 256 || key === transport?.viewer)) ||
338339
priority !== subject.profiles > 0
339340
)
340341
demand();

‎src/features/relay/live.test.ts‎

Lines changed: 193 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@ import {
88
} from "./live";
99
import { keypair, message, roster, signed, scriptedTransport } from "./testing";
1010
import { createRelaySession } from "./session";
11+
import { createPresence } from "../presence/presence";
1112
type WireFilter = {
1213
kinds: number[];
1314
"#h"?: string[];
@@ -1438,56 +1439,77 @@ it("presence holds its receipt without delaying ordinary setup and shares correl
14381439
h.owner.dispose();
14391440
});
14401441

1441-
it("an outstanding presence signer pins its principal flight across socket replacement", async () => {
1442-
vi.useFakeTimers();
1443-
const key = keypair(),
1444-
sockets: Socket[] = [];
1445-
const admission = createLiveAdmission();
1446-
let release!: () => void;
1447-
const gate = new Promise<void>((resolve) => {
1448-
release = resolve;
1449-
});
1450-
const callbacks = { receive() {}, state() {}, established() {}, denied() {} };
1451-
const owner = subscribeRelayTraffic(
1452-
"wss://relay.test",
1453-
async (event) => {
1454-
if (event.kind === 20001) await gate;
1455-
return signed(key, event);
1456-
},
1457-
key.pubkey,
1458-
callbacks,
1459-
() => {
1460-
const s = new Socket();
1461-
sockets.push(s);
1462-
return s as unknown as WebSocket;
1463-
},
1464-
admission,
1465-
);
1466-
const first = sockets[0];
1467-
assert.exists(first);
1468-
await first.auth();
1469-
await vi.advanceTimersByTimeAsync(500);
1470-
for (const [, id] of first.requests()) await first.receive(["EOSE", id]);
1471-
const result = owner.publishPresence?.("away", new AbortController().signal);
1472-
expect(admission.presenceIdle()).toBe(false);
1473-
first.close();
1474-
await vi.advanceTimersByTimeAsync(500);
1475-
const next = sockets[1];
1476-
assert.exists(next);
1477-
await next.auth();
1478-
await vi.advanceTimersByTimeAsync(500);
1479-
for (const [, id] of next.requests()) await next.receive(["EOSE", id]);
1480-
expect(
1481-
await owner.publishPresence?.("online", new AbortController().signal),
1482-
).toEqual({ retryAfterMs: 250 });
1483-
release();
1484-
expect(await result).toBeNull();
1485-
expect(
1486-
sockets.flatMap((s) => s.sent).filter(([kind]) => kind === "EVENT"),
1487-
).toEqual([]);
1488-
expect(admission.presenceIdle()).toBe(true);
1489-
owner.dispose();
1490-
});
1442+
it.each(["reconnect", "cooldown"])(
1443+
"an outstanding presence signer respects %s",
1444+
async (mode) => {
1445+
vi.useFakeTimers();
1446+
const key = keypair(),
1447+
sockets: Socket[] = [];
1448+
const admission = createLiveAdmission();
1449+
let release!: () => void;
1450+
const gate = new Promise<void>((resolve) => {
1451+
release = resolve;
1452+
});
1453+
const callbacks = {
1454+
receive() {},
1455+
state() {},
1456+
established() {},
1457+
denied() {},
1458+
};
1459+
const owner = subscribeRelayTraffic(
1460+
"wss://relay.test",
1461+
async (event) => {
1462+
if (event.kind === 20001) await gate;
1463+
return signed(key, event);
1464+
},
1465+
key.pubkey,
1466+
callbacks,
1467+
() => {
1468+
const s = new Socket();
1469+
sockets.push(s);
1470+
return s as unknown as WebSocket;
1471+
},
1472+
admission,
1473+
);
1474+
const first = sockets[0];
1475+
assert.exists(first);
1476+
await first.auth();
1477+
await vi.advanceTimersByTimeAsync(500);
1478+
for (const [, id] of first.requests()) await first.receive(["EOSE", id]);
1479+
const result = owner.publishPresence?.(
1480+
"away",
1481+
new AbortController().signal,
1482+
);
1483+
expect(admission.presenceIdle()).toBe(false);
1484+
if (mode === "reconnect") {
1485+
first.close();
1486+
await vi.advanceTimersByTimeAsync(500);
1487+
const next = sockets[1];
1488+
assert.exists(next);
1489+
await next.auth();
1490+
await vi.advanceTimersByTimeAsync(500);
1491+
for (const [, id] of next.requests()) await next.receive(["EOSE", id]);
1492+
expect(
1493+
await owner.publishPresence?.("online", new AbortController().signal),
1494+
).toBeNull();
1495+
} else {
1496+
admission.pause(3);
1497+
// A real cooldown wins even when another flight is busy signing.
1498+
expect(
1499+
await owner.publishPresence?.("online", new AbortController().signal),
1500+
).toEqual({ retryAfterMs: 4000 });
1501+
}
1502+
release();
1503+
expect(await result).toEqual(
1504+
mode === "reconnect" ? null : { retryAfterMs: 4000 },
1505+
);
1506+
expect(
1507+
sockets.flatMap((s) => s.sent).filter(([kind]) => kind === "EVENT"),
1508+
).toEqual([]);
1509+
expect(admission.presenceIdle()).toBe(true);
1510+
owner.dispose();
1511+
},
1512+
);
14911513

14921514
it("admits signed typing only on its authenticated channel route, without extra subscriptions", async () => {
14931515
vi.useFakeTimers();
@@ -2049,12 +2071,132 @@ it("presence shares the authenticated socket, verifies signatures, and replaces
20492071
h.owner.dispose();
20502072
});
20512073

2074+
it.each([false, true])(
2075+
"paces replacement commands behind a held receipt without polling (late cooldown: %s)",
2076+
async (cooldown) => {
2077+
vi.useFakeTimers();
2078+
vi.spyOn(Math, "random").mockReturnValue(0);
2079+
vi.stubGlobal("navigator", {
2080+
locks: {
2081+
request: async (
2082+
_name: string,
2083+
_options: unknown,
2084+
work: () => Promise<void>,
2085+
) => work(),
2086+
},
2087+
});
2088+
const h = setup([]);
2089+
const listeners = new Set<() => void>();
2090+
let status: "online" | "away" | "offline" = "online",
2091+
command = 0;
2092+
const attempts: number[] = [];
2093+
const publishPresence = h.owner.publishPresence;
2094+
assert.exists(publishPresence);
2095+
const publish = vi.fn(
2096+
(value: "online" | "away" | "offline", signal: AbortSignal) => {
2097+
attempts.push(performance.now());
2098+
return publishPresence(value, signal);
2099+
},
2100+
);
2101+
const owner = createPresence(
2102+
{
2103+
...scriptedTransport(h.key.pubkey, h.key.pubkey).transport,
2104+
viewer: h.key.pubkey,
2105+
presenceSnapshot: async () => new Map([[h.key.pubkey, "online"]]),
2106+
},
2107+
{
2108+
visible: () => true,
2109+
status: () => status,
2110+
command: () => command,
2111+
subscribe(fn) {
2112+
listeners.add(fn);
2113+
return () => {
2114+
listeners.delete(fn);
2115+
};
2116+
},
2117+
dispose() {},
2118+
},
2119+
publish,
2120+
(fn) => fn(),
2121+
);
2122+
const events = () =>
2123+
h.first.sent
2124+
.filter(([kind]) => kind === "EVENT")
2125+
.map(([, event]) => event as { id: string; content: string });
2126+
try {
2127+
await h.first.auth();
2128+
owner.subscribe(h.key.pubkey, () => {});
2129+
owner.connected(true);
2130+
await vi.advanceTimersByTimeAsync(250);
2131+
for (const request of h.first.requests())
2132+
await h.first.receive(["EOSE", request[1]]);
2133+
expect(events().map((event) => event.content)).toEqual(["online"]);
2134+
await vi.advanceTimersByTimeAsync(1000);
2135+
status = "away";
2136+
command++;
2137+
for (const fn of listeners) fn();
2138+
await vi.advanceTimersByTimeAsync(4050);
2139+
// The gate opened, but the original receipt still owns the flight.
2140+
expect(attempts).toEqual([250, 1250, 5300]);
2141+
expect(await publish.mock.results[2]?.value).toBeNull();
2142+
await vi.advanceTimersByTimeAsync(700);
2143+
status = "offline";
2144+
command++;
2145+
for (const fn of listeners) fn();
2146+
await vi.advanceTimersByTimeAsync(4000);
2147+
expect(attempts).toEqual([250, 1250, 5300, 6000]);
2148+
expect(events()).toHaveLength(1);
2149+
const first = events()[0];
2150+
assert.exists(first);
2151+
// Aborting the old owner must not discard a late shared quota refusal.
2152+
await h.first.receive([
2153+
"OK",
2154+
first.id,
2155+
!cooldown,
2156+
cooldown ? "rate-limited: quota exceeded; retry in 1s" : "",
2157+
]);
2158+
await vi.advanceTimersByTimeAsync(999);
2159+
expect(attempts).toEqual([250, 1250, 5300, 6000]);
2160+
await vi.advanceTimersByTimeAsync(1);
2161+
if (cooldown) {
2162+
expect(events()).toHaveLength(1);
2163+
await vi.advanceTimersByTimeAsync(1049);
2164+
expect(attempts).toEqual([250, 1250, 5300, 6000, 11000]);
2165+
await vi.advanceTimersByTimeAsync(1);
2166+
}
2167+
expect(attempts).toEqual(
2168+
cooldown
2169+
? [250, 1250, 5300, 6000, 11000, 12050]
2170+
: [250, 1250, 5300, 6000, 11000],
2171+
);
2172+
expect(events().map((event) => event.content)).toEqual([
2173+
"online",
2174+
"offline",
2175+
]);
2176+
expect(owner.status(h.key.pubkey)).toBe("online");
2177+
const last = events().at(-1);
2178+
assert.exists(last);
2179+
await h.first.receive(["OK", last.id, true, ""]);
2180+
await vi.advanceTimersByTimeAsync(0);
2181+
expect(owner.status(h.key.pubkey)).toBe("offline");
2182+
const count = attempts.length;
2183+
await vi.advanceTimersByTimeAsync(65000);
2184+
expect(attempts).toHaveLength(count); // No superseded renewal or Offline lease.
2185+
} finally {
2186+
owner.dispose();
2187+
h.owner.dispose();
2188+
vi.restoreAllMocks();
2189+
vi.unstubAllGlobals();
2190+
}
2191+
},
2192+
);
2193+
20522194
it("reports the remaining presence gate without extending it and honors cooldown", () => {
20532195
vi.useFakeTimers();
20542196
const admission = createLiveAdmission();
20552197
expect(admission.presenceDelay()).toBe(0);
20562198
const release = admission.tryPresence();
2057-
expect(admission.presenceDelay()).toBe(250);
2199+
expect(admission.presenceDelay()).toBe(0);
20582200
admission.presenceSent();
20592201
vi.advanceTimersByTime(1200);
20602202
expect(admission.presenceDelay()).toBe(3800);

0 commit comments

Comments
 (0)