Bound live event stream queues (Refs #71)

2026-10-09 12:41:23 -04:00
parent 0abe5ba820
commit deb2d21f29
4 changed files with 244 additions and 73 deletions
@@ -0,0 +1,60 @@
+import { subscribe, type PipelineEvent } from './bus.js';
+
+const encoder = new TextEncoder();
+const hello = encoder.encode(': hello\n\n');
+const ping = encoder.encode(': ping\n\n');
+const HEARTBEAT_MS = 20_000;
+// Allow snapshots and short bursts, but never retain an unbounded event history.
+const MAX_QUEUED_FRAMES = 64;
+
+interface EventStreamOptions {
+    accepts: (event: PipelineEvent) => boolean;
+    encode: (event: PipelineEvent) => Uint8Array;
+    initialFrames?: Uint8Array[];
+}
+
+export function eventStreamResponse({ accepts, encode, initialFrames = [] }: EventStreamOptions): Response {
+    let heartbeat: ReturnType<typeof setInterval> | undefined;
+    let unsubscribe: (() => void) | undefined;
+    let closed = false;
+    const cleanup = () => {
+        closed = true;
+        if (heartbeat) clearInterval(heartbeat);
+        unsubscribe?.();
+        heartbeat = undefined;
+        unsubscribe = undefined;
+    };
+
+    const stream = new ReadableStream<Uint8Array>({
+        start(controller) {
+            const send = (frame: () => Uint8Array) => {
+                if (closed) return;
+                if ((controller.desiredSize ?? 0) <= 0) {
+                    // Reconnect for fresh state instead of silently losing deltas.
+                    // close() does not invoke cancel(), so release resources here.
+                    cleanup();
+                    controller.close();
+                    return;
+                }
+                try { controller.enqueue(frame()); }
+                catch (cause) { cleanup(); controller.error(cause); }
+            };
+            send(() => hello);
+            for (const frame of initialFrames) send(() => frame);
+            if (closed) return;
+            unsubscribe = subscribe(event => {
+                if (accepts(event)) send(() => encode(event));
+            });
+            heartbeat = setInterval(() => send(() => ping), HEARTBEAT_MS);
+        },
+        cancel: cleanup
+    }, { highWaterMark: MAX_QUEUED_FRAMES });
+
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            Connection: 'keep-alive'
+        }
+    });
+}
@@ -1,45 +1,14 @@
-import { subscribe, type PipelineEvent } from '$lib/server/pipeline/bus.js';
+import { eventStreamResponse } from '$lib/server/pipeline/event-stream.js';

-// Multiplexed SSE. Every event with a type field goes out. The client filters
-// by type (server-state | deployment-opened | sweep-tick | server-changed).
+// Multiplexed SSE for deployment progress and fleet invalidations.

 const encoder = new TextEncoder();
-const HEARTBEAT_MS = 20_000;
-
-function send(controller: ReadableStreamDefaultController<Uint8Array>, event: PipelineEvent): void {
-    controller.enqueue(encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`));
-}

 export async function GET() {
-    let heartbeat: NodeJS.Timeout | null = null;
-    let unsubscribe: (() => void) | null = null;
-
-    const stream = new ReadableStream<Uint8Array>({
-        start(controller) {
-            unsubscribe = subscribe((event) => {
-                if (
-                    event.type === 'server-state' ||
-                    event.type === 'deployment-opened' ||
-                    event.type === 'server-changed' ||
-                    event.type === 'sweep-tick' || event.type === 'fleet-invalidated' || event.type === 'beta-changed'
-                ) {
-                    send(controller, event);
-                }
-            });
-            controller.enqueue(encoder.encode(': hello\n\n'));
-            heartbeat = setInterval(() => controller.enqueue(encoder.encode(': ping\n\n')), HEARTBEAT_MS);
-        },
-        cancel() {
-            if (heartbeat) clearInterval(heartbeat);
-            if (unsubscribe) unsubscribe();
-        }
-    });
-
-    return new Response(stream, {
-        headers: {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache, no-transform',
-            Connection: 'keep-alive'
-        }
+    return eventStreamResponse({
+        accepts: event => event.type === 'server-state' || event.type === 'deployment-opened' ||
+            event.type === 'server-changed' || event.type === 'sweep-tick' ||
+            event.type === 'fleet-invalidated' || event.type === 'beta-changed',
+        encode: event => encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`)
    });
 }
@@ -1,51 +1,34 @@
 import { observationReader } from '$lib/server/fleet/status.js';
 import { listServers } from '$lib/server/fleet/servers.js';
 import { statusEntry } from '$lib/server/pipeline/worker.js';
-import { subscribe, type PipelineEvent } from '$lib/server/pipeline/bus.js';
+import type { PipelineEvent } from '$lib/server/pipeline/bus.js';
+import { eventStreamResponse } from '$lib/server/pipeline/event-stream.js';
 import { listTelemetry } from '$lib/server/fleet/telemetry.js';
 import { playerCapacityReader } from '$lib/server/fleet/player-capacity.js';

 const encoder = new TextEncoder();
-const HEARTBEAT_MS = 20_000;
 // Bus subscribers receive the same event object. Reuse its complete frame
 // across connections without retaining events after delivery.
 const frames = new WeakMap<PipelineEvent, Uint8Array>();

 export async function GET() {
-    let heartbeat: NodeJS.Timeout | null = null;
-    let unsubscribe: (() => void) | null = null;
+    const observation = observationReader();
+    const capacity = playerCapacityReader();
+    const observe = (server: ReturnType<typeof listServers>[number]) => statusEntry(server, observation, capacity(server.name));

-    const stream = new ReadableStream<Uint8Array>({
-        start(controller) {
-            unsubscribe = subscribe((event) => {
-                if (event.type === 'server-status' || event.type === 'server-telemetry') {
-                    let frame = frames.get(event);
-                    if (!frame) {
-                        frame = encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify({ ...event, serverNow: Date.now() })}\n\n`);
-                        frames.set(event, frame);
-                    }
-                    controller.enqueue(frame);
-                }
-            });
-            const observation = observationReader();
-            const capacity = playerCapacityReader();
-            const observe = (server: ReturnType<typeof listServers>[number]) => statusEntry(server, observation, capacity(server.name));
-            controller.enqueue(encoder.encode(': hello\n\n'));
-            controller.enqueue(encoder.encode(`event: server-status\ndata: ${JSON.stringify({ entries: listServers().map(server => observe(server)), snapshot: true, serverNow: Date.now() })}\n\n`));
-            controller.enqueue(encoder.encode(`event: server-telemetry\ndata: ${JSON.stringify({ entries: listTelemetry(), snapshot: true, serverNow: Date.now() })}\n\n`));
-            heartbeat = setInterval(() => controller.enqueue(encoder.encode(': ping\n\n')), HEARTBEAT_MS);
+    return eventStreamResponse({
+        accepts: event => event.type === 'server-status' || event.type === 'server-telemetry',
+        encode(event) {
+            let frame = frames.get(event);
+            if (!frame) {
+                frame = encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify({ ...event, serverNow: Date.now() })}\n\n`);
+                frames.set(event, frame);
+            }
+            return frame;
        },
-        cancel() {
-            if (heartbeat) clearInterval(heartbeat);
-            if (unsubscribe) unsubscribe();
-        }
-    });
-
-    return new Response(stream, {
-        headers: {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache, no-transform',
-            Connection: 'keep-alive'
-        }
+        initialFrames: [
+            encoder.encode(`event: server-status\ndata: ${JSON.stringify({ entries: listServers().map(server => observe(server)), snapshot: true, serverNow: Date.now() })}\n\n`),
+            encoder.encode(`event: server-telemetry\ndata: ${JSON.stringify({ entries: listTelemetry(), snapshot: true, serverNow: Date.now() })}\n\n`)
+        ]
    });
 }