@epicgames-ps/lib-pixelstreamingsignalling-ue5.8 0.1.0 → 0.2.1

package/src/Logger.test.ts

@@ -0,0 +1,109 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { IConfig, InitLogging, Logger } from './Logger';
+import { MAX_LOGGED_LENGTH } from './Utils';
+
+type Transport = (typeof Logger.transports)[number];
+
+const LEVEL = Symbol.for('level');
+const MESSAGE = Symbol.for('message');
+
+// Runs a log call through a transport's format and returns the line it would write. Formatting does no
+// I/O, so this reads exactly what the logger produces without waiting on the file.
+function lineFor(transport: Transport, message: unknown): string {
+    const info = transport.format?.transform({ level: 'info', message, [LEVEL]: 'info' });
+    if (!info || info === true) {
+        throw new Error('the format dropped the line');
+    }
+    return info[MESSAGE] as string;
+}
+
+// InitLogging opens the day's file, so every logger a test creates is closed before its folder is removed.
+async function withLogger(config: IConfig, check: (console: Transport, file: Transport) => void) {
+    InitLogging(config);
+    const [consoleTransport, fileTransport] = Logger.transports;
+    try {
+        check(consoleTransport, fileTransport);
+    } finally {
+        await new Promise((resolve) => {
+            fileTransport.once('finish', resolve);
+            fileTransport.close?.();
+        });
+    }
+}
+
+describe('InitLogging', () => {
+    let logDir: string;
+
+    beforeEach(() => {
+        logDir = fs.mkdtempSync(path.join(os.tmpdir(), 'signalling-log-'));
+    });
+
+    afterEach(() => {
+        fs.rmSync(logDir, { recursive: true, force: true });
+    });
+
+    it('refuses a file size that the file transport would take as no limit', () => {
+        expect(() => InitLogging({ logDir, logMaxSize: '100mb' })).toThrow('logMaxSize');
+        expect(() => InitLogging({ logDir, logMaxSize: '0m' })).toThrow('logMaxSize');
+    });
+
+    it('refuses a file count that the file transport would take as no limit', () => {
+        expect(() => InitLogging({ logDir, logMaxFiles: 0 })).toThrow('logMaxFiles');
+        expect(() => InitLogging({ logDir, logMaxFiles: NaN })).toThrow('logMaxFiles');
+    });
+
+    it('limits the size of each log file and how many are kept', async () => {
+        await withLogger({ logDir }, (_console, file) => {
+            const { options } = file as unknown as { options: { maxSize: unknown; maxFiles: unknown } };
+            expect(options.maxSize).toBe('100m');
+            expect(options.maxFiles).toBe(14);
+        });
+        await withLogger({ logDir, logMaxSize: '5m', logMaxFiles: 3 }, (_console, file) => {
+            const { options } = file as unknown as { options: { maxSize: unknown; maxFiles: unknown } };
+            expect(options.maxSize).toBe('5m');
+            expect(options.maxFiles).toBe(3);
+        });
+    });
+
+    it('cuts long text on the console and in the file', async () => {
+        const text = 'x'.repeat(100000);
+        await withLogger({ logDir }, (console, file) => {
+            const consoleLine = lineFor(console, text);
+            expect(consoleLine.endsWith('... (100000 characters)')).toBe(true);
+            expect(consoleLine.length).toBeLessThan(MAX_LOGGED_LENGTH + 100);
+
+            const fileLine = lineFor(file, text);
+            expect(
+                (JSON.parse(fileLine) as { message: string }).message.endsWith('... (100000 characters)')
+            ).toBe(true);
+            expect(fileLine.length).toBeLessThan(MAX_LOGGED_LENGTH + 200);
+        });
+    });
+
+    it('writes a protocol message to the file whole, or as cut JSON text when it is too long', async () => {
+        const logObj = (protoMessage: object) => ({
+            event: 'proto_message',
+            direction: 'incoming',
+            receiver: 'Player0',
+            protoMessage
+        });
+        await withLogger({ logDir }, (_console, file) => {
+            const short = JSON.parse(lineFor(file, logObj({ type: 'ping', time: 1 }))) as {
+                protoMessage: unknown;
+            };
+            expect(short.protoMessage).toEqual({ type: 'ping', time: 1 });
+
+            const long = { type: 'ping', pad: 'a'.repeat(100000) };
+            const longLine = lineFor(file, logObj(long));
+            const parsed = JSON.parse(longLine) as { protoMessage: string };
+            expect(parsed.protoMessage.startsWith('{"type":"ping"')).toBe(true);
+            expect(parsed.protoMessage.endsWith(`... (${JSON.stringify(long).length} characters)`)).toBe(
+                true
+            );
+            expect(longLine.length).toBeLessThan(MAX_LOGGED_LENGTH + 300);
+        });
+    });
+});

package/src/Logger.ts

@@ -1,5 +1,5 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
-import { stringify, beautify } from './Utils';
+import { stringify, beautify, limitLogText, limitLoggedMessage } from './Utils';
 import { IProtoLogObj } from './LoggingUtils';
 import path from 'path';
 import winston from 'winston';
@@ -30,6 +30,12 @@ export interface IConfig {
 
     // the minimum log level for file messages
     logLevelFile?: string;
+
+    // the size at which a log file is closed and a new one started, as a whole number followed by k, m or g
+    logMaxSize?: string;
+
+    // the number of log files to keep. The oldest is deleted when a new one is started.
+    logMaxFiles?: number;
 }
 
 /**
@@ -70,10 +76,23 @@ export function InitLogging(config: IConfig): void {
     const logDir = config.logDir || 'logs';
     const logLevelConsole = config.logLevelConsole || 'info';
     const logLevelFile = config.logLevelFile || 'info';
+    const logMaxSize = config.logMaxSize || '100m';
+    const logMaxFiles = config.logMaxFiles ?? 14;
     logMessagesToConsole = config.logMessagesToConsole || 'none';
 
+    // winston-daily-rotate-file takes a size it cannot parse, or a count of 0, as no limit at all.
+    if (!/^[1-9]\d*[kmg]$/i.test(logMaxSize)) {
+        throw new Error(`logMaxSize must be a whole number followed by k, m or g, not "${logMaxSize}".`);
+    }
+    if (!Number.isInteger(logMaxFiles) || logMaxFiles < 1) {
+        throw new Error(`logMaxFiles must be a whole number of at least 1, not "${logMaxFiles}".`);
+    }
+
     Logger = winston.createLogger({
-        transports: [createConsoleTransport(logLevelConsole), createFileTransport(logDir, logLevelFile)]
+        transports: [
+            createConsoleTransport(logLevelConsole),
+            createFileTransport(logDir, logLevelFile, logMaxSize, logMaxFiles)
+        ]
     });
 
     const commonLogger = new CommonLogger(Logger);
@@ -118,7 +137,7 @@ function createConsoleFormat() {
     return printf((logObj: TransformableInfo) => {
         const prefix = `[${String(logObj['timestamp'])}] ${logObj.level}: `;
         if (typeof logObj.message === 'string') {
-            return prefix + logObj.message;
+            return prefix + limitLogText(logObj.message);
         } else if (isLogObject(logObj.message)) {
             const { direction, receiver, sender, target, protoMessage } = logObj.message;
             switch (direction) {
@@ -139,9 +158,9 @@ function createConsoleFormat() {
 function formatMessageForConsole(message: BaseMessage) {
     switch (logMessagesToConsole) {
         case 'verbose':
-            return stringify(message);
+            return limitLogText(stringify(message));
         case 'formatted':
-            return beautify(message);
+            return limitLogText(beautify(message));
         default:
             return `[${message.type}]`;
     }
@@ -156,12 +175,13 @@ function createProtoMessageFilter() {
     });
 }
 
-function createFileTransport(logDirPath: string, logLevel: string) {
+function createFileTransport(logDirPath: string, logLevel: string, maxSize: string, maxFiles: number) {
     return new winston.transports.DailyRotateFile({
         level: logLevel,
         filename: path.join(logDirPath, 'server-%DATE%.log'),
         datePattern: 'YYYY-MM-DD',
-        maxFiles: '14d',
+        maxSize,
+        maxFiles,
         format: combine(timestamp({ format: 'YYYY-MM-DD HH:mm:ss.SSS' }), splat(), createFileFormat())
     });
 }
@@ -174,14 +194,15 @@ function createFileFormat() {
                 timestamp,
                 level,
                 event: 'message',
-                message
+                message: limitLogText(message)
             });
         } else if (isLogObject(logObj.message)) {
             const { timestamp, level, message } = logObj;
             return JSON.stringify({
                 timestamp,
                 level,
-                ...message
+                ...message,
+                protoMessage: limitLoggedMessage(message.protoMessage)
             });
         }
         return '';

package/src/PlayerConnection.ts

@@ -142,12 +142,22 @@ export class PlayerConnection implements IPlayer, LogUtils.IMessageLogger {
             } else {
                 Logger.warn(`Subscribing to ${streamerId}`);
                 this.subscribe(streamerId);
+                // subscribe() declines silently, most often because maxSubscribers is reached, and
+                // says so only by leaving subscribedStreamer unset. Forwarding anyway dereferences
+                // null, which surfaces as an uncaughtException and exits the process.
+                if (!this.subscribedStreamer) {
+                    Logger.error(
+                        `Player ${this.playerId} could not be subscribed to ${streamerId}. Disconnecting.`
+                    );
+                    this.disconnect();
+                    return;
+                }
             }
         }
 
         message.playerId = this.playerId;
-        LogUtils.logForward(this, this.subscribedStreamer!, message);
-        this.subscribedStreamer!.protocol.sendMessage(message);
+        LogUtils.logForward(this, this.subscribedStreamer, message);
+        this.subscribedStreamer.protocol.sendMessage(message);
     }
 
     private subscribe(streamerId: string) {

package/src/SFUConnection.test.ts

@@ -0,0 +1,45 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import type WebSocket from 'ws';
+import { Messages } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+import { SFUConnection } from './SFUConnection';
+import { StreamerConnection } from './StreamerConnection';
+import { StreamerRegistry } from './StreamerRegistry';
+import { PlayerRegistry } from './PlayerRegistry';
+import { SignallingServer } from './SignallingServer';
+
+// A streamer the SFU can subscribe to, with no socket behind it.
+function unconnectedStreamer(streamerId: string): StreamerConnection {
+    const streamer = new StreamerConnection({} as unknown as SignallingServer, {} as unknown as WebSocket);
+    streamer.streamerId = streamerId;
+    return streamer;
+}
+
+describe('SFUConnection subscribe', () => {
+    it('leaves the previous streamer when it subscribes to another', () => {
+        const a = unconnectedStreamer('A');
+        const b = unconnectedStreamer('B');
+        const streamerRegistry = new StreamerRegistry();
+        streamerRegistry.streamers.push(a, b);
+        const server = {
+            streamerRegistry,
+            playerRegistry: new PlayerRegistry()
+        } as unknown as SignallingServer;
+        const sfu = new SFUConnection(server, {} as unknown as WebSocket);
+        sfu.playerId = 'SFU1';
+
+        sfu.protocol.emit(Messages.subscribe.typeName, {
+            type: Messages.subscribe.typeName,
+            streamerId: 'A'
+        });
+        sfu.protocol.emit(Messages.subscribe.typeName, {
+            type: Messages.subscribe.typeName,
+            streamerId: 'B'
+        });
+
+        expect(a.subscribers.has('SFU1')).toBe(false);
+        expect(b.subscribers.has('SFU1')).toBe(true);
+        // A disconnect from the old streamer must not detach the SFU from the one it is on now.
+        a.emit('disconnect');
+        expect(sfu.subscribedStreamer).toBe(b);
+    });
+});

package/src/SFUConnection.ts

@@ -184,6 +184,11 @@ export class SFUConnection extends EventEmitter implements IPlayer, IStreamer, L
             return;
         }
 
+        // Leave the previous streamer first, as PlayerConnection does, so it stops forwarding to this SFU
+        // and a later disconnect of it cannot detach the SFU from the streamer it is now on.
+        if (this.subscribedStreamer) {
+            this.unsubscribe();
+        }
         this.subscribedStreamer = streamer;
         // Register as a subscriber of the upstream streamer so it will forward signalling messages
         // back to this SFU (the streamer's forwardMessage only sends to subscribed players).

package/src/SignallingServer.maxPayload.test.ts

@@ -0,0 +1,69 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import * as wslib from 'ws';
+import { SignallingServer, DEFAULT_MAX_PAYLOAD, IServerConfig } from './SignallingServer';
+
+// The constructor binds real listening sockets and the class offers no way to close them, so the
+// websocket servers are replaced here and only the options they are created with are checked.
+jest.mock('ws', () => {
+    const actual = jest.requireActual<typeof wslib>('ws');
+    return {
+        ...actual,
+        WebSocketServer: jest.fn().mockImplementation(() => ({ on: jest.fn() }))
+    };
+});
+
+const STREAMER_PORT = 8888;
+const PLAYER_PORT = 80;
+const SFU_PORT = 8889;
+
+function createdOptions(config: Partial<IServerConfig>): Map<number | undefined, wslib.ServerOptions> {
+    const constructor = jest.mocked(wslib.WebSocketServer);
+    constructor.mockClear();
+    new SignallingServer({
+        streamerPort: STREAMER_PORT,
+        playerPort: PLAYER_PORT,
+        sfuPort: SFU_PORT,
+        peerOptions: {},
+        ...config
+    });
+    const byPort = new Map<number | undefined, wslib.ServerOptions>();
+    for (const [options] of constructor.mock.calls) {
+        byPort.set(options?.port, options ?? {});
+    }
+    return byPort;
+}
+
+describe('SignallingServer websocket message size', () => {
+    it('limits every port to DEFAULT_MAX_PAYLOAD', () => {
+        const options = createdOptions({});
+
+        expect(options.size).toBe(3);
+        expect(options.get(STREAMER_PORT)?.maxPayload).toBe(DEFAULT_MAX_PAYLOAD);
+        expect(options.get(PLAYER_PORT)?.maxPayload).toBe(DEFAULT_MAX_PAYLOAD);
+        expect(options.get(SFU_PORT)?.maxPayload).toBe(DEFAULT_MAX_PAYLOAD);
+    });
+
+    it('is 1 MiB', () => {
+        expect(DEFAULT_MAX_PAYLOAD).toBe(1024 * 1024);
+    });
+
+    it('lets the websocket options of each port override the limit', () => {
+        const options = createdOptions({
+            streamerWsOptions: { maxPayload: 4 * 1024 * 1024 },
+            playerWsOptions: { maxPayload: 64 * 1024 },
+            sfuWsOptions: { maxPayload: 0 }
+        });
+
+        expect(options.get(STREAMER_PORT)?.maxPayload).toBe(4 * 1024 * 1024);
+        expect(options.get(PLAYER_PORT)?.maxPayload).toBe(64 * 1024);
+        expect(options.get(SFU_PORT)?.maxPayload).toBe(0);
+    });
+
+    it('keeps the other websocket options it is given', () => {
+        const verifyClient = jest.fn();
+        const options = createdOptions({ playerWsOptions: { verifyClient } });
+
+        expect(options.get(PLAYER_PORT)?.verifyClient).toBe(verifyClient);
+        expect(options.get(PLAYER_PORT)?.maxPayload).toBe(DEFAULT_MAX_PAYLOAD);
+    });
+});

package/src/SignallingServer.test.ts

@@ -0,0 +1,63 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import { SignallingServer, IPeerOptionsRequest, PeerOptionsProvider } from './SignallingServer';
+
+const STATIC_PEER_OPTIONS = { iceServers: [{ urls: ['stun:stun.example.com:19302'] }] };
+
+const PLAYER_REQUEST: IPeerOptionsRequest = { peerType: 'player', peerId: 'player-1' };
+
+// The constructor binds listening sockets and the class offers no way to close them, so a test that
+// built a server properly would leak a listener per case. The peer options path depends on nothing
+// the constructor sets up beyond these two fields, so we supply them directly.
+function serverWith(provider?: PeerOptionsProvider): SignallingServer {
+    const server = Object.create(SignallingServer.prototype) as SignallingServer;
+    server.config = { streamerPort: 0, peerOptions: STATIC_PEER_OPTIONS, peerOptionsProvider: provider };
+    server.protocolConfig = { peerConnectionOptions: STATIC_PEER_OPTIONS };
+    return server;
+}
+
+function getPeerOptions(server: SignallingServer, request: IPeerOptionsRequest): unknown {
+    // Private: called through the type system rather than exported, because the behaviour under test
+    // is what a connecting peer is sent, not a public API.
+    return (server as unknown as { getPeerOptions(request: IPeerOptionsRequest): unknown }).getPeerOptions(
+        request
+    );
+}
+
+describe('SignallingServer peer options', () => {
+    it('sends the configured peer options when no provider is supplied', () => {
+        expect(getPeerOptions(serverWith(), PLAYER_REQUEST)).toBe(STATIC_PEER_OPTIONS);
+    });
+
+    it('sends what the provider returns', () => {
+        const minted = { iceServers: [{ urls: ['turn:turn.example.com:3478'], username: 'u' }] };
+        expect(
+            getPeerOptions(
+                serverWith(() => minted),
+                PLAYER_REQUEST
+            )
+        ).toBe(minted);
+    });
+
+    it('tells the provider which peer is connecting', () => {
+        const seen: IPeerOptionsRequest[] = [];
+        const server = serverWith((request) => {
+            seen.push(request);
+            return {};
+        });
+
+        getPeerOptions(server, PLAYER_REQUEST);
+        getPeerOptions(server, { peerType: 'streamer', peerId: 'UnknownStreamer' });
+
+        expect(seen).toEqual([
+            { peerType: 'player', peerId: 'player-1' },
+            { peerType: 'streamer', peerId: 'UnknownStreamer' }
+        ]);
+    });
+
+    it('falls back to the configured peer options when the provider throws', () => {
+        const server = serverWith(() => {
+            throw new Error('credential service unreachable');
+        });
+        expect(getPeerOptions(server, PLAYER_REQUEST)).toBe(STATIC_PEER_OPTIONS);
+    });
+});

package/src/SignallingServer.ts

@@ -60,12 +60,54 @@ export interface IServerConfig {
     // ships no authentication of its own. See StreamerIdAuthorizer. When omitted, the default
     // behaviour is unchanged (requested id accepted, numeric suffix appended on collision).
     authorizeStreamerId?: StreamerIdAuthorizer;
+
+    // Optional hook returning the peer configuration to send to a single connecting peer, in place
+    // of the static peerOptions. This is the seam for peer configuration that must not be shared
+    // between connections - time limited TURN credentials being the motivating case, since a static
+    // credential is sent to every peer that ever connects and cannot be changed without a redeploy.
+    // See PeerOptionsProvider. When omitted, every peer receives peerOptions unchanged.
+    peerOptionsProvider?: PeerOptionsProvider;
 }
 
 export type ProtocolConfig = {
     [key: string]: any;
 };
 
+/**
+ * The kind of peer a set of peer options is being built for. Provided so a consumer can vary what
+ * it returns by peer - a streamer connects once and holds its configuration for as long as it runs,
+ * where a player receives a fresh one every time it connects.
+ */
+export type PeerType = 'streamer' | 'player' | 'sfu';
+
+/**
+ * Describes the peer that is about to be sent a config message.
+ */
+export interface IPeerOptionsRequest {
+    // The kind of peer connecting.
+    peerType: PeerType;
+    // The id the registry assigned this peer. For a streamer or an SFU this is the placeholder the
+    // registry allocates on connect, because a streamer is not named until it sends its endpointId
+    // message, which happens after it has been configured. A player id is final.
+    peerId: string;
+}
+
+/**
+ * An optional consumer-supplied hook that builds the peer configuration for one connecting peer.
+ * Return the object to send as peerConnectionOptions in that peer's config message. This is the
+ * seam for per-connection credentials without the project committing to a credential scheme of its
+ * own. A provider that throws is treated as having no answer, and the static peerOptions are sent.
+ */
+export type PeerOptionsProvider = (request: IPeerOptionsRequest) => unknown;
+
+/**
+ * The largest websocket message, in bytes, accepted on the streamer, player and SFU ports. Signalling
+ * messages are a few kilobytes, and ws would otherwise accept up to 100 MiB in one message. A
+ * connection that sends more is closed with code 1009. Setting maxPayload in streamerWsOptions,
+ * playerWsOptions or sfuWsOptions overrides it for that port.
+ */
+export const DEFAULT_MAX_PAYLOAD = 1024 * 1024;
+
 /**
  * The main signalling server object.
  * Contains a streamer and player registry and handles setting up of websockets
@@ -104,6 +146,7 @@ export class SignallingServer {
         const streamerServer = new wslib.WebSocketServer({
             port: config.streamerPort,
             backlog: 1,
+            maxPayload: DEFAULT_MAX_PAYLOAD,
             ...config.streamerWsOptions
         });
         streamerServer.on('connection', this.onStreamerConnected.bind(this));
@@ -114,6 +157,7 @@ export class SignallingServer {
         const playerServer = new wslib.WebSocketServer({
             server: server,
             port: server ? undefined : config.playerPort,
+            maxPayload: DEFAULT_MAX_PAYLOAD,
             ...config.playerWsOptions
         });
         playerServer.on('connection', this.onPlayerConnected.bind(this));
@@ -126,6 +170,7 @@ export class SignallingServer {
             const sfuServer = new wslib.WebSocketServer({
                 port: config.sfuPort,
                 backlog: 1,
+                maxPayload: DEFAULT_MAX_PAYLOAD,
                 ...config.sfuWsOptions
             });
             sfuServer.on('connection', this.onSFUConnected.bind(this));
@@ -133,15 +178,46 @@ export class SignallingServer {
         }
     }
 
-    private sendConfigMessage(connection: { sendMessage(msg: Messages.config): void }): void {
+    private sendConfigMessage(
+        connection: { sendMessage(msg: Messages.config): void },
+        peerRequest: IPeerOptionsRequest
+    ): void {
         // peer connection options is a general field with all optional fields;
         // it doesnt play nice with mergePartial so we just add it verbatim
         const message: Messages.config = MessageHelpers.createMessage(Messages.config, this.protocolConfig);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        message.peerConnectionOptions = this.protocolConfig['peerConnectionOptions'];
+        message.peerConnectionOptions = this.getPeerOptions(peerRequest);
         connection.sendMessage(message);
     }
 
+    /**
+     * Resolves the peer options for one connecting peer, deferring to peerOptionsProvider when the
+     * consumer supplied one.
+     */
+    private getPeerOptions(peerRequest: IPeerOptionsRequest): Messages.config['peerConnectionOptions'] {
+        if (!this.config.peerOptionsProvider) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return this.protocolConfig['peerConnectionOptions'];
+        }
+
+        try {
+            // The provider is consumer code, so its return is unknown to us; it travels as an
+            // opaque blob in the config message either way.
+            return this.config.peerOptionsProvider(peerRequest) as Messages.config['peerConnectionOptions'];
+        } catch (error) {
+            // A provider is consumer code and may reach outside the process for a credential. If it
+            // fails we still send a config message, because a peer that never receives one simply
+            // waits forever with nothing in its log to explain why.
+            Logger.error(
+                'peerOptionsProvider threw for %s peer %s, falling back to the static peer options: %s',
+                peerRequest.peerType,
+                peerRequest.peerId,
+                error instanceof Error ? error.message : stringify(error)
+            );
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return this.protocolConfig['peerConnectionOptions'];
+        }
+    }
+
     private onStreamerConnected(ws: wslib.WebSocket, request: http.IncomingMessage) {
         Logger.info(`New streamer connection: %s`, request.socket.remoteAddress);
 
@@ -159,7 +235,7 @@ export class SignallingServer {
             );
         });
 
-        this.sendConfigMessage(newStreamer);
+        this.sendConfigMessage(newStreamer, { peerType: 'streamer', peerId: newStreamer.streamerId });
     }
 
     private onPlayerConnected(ws: wslib.WebSocket, request: http.IncomingMessage) {
@@ -193,7 +269,7 @@ export class SignallingServer {
             };
         }
 
-        this.sendConfigMessage(newPlayer);
+        this.sendConfigMessage(newPlayer, { peerType: 'player', peerId: newPlayer.playerId });
     }
 
     private onSFUConnected(ws: wslib.WebSocket, request: http.IncomingMessage) {
@@ -209,6 +285,6 @@ export class SignallingServer {
             Logger.info(`SFU %s (%s) disconnected.`, newSFU.streamerId, request.socket.remoteAddress);
         });
 
-        this.sendConfigMessage(newSFU);
+        this.sendConfigMessage(newSFU, { peerType: 'sfu', peerId: newSFU.streamerId });
     }
 }

package/src/StreamerConnection.test.ts

@@ -0,0 +1,48 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import type WebSocket from 'ws';
+import { StreamerConnection } from './StreamerConnection';
+import { SignallingServer } from './SignallingServer';
+
+describe('StreamerConnection disconnectPlayer reason', () => {
+    // A streamer with one subscribed player whose protocol records the close it is asked for.
+    function streamerWithPlayer() {
+        const disconnect = jest.fn();
+        const player = { protocol: { disconnect } };
+        const server = { playerRegistry: { get: () => player } } as unknown as SignallingServer;
+        const streamer = new StreamerConnection(server, {} as unknown as WebSocket);
+        streamer.subscribers = new Set(['player-1']);
+        return { streamer, disconnect };
+    }
+
+    function disconnectPlayer(streamer: StreamerConnection, reason: unknown): void {
+        streamer.protocol.emit('disconnectPlayer', {
+            type: 'disconnectPlayer',
+            playerId: 'player-1',
+            reason
+        });
+    }
+
+    it('passes a short string reason through', () => {
+        const { streamer, disconnect } = streamerWithPlayer();
+        disconnectPlayer(streamer, 'bye');
+        expect(disconnect).toHaveBeenCalledWith(1011, 'bye');
+    });
+
+    it('closes without a reason when the reason is over 123 bytes', () => {
+        const { streamer, disconnect } = streamerWithPlayer();
+        disconnectPlayer(streamer, 'x'.repeat(124));
+        expect(disconnect).toHaveBeenCalledWith(1011, undefined);
+    });
+
+    it('counts the reason in bytes, not characters', () => {
+        const { streamer, disconnect } = streamerWithPlayer();
+        disconnectPlayer(streamer, String.fromCharCode(0xe9).repeat(62)); // 124 bytes in UTF-8
+        expect(disconnect).toHaveBeenCalledWith(1011, undefined);
+    });
+
+    it('closes without a reason when the reason is not a string', () => {
+        const { streamer, disconnect } = streamerWithPlayer();
+        disconnectPlayer(streamer, { length: 1 });
+        expect(disconnect).toHaveBeenCalledWith(1011, undefined);
+    });
+});

package/src/StreamerConnection.ts

@@ -179,7 +179,13 @@ export class StreamerConnection extends EventEmitter implements IStreamer, LogUt
             }
             const player = this.server.playerRegistry.get(message.playerId);
             if (player) {
-                player.protocol.disconnect(1011, message.reason);
+                // ws throws on a reason over 123 bytes or one that is not a string, which would crash the
+                // server. Such a reason is dropped; the player is still closed.
+                const reason =
+                    typeof message.reason === 'string' && Buffer.byteLength(message.reason) <= 123
+                        ? message.reason
+                        : undefined;
+                player.protocol.disconnect(1011, reason);
             }
         }
     }

package/src/StreamerRegistry.test.ts

@@ -0,0 +1,27 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import type WebSocket from 'ws';
+import { Messages } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+import { StreamerConnection } from './StreamerConnection';
+import { StreamerRegistry } from './StreamerRegistry';
+import { SignallingServer } from './SignallingServer';
+
+// A streamer the registry can add and talk to, with no socket behind it.
+function unconnectedStreamer(): StreamerConnection {
+    return new StreamerConnection({} as unknown as SignallingServer, {} as unknown as WebSocket);
+}
+
+describe('StreamerRegistry endpointId handling', () => {
+    it('treats a non-string id as no id, so a later registration still works', () => {
+        const registry = new StreamerRegistry();
+        const first = unconnectedStreamer();
+        registry.add(first);
+
+        // The id arrives as any JSON value; a number here used to be stored as the streamer id.
+        first.protocol.emit(Messages.endpointId.typeName, { type: Messages.endpointId.typeName, id: 5 });
+        expect(typeof first.streamerId).toBe('string');
+
+        const second = unconnectedStreamer();
+        expect(() => registry.add(second)).not.toThrow();
+        expect(second.streamerId).not.toBe(first.streamerId);
+    });
+});