@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/shared/SignalingSession.js

@@ -0,0 +1,343 @@
+import { SignalingEvent, SignalingMethod } from '../protocol/SignalingProtocol.js';
+import { Emitter } from './Emitter.js';
+import { Room } from './Room.js';
+import { SignalingRequestError } from './SignalingError.js';
+import { unrefTimer } from './Transports.js';
+/**
+ * How many times a signal refused for its rate is sent again
+ */
+const LIMIT_RETRIES = 3;
+/**
+ * How long a room joined again for a new media server waits before it is joined again once more, after a failure (no
+ * media server takes the member), in milliseconds: twice longer after each failure, up to MAX_REJOIN_DELAY
+ */
+const REJOIN_DELAY = 1000;
+const MAX_REJOIN_DELAY = 10000;
+/**
+ * A random session id
+ */
+function randomSession() {
+    const bytes = new Uint8Array(12);
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * The signaling of a client: it joins rooms, relays the signals of their peers, keeps the membership alive (heartbeats
+ * for the transports needing them), renews the TURN credentials before they expire, and joins the rooms again after a
+ * reconnection of its transport (with the same session, so the other members keep their connections).
+ */
+export class SignalingSession extends Emitter {
+    #transport;
+    #options;
+    #session;
+    #rooms = new Map();
+    //The events of the rooms being joined, arrived before the answer (the media server of the room offers at once)
+    #early = new Map();
+    //The rooms being joined again for a new media server
+    #rejoining = new Set();
+    #unsubscribe = [];
+    #id;
+    #iceServers = [];
+    #heartbeat;
+    #heartbeatInterval = 0;
+    #refresh;
+    #wasConnected;
+    #closed = false;
+    /**
+     * Create a session on a transport.
+     * @param transport The transport.
+     * @param options How to create the peer connections.
+     */
+    constructor(transport, options) {
+        super();
+        this.#transport = transport;
+        this.#options = options;
+        this.#session = options.session ?? randomSession();
+        this.#wasConnected = transport.connected;
+        this.#unsubscribe.push(transport.listen((event, payload) => this.#event(event, payload)));
+        this.#unsubscribe.push(transport.watch((connected) => this.#status(connected)));
+    }
+    /**
+     * The local member's id (its client id), known once a room is joined.
+     */
+    get id() {
+        return this.#id;
+    }
+    /**
+     * The session: the other members keep their connections when the client joins again with it.
+     */
+    get session() {
+        return this.#session;
+    }
+    /**
+     * Whether the signaling is connected.
+     */
+    get connected() {
+        return this.#transport.connected;
+    }
+    /**
+     * The ICE servers given by the server, with the TURN credentials.
+     */
+    get iceServers() {
+        return [...this.#iceServers];
+    }
+    /**
+     * The rooms joined.
+     */
+    get rooms() {
+        return [...this.#rooms.values()];
+    }
+    /**
+     * Join a room: a {@link Room}, whose `peer` event gives the other members. Joining a room already joined updates the
+     * metadata and gives the same room.
+     * @param room The room.
+     * @param options The metadata the other members get.
+     * @returns The room.
+     */
+    async join(room, options = {}) {
+        if (this.#closed)
+            throw new SignalingRequestError('The signaling is closed', 'E_SIGNALING_CLOSED');
+        const early = [];
+        if (!this.#rooms.has(room))
+            this.#early.set(room, early);
+        let result;
+        try {
+            result = await this.#transport.request(SignalingMethod.join, { room: room, metadata: options.metadata, session: this.#session });
+        }
+        finally {
+            if (this.#early.get(room) === early)
+                this.#early.delete(room);
+        }
+        this.#joinedWith(result);
+        let joined = this.#rooms.get(room);
+        if (!joined) {
+            joined = new Room(this.#roomHost(), room, options.metadata);
+            this.#rooms.set(room, joined);
+        }
+        joined.members(result.peers, options.metadata, result.sfu);
+        for (const [event, payload] of early)
+            this.#event(event, payload);
+        return joined;
+    }
+    /**
+     * Close the session: the rooms are left and their peers closed. A socket given by the application stays open (its
+     * listeners are removed); a WebSocket created by the function given is closed.
+     * @returns Resolves once the rooms are left.
+     */
+    async close() {
+        if (this.#closed)
+            return;
+        const rooms = [...this.#rooms.values()];
+        await Promise.allSettled(rooms.map((room) => room.leave()));
+        this.#closed = true;
+        clearInterval(this.#heartbeat);
+        clearTimeout(this.#refresh);
+        for (const unsubscribe of this.#unsubscribe)
+            unsubscribe();
+        this.#transport.close();
+    }
+    /**
+     * What the rooms need of the session
+     */
+    #roomHost() {
+        const session = this;
+        return {
+            get localId() {
+                return session.#id ?? '';
+            },
+            get signalingUp() {
+                return session.#transport.connected;
+            },
+            create: (configuration = {}) => this.#options.createPeerConnection({
+                ...configuration,
+                iceServers: this.#iceServers,
+                iceTransportPolicy: this.#options.iceTransportPolicy ?? 'all'
+            }),
+            send: (room, to, signal) => this.#signal(room, to, signal),
+            leave: async (room) => {
+                if (this.#rooms.get(room.name) === room)
+                    this.#rooms.delete(room.name);
+                if (!this.#transport.connected)
+                    return;
+                await this.#transport.request(SignalingMethod.leave, { room: room.name }).catch(() => undefined);
+            },
+            //Joined again once the transport is up, if it is not; again and again while it fails (no media server takes
+            //the member), until the room is left
+            rejoin: (room) => {
+                if (this.#closed || !this.#transport.connected || this.#rejoining.has(room.name))
+                    return;
+                this.#rejoining.add(room.name);
+                const attempt = async () => {
+                    for (let attempts = 0;; attempts++) {
+                        try {
+                            return await this.#joinAgain(room);
+                        }
+                        catch (error) {
+                            this.emit('error', error);
+                        }
+                        await new Promise((resolve) => void unrefTimer(setTimeout(resolve, Math.min(REJOIN_DELAY * 2 ** attempts, MAX_REJOIN_DELAY))));
+                        if (this.#closed || room.left || this.#rooms.get(room.name) !== room || !this.#transport.connected)
+                            return;
+                    }
+                };
+                void attempt().finally(() => this.#rejoining.delete(room.name));
+            }
+        };
+    }
+    /**
+     * Join a room again, with the same session: its events wait for the answer
+     * @param room
+     */
+    async #joinAgain(room) {
+        const early = [];
+        this.#early.set(room.name, early);
+        try {
+            const result = await this.#transport.request(SignalingMethod.join, { room: room.name, metadata: room.metadata, session: this.#session });
+            this.#joinedWith(result);
+            if (this.#rooms.get(room.name) === room)
+                room.members(result.peers, room.metadata, result.sfu);
+        }
+        finally {
+            if (this.#early.get(room.name) === early)
+                this.#early.delete(room.name);
+            for (const [event, payload] of early)
+                this.#event(event, payload);
+        }
+    }
+    /**
+     * Send a signal; a signal refused for the rate is sent again a second later
+     * @param room
+     * @param to
+     * @param signal
+     */
+    async #signal(room, to, signal) {
+        for (let attempt = 0;; attempt++) {
+            try {
+                await this.#transport.request(SignalingMethod.signal, { room: room, to: to, ...signal });
+                return;
+            }
+            catch (error) {
+                //The member left in between
+                if (error.errno === 'E_SIGNALING_NOT_A_MEMBER')
+                    return;
+                if (error.errno !== 'E_SIGNALING_LIMIT' || attempt >= LIMIT_RETRIES)
+                    throw error;
+                await new Promise((resolve) => void unrefTimer(setTimeout(resolve, 1000)));
+            }
+        }
+    }
+    /**
+     * The answer of a join: the id, the ICE servers, the heartbeats, the renewal of the credentials
+     * @param result
+     */
+    #joinedWith(result) {
+        this.#id = result.peerId;
+        this.#iceServers = result.iceServers;
+        if (result.heartbeatInterval !== this.#heartbeatInterval) {
+            clearInterval(this.#heartbeat);
+            this.#heartbeatInterval = result.heartbeatInterval;
+            if (result.heartbeatInterval > 0) {
+                this.#heartbeat = unrefTimer(setInterval(() => {
+                    if (this.#transport.connected && this.#rooms.size)
+                        this.#transport.request(SignalingMethod.heartbeat, {}).catch(() => undefined);
+                }, result.heartbeatInterval));
+            }
+        }
+        this.#scheduleRefresh(result.credentialTtl);
+    }
+    /**
+     * Renew the TURN credentials when four fifths of their lifetime are gone
+     * @param ttl
+     */
+    #scheduleRefresh(ttl) {
+        clearTimeout(this.#refresh);
+        if (!ttl)
+            return;
+        //setTimeout holds at most 2^31 - 1 milliseconds
+        const delay = Math.min(ttl * 800, 2 ** 31 - 1);
+        this.#refresh = unrefTimer(setTimeout(() => void this.#renew(), delay));
+    }
+    /**
+     * Get new ICE servers and give them to the connections
+     */
+    async #renew() {
+        if (this.#closed || !this.#rooms.size)
+            return;
+        try {
+            const result = await this.#transport.request(SignalingMethod.iceServers, {});
+            this.#iceServers = result.iceServers;
+            for (const room of this.#rooms.values()) {
+                for (const peer of room.peers) {
+                    try {
+                        peer.connection.setConfiguration({ ...peer.connection.getConfiguration(), iceServers: result.iceServers });
+                    }
+                    catch (error) {
+                        this.emit('error', error);
+                    }
+                }
+            }
+            this.#scheduleRefresh(result.credentialTtl);
+        }
+        catch (error) {
+            this.emit('error', error);
+            //Try again in a minute
+            this.#refresh = unrefTimer(setTimeout(() => void this.#renew(), 60000));
+        }
+    }
+    /**
+     * An event pushed by the server
+     * @param event
+     * @param payload
+     */
+    #event(event, payload) {
+        if (this.#closed || !payload || typeof payload !== 'object')
+            return;
+        const name = payload.room ?? '';
+        //The events of a room being joined wait for the answer
+        const early = this.#early.get(name);
+        if (early)
+            return void early.push([event, payload]);
+        const room = this.#rooms.get(name);
+        if (!room)
+            return;
+        switch (event) {
+            case SignalingEvent.peerJoined:
+                return room.joined(payload);
+            case SignalingEvent.peerLeft:
+                return room.departed(payload);
+            case SignalingEvent.signal:
+                return room.signal(payload);
+        }
+    }
+    /**
+     * The transport connected or disconnected: after a reconnection, the rooms are joined again
+     * @param connected
+     */
+    #status(connected) {
+        if (this.#closed)
+            return;
+        if (!connected) {
+            this.emit('disconnected');
+            return;
+        }
+        if (!this.#wasConnected) {
+            this.#wasConnected = true;
+            return;
+        }
+        void this.#rejoin();
+    }
+    /**
+     * Join the rooms again, with the same session
+     */
+    async #rejoin() {
+        for (const room of [...this.#rooms.values()]) {
+            try {
+                await this.#joinAgain(room);
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        }
+        this.emit('connected');
+    }
+}

package/dist/esm/shared/Transports.js

@@ -0,0 +1,279 @@
+import { SignalingEvent } from '../protocol/SignalingProtocol.js';
+import { signalingErrorOf, SignalingRequestError } from './SignalingError.js';
+/**
+ * The timers of Node.js are not to hold the process
+ * @param timer
+ */
+export function unrefTimer(timer) {
+    timer.unref?.();
+    return timer;
+}
+/**
+ * Set of listeners
+ */
+class Listeners {
+    #set = new Set();
+    add(listener) {
+        this.#set.add(listener);
+        return () => void this.#set.delete(listener);
+    }
+    call(...args) {
+        for (const listener of [...this.#set]) {
+            try {
+                listener(...args);
+            }
+            catch (error) {
+                queueMicrotask(() => {
+                    throw error;
+                });
+            }
+        }
+    }
+}
+/**
+ * The signaling over a Socket.IO socket: a request is the event `message`, `{method, ...params}`, answered by its
+ * acknowledgement `{success, error, payload}`; the events are Socket.IO events. A request sent when the socket
+ * disconnects fails at once (its answer cannot come any more); one made while it is disconnected is sent once it
+ * connects again.
+ */
+export class SocketIOTransport {
+    #socket;
+    #timeout;
+    #events = new Listeners();
+    #status = new Listeners();
+    #handlers = [];
+    //The requests waiting for their answer, and whether they are sent (Socket.IO keeps the ones made while disconnected,
+    //and sends them as it connects)
+    #pending = new Map();
+    #nextId = 1;
+    /**
+     * Use a socket.
+     * @param socket The socket of the application.
+     * @param timeout How long a request waits for its answer, in milliseconds.
+     */
+    constructor(socket, timeout = 15000) {
+        this.#socket = socket;
+        this.#timeout = timeout;
+        for (const event of Object.values(SignalingEvent)) {
+            this.#handlers.push([event, (payload) => this.#events.call(event, payload)]);
+        }
+        this.#handlers.push(['connect', () => {
+                this.#pending.forEach((pending) => pending.sent = true);
+                this.#status.call(true);
+            }]);
+        this.#handlers.push(['disconnect', () => {
+                for (const [id, pending] of [...this.#pending]) {
+                    if (!pending.sent)
+                        continue;
+                    this.#pending.delete(id);
+                    clearTimeout(pending.timer);
+                    pending.reject(new SignalingRequestError('The signaling is disconnected', 'E_SIGNALING_CLOSED'));
+                }
+                this.#status.call(false);
+            }]);
+        for (const [event, handler] of this.#handlers)
+            socket.on(event, handler);
+    }
+    get connected() {
+        return this.#socket.connected;
+    }
+    request(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = this.#nextId++;
+            const timer = unrefTimer(setTimeout(() => {
+                this.#pending.delete(id);
+                reject(new SignalingRequestError(`The request ${method} was not answered in time`, 'E_SIGNALING_TIMEOUT'));
+            }, this.#timeout));
+            this.#pending.set(id, { reject: reject, timer: timer, sent: this.#socket.connected });
+            this.#socket.emit('message', { ...params, method: method }, (response) => {
+                if (!this.#pending.delete(id))
+                    return;
+                clearTimeout(timer);
+                if (response?.success)
+                    return resolve(response.payload);
+                reject(signalingErrorOf(response?.error, `The request ${method} failed`));
+            });
+        });
+    }
+    listen(listener) {
+        return this.#events.add(listener);
+    }
+    watch(listener) {
+        return this.#status.add(listener);
+    }
+    close() {
+        for (const [event, handler] of this.#handlers)
+            this.#socket.off(event, handler);
+    }
+}
+/**
+ * The signaling over JSON-RPC 2.0 on a WebSocket: the requests are JSON-RPC requests, the events are notifications whose
+ * `params` hold the payload. Given a function creating the WebSocket, it reconnects after a disconnection, waiting 1
+ * second, then twice as long each time, 30 seconds at most. A request sent on a socket that closes fails at once (its
+ * answer cannot come any more); one made while the socket is not open is sent once it opens.
+ */
+export class JSONRPCTransport {
+    #factory;
+    #timeout;
+    #events = new Listeners();
+    #status = new Listeners();
+    #pending = new Map();
+    //The requests sent once the socket opens
+    #queue = [];
+    //The requests sent on the socket, waiting for their answer
+    #sent = new Set();
+    #socket;
+    #nextId = 1;
+    #closed = false;
+    #delay = 1000;
+    #reconnectTimer;
+    /**
+     * Use a WebSocket.
+     * @param socket The WebSocket, or a function creating one (to reconnect).
+     * @param timeout How long a request waits for its answer, in milliseconds.
+     */
+    constructor(socket, timeout = 15000) {
+        this.#timeout = timeout;
+        if (typeof socket === 'function') {
+            this.#factory = socket;
+            this.#attach(socket());
+        }
+        else {
+            this.#attach(socket);
+        }
+    }
+    get connected() {
+        return this.#socket.readyState === 1;
+    }
+    request(method, params) {
+        if (this.#closed)
+            return Promise.reject(new SignalingRequestError('The signaling is closed', 'E_SIGNALING_CLOSED'));
+        return new Promise((resolve, reject) => {
+            const id = this.#nextId++;
+            const timer = unrefTimer(setTimeout(() => {
+                this.#pending.delete(id);
+                reject(new SignalingRequestError(`The request ${method} was not answered in time`, 'E_SIGNALING_TIMEOUT'));
+            }, this.#timeout));
+            this.#pending.set(id, { resolve: resolve, reject: reject, timer: timer });
+            const message = JSON.stringify({ jsonrpc: '2.0', id: id, method: method, params: params });
+            if (this.connected) {
+                this.#socket.send(message);
+                this.#sent.add(id);
+            }
+            else if (this.#factory || this.#socket.readyState === 0) {
+                this.#queue.push([id, message]);
+            }
+            else {
+                this.#settle(id, new SignalingRequestError('The signaling is disconnected', 'E_SIGNALING_CLOSED'));
+            }
+        });
+    }
+    listen(listener) {
+        return this.#events.add(listener);
+    }
+    watch(listener) {
+        return this.#status.add(listener);
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        clearTimeout(this.#reconnectTimer);
+        this.#queue.length = 0;
+        for (const id of [...this.#pending.keys()])
+            this.#settle(id, new SignalingRequestError('The signaling is closed', 'E_SIGNALING_CLOSED'));
+        //A socket given by the application stays open: only the ones created by its function are closed
+        if (this.#factory && this.#socket.readyState < 2)
+            this.#socket.close(1000);
+    }
+    /**
+     * Answer a pending request with an error, or with its result
+     * @param id
+     * @param error
+     * @param result
+     */
+    #settle(id, error, result) {
+        const pending = this.#pending.get(id);
+        if (!pending)
+            return;
+        this.#pending.delete(id);
+        this.#sent.delete(id);
+        clearTimeout(pending.timer);
+        if (error) {
+            pending.reject(error);
+        }
+        else {
+            pending.resolve(result);
+        }
+    }
+    /**
+     * Listen to a socket
+     * @param socket
+     */
+    #attach(socket) {
+        this.#socket = socket;
+        const onOpen = () => {
+            this.#delay = 1000;
+            for (const [id, message] of this.#queue.splice(0)) {
+                //Not sent when it failed meanwhile (its time ran out)
+                if (!this.#pending.has(id))
+                    continue;
+                socket.send(message);
+                this.#sent.add(id);
+            }
+            this.#status.call(true);
+        };
+        const onMessage = (event) => this.#receive(event.data);
+        const onClose = () => {
+            socket.removeEventListener('open', onOpen);
+            socket.removeEventListener('message', onMessage);
+            socket.removeEventListener('close', onClose);
+            if (this.#closed)
+                return;
+            //The requests sent cannot be answered any more; without a function to reconnect, the queued ones neither
+            for (const id of this.#factory ? [...this.#sent] : [...this.#pending.keys()])
+                this.#settle(id, new SignalingRequestError('The signaling is disconnected', 'E_SIGNALING_CLOSED'));
+            this.#status.call(false);
+            if (!this.#factory)
+                return;
+            this.#reconnectTimer = unrefTimer(setTimeout(() => {
+                if (!this.#closed)
+                    this.#attach(this.#factory());
+            }, this.#delay));
+            this.#delay = Math.min(this.#delay * 2, 30000);
+        };
+        socket.addEventListener('open', onOpen);
+        socket.addEventListener('message', onMessage);
+        socket.addEventListener('close', onClose);
+        if (socket.readyState === 1)
+            onOpen();
+    }
+    /**
+     * A message from the server: an answer, or a notification
+     * @param data
+     */
+    #receive(data) {
+        let message;
+        try {
+            message = JSON.parse(typeof data === 'string' ? data : new TextDecoder().decode(data));
+        }
+        catch {
+            return;
+        }
+        for (const item of Array.isArray(message) ? message : [message]) {
+            if (!item || typeof item !== 'object')
+                continue;
+            if (typeof item.method === 'string' && item.id === undefined) {
+                this.#events.call(item.method, Array.isArray(item.params) ? item.params[0] : item.params);
+            }
+            else if (typeof item.id === 'number') {
+                if (item.error) {
+                    this.#settle(item.id, signalingErrorOf(item.error, 'The signaling request failed'));
+                }
+                else {
+                    this.#settle(item.id, undefined, item.result);
+                }
+            }
+        }
+    }
+}

package/dist/esm/signaling/MediaServers.js

@@ -0,0 +1,13 @@
+/**
+ * The media server attached to each signaling
+ */
+export const mediaServers = new WeakMap();
+/**
+ * The service a media server announces on the cluster (`Cluster.announce()`), with its load
+ */
+export const MEDIA_SERVER_SERVICE = 'sfu';
+/**
+ * The topic of the requests to a media server of the cluster: give a member joining a room (through a node without a
+ * media server) a media server, as the media server would for a member joining through its own node
+ */
+export const MEDIA_SERVER_ASSIGN_TOPIC = 'webrtc.sfu.assign';