@soundworks/core 4.0.0-alpha.7 → 5.0.0

package/src/server/Socket.js

@@ -1,396 +0,0 @@
-import { getTime } from '@ircam/sc-gettime';
-import {
-  packBinaryMessage,
-  unpackBinaryMessage,
-  packStringMessage,
-  unpackStringMessage,
-} from '../common/sockets-utils.js';
-
-// Status codes:
-//
-// CONNECTING = 0;
-// OPEN = 1;
-// CLOSING = 2;
-// CLOSED = 3;
-// READY_STATES = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
-
-/**
- * The Socket class is a simple publish / subscribe wrapper built on top of the
- * [ws](https://github.com/websockets/ws) library. An instance of {@link server.Socket}
- * is automatically created per client when it connects (see {@link server.Client#socket}).
- *
- * _Important: In most cases, you should consider using a {@link client.SharedState}
- * rather than directly using the sockets._
- *
- * The Socket class contains two different WebSockets:
- * - a socket configured with `binaryType = 'blob'` for JSON compatible data
- *  types (i.e. string, number, boolean, object, array and null).
- * - a socket configured with `binaryType= 'arraybuffer'` for efficient streaming
- *  of binary data.
- *
- * @memberof server
- * @hideconstructor
- */
-class Socket {
-  constructor(ws, binaryWs, rooms, sockets, options = {}) {
-    /**
-     * Configuration object
-     *
-     * @type {object}
-     */
-    this.config = {
-      pingInterval: 5 * 1000,
-      ...options,
-    };
-
-    /**
-     * `ws` socket instance configured with `binaryType=blob` (string)
-     *
-     * @type {object}
-     * @private
-     */
-    this.ws = ws;
-
-    /**
-     * `ws` socket instance configured with `binaryType=arraybuffer` (TypedArray)
-     *
-     * @type {object}
-     * @private
-     */
-    this.binaryWs = binaryWs;
-
-    /**
-     * Reference to the sockets object, is mainly dedicated to allow
-     * broadcasting from a given socket instance.
-     *
-     * @type {server.Sockets}
-     * @example
-     * socket.sockets.broadcast('my-room', this, 'update-value', 1);
-     */
-    this.sockets = sockets;
-
-    /**
-     * Reference to the rooms object
-     *
-     * @type {Map}
-     * @private
-     */
-    this.rooms = rooms;
-
-    /** @private */
-    this._stringListeners = new Map();
-    /** @private */
-    this._binaryListeners = new Map();
-
-    // ----------------------------------------------------------
-    // init string socket
-    // ----------------------------------------------------------
-    this.ws.addEventListener('message', e => {
-      const [channel, args] = unpackStringMessage(e.data);
-      this._emit(false, channel, ...args);
-    });
-
-    // broadcast all `ws` "native" events
-    [
-      'close',
-      'error',
-      'message',
-      'open',
-      'ping',
-      'pong',
-      'unexpected-response',
-      'upgrade',
-    ].forEach(eventName => {
-      this.ws.addEventListener(eventName, e => {
-        this._emit(false, eventName, e.data);
-      });
-    });
-
-    // ----------------------------------------------------------
-    // init binary socket
-    // ----------------------------------------------------------
-    this.binaryWs.addEventListener('message', e => {
-      const [channel, data] = unpackBinaryMessage(e.data);
-      this._emit(true, channel, data);
-    });
-
-    // broadcast all `ws` "native" events
-    [
-      'close',
-      'error',
-      'message',
-      'open',
-      'ping',
-      'pong',
-      'unexpected-response',
-      'upgrade',
-    ].forEach(eventName => {
-      this.binaryWs.addEventListener(eventName, e => {
-        this._emit(true, eventName, e.data);
-      });
-    });
-
-    // heartbeat system (run only on string socket), adapted from:
-    // https://github.com/websockets/ws#how-to-detect-and-close-broken-connections
-    this._isAlive = true;
-    let msg = {
-      type: 'add-measurement',
-      value: {
-        ping: 0,
-        pong: 0,
-      },
-    };
-
-    // heartbeat system, only on "regular" socket
-    this.ws.on('pong', () => {
-      this._isAlive = true;
-
-      msg.value.pong = getTime();
-      this.sockets._latencyStatsWorker.postMessage(msg);
-    });
-
-    this._intervalId = setInterval(() => {
-      if (this._isAlive === false) {
-        // emit a 'close' event to go trough all the disconnection pipeline
-        this._emit(false, 'close');
-        return;
-      }
-
-      this._isAlive = false;
-      msg.value.ping = getTime();
-
-      this.ws.ping();
-    }, this.config.pingInterval);
-  }
-
-  /**
-   * Removes all listeners and immediately close the two sockets. Is automatically
-   * called on `server.stop()`
-   *
-   * @private
-   */
-  terminate() {
-    // clear ping/pong check
-    clearInterval(this._intervalId);
-    // clean rooms
-    for (let [_key, room] of this.rooms) {
-      room.delete(this);
-    }
-
-    // clear references to sockets and rooms
-    this.sockets = null;
-    this.rooms = null;
-
-    // clear all listeners
-    this._stringListeners.clear();
-    this._binaryListeners.clear();
-
-    // clear "native" listeners
-    [this.binaryWs, this.ws].forEach((socket) => {
-      [
-        'close',
-        'error',
-        'message',
-        'open',
-        'ping',
-        'pong',
-        'unexpected-response',
-        'upgrade',
-      ].forEach(eventName => {
-        socket.removeAllListeners(eventName);
-      });
-    });
-
-    // clear binarySocket as this is called from the string one.
-    this.binaryWs.terminate();
-    this.ws.terminate();
-  }
-
-  /**
-   * @param {boolean} binary - Emit to either the string or binary socket.
-   * @param {string} channel - Channel name.
-   * @param {...*} args - Content of the message.
-   * @private
-   */
-  _emit(binary, channel, ...args) {
-    const listeners = binary ? this._binaryListeners : this._stringListeners;
-
-    if (listeners.has(channel)) {
-      const callbacks = listeners.get(channel);
-      callbacks.forEach(callback => callback(...args));
-    }
-  }
-
-  /**
-   * @param {Function[]} listeners - List of listeners, either for the string or binary socket.
-   * @param {string} channel - Channel name.
-   * @param {Function} callback - The function to be added to the listeners.
-   * @private
-   */
-  _addListener(listeners, channel, callback) {
-    if (!listeners.has(channel)) {
-      listeners.set(channel, new Set());
-    }
-
-    const callbacks = listeners.get(channel);
-    callbacks.add(callback);
-  }
-
-  /**
-   * @param {Function[]} listeners - List of listeners, either for the string or binary socket.
-   * @param {string} channel - Channel name.
-   * @param {Function} callback - The function to be removed from the listeners.
-   * @private
-   */
-  _removeListener(listeners, channel, callback) {
-    if (listeners.has(channel)) {
-      const callbacks = listeners.get(channel);
-      callbacks.delete(callback);
-
-      if (callbacks.size === 0) {
-        listeners.delete(channel);
-      }
-    }
-  }
-
-  /**
-   * @param {Function[]} listeners - List of listeners, either for the string or binary socket.
-   * @param {string} [channel=null] - Channel name of the listeners to remove. If null
-   *  all the listeners are cleared.
-   * @private
-   */
-  _removeAllListeners(listeners, channel) {
-    if (channel === null) {
-      listeners.clear();
-    } else if (listeners.has(channel)) {
-      listeners.delete(channel);
-    }
-  }
-
-  /**
-   * Add the socket to a room
-   *
-   * @param {string} roomId - Id of the room.
-   */
-  addToRoom(roomId) {
-    if (!this.rooms.has(roomId)) {
-      this.rooms.set(roomId, new Set());
-    }
-
-    const room = this.rooms.get(roomId);
-    room.add(this);
-  }
-
-  /**
-   * Remove the socket from a room
-   *
-   * @param {string} roomId - Id of the room.
-   */
-  removeFromRoom(roomId) {
-    if (this.rooms.has(roomId)) {
-      const room = this.rooms.get(roomId);
-      room.delete(this);
-    }
-  }
-
-  /**
-   * Send messages with JSON compatible data types on a given channel.
-   *
-   * @param {string} channel - Channel name.
-   * @param {...*} args - Payload of the message. As many arguments as needed, of
-   *  JSON compatible data types (i.e. string, number, boolean, object, array and null).
-   */
-  send(channel, ...args) {
-    const msg = packStringMessage(channel, ...args);
-
-    // 0 CONNECTING  Socket has been created. The connection is not yet open.
-    // 1 OPEN  The connection is open and ready to communicate.
-    // 2 CLOSING The connection is in the process of closing.
-    // 3 CLOSED  The connection is closed or couldn't be opened.
-    if (this.ws.readyState === 1) {
-      this.ws.send(msg, (err) => {
-        if (err) {
-          console.error('error sending msg:', channel, args, err);
-        }
-      });
-    }
-  }
-
-  /**
-   * Listen messages with JSON compatible data types on a given channel.
-   *
-   * @param {string} channel - Channel name.
-   * @param {Function} callback - Callback to execute when a message is received,
-   *  arguments of the callback function will match the arguments sent using the
-   *  {@link server.Socket#send} method.
-   */
-  addListener(channel, callback) {
-    this._addListener(this._stringListeners, channel, callback);
-  }
-
-  /**
-   * Remove a listener of messages with JSON compatible data types from a given channel.
-   *
-   * @param {string} channel - Channel name.
-   * @param {Function} callback - Callback to remove.
-   */
-  removeListener(channel, callback) {
-    this._removeListener(this._stringListeners, channel, callback);
-  }
-
-  /**
-   * Remove all listeners of messages with JSON compatible data types.
-   *
-   * @param {string} channel - Channel name.
-   */
-  removeAllListeners(channel = null) {
-    this._removeAllListeners(this._stringListeners, channel);
-  }
-
-  /**
-   * Send binary messages on a given channel.
-   *
-   * @param {string} channel - Channel name.
-   * @param {TypedArray} typedArray - Binary data to be sent.
-   */
-  sendBinary(channel, typedArray) {
-    const msg = packBinaryMessage(channel, typedArray);
-
-    this.binaryWs.send(msg, (err) => {
-      if (err) {
-        console.error('error sending msg:', channel, typedArray);
-      }
-    });
-  }
-
-  /**
-   * Listen binary messages on a given channel
-   *
-   * @param {string} channel - Channel name.
-   * @param {Function} callback - Callback to execute when a message is received.
-   */
-  addBinaryListener(channel, callback) {
-    this._addListener(this._binaryListeners, channel, callback);
-  }
-
-  /**
-   * Remove a listener of binary compatible messages from a given channel
-   *
-   * @param {string} channel - Channel name.
-   * @param {Function} callback - Callback to remove.
-   */
-  removeBinaryListener(channel, callback) {
-    this._removeListener(this._binaryListeners, channel, callback);
-  }
-
-  /**
-   * Remove all listeners of binary compatible messages on a given channel
-   *
-   * @param {string} channel - Channel of the message.
-   */
-  removeAllBinaryListeners(channel = null) {
-    this._removeAllListeners(this._binaryListeners, channel);
-  }
-}
-
-export default Socket;

package/src/server/Sockets.js

@@ -1,224 +0,0 @@
-import { Worker } from 'node:worker_threads';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import querystring from 'querystring';
-import { WebSocketServer } from 'ws';
-import WebSocket from 'ws';
-
-import Socket from './Socket.js';
-
-const __dirname = fileURLToPath(new URL('.', import.meta.url));
-
-/**
- * Manager all {@link server.Socket} instances.
- *
- * Most of the time, you shouldn't have to use this class instance directely, but
- * it could be usefull in some situations, for broadcasting messages, creating rooms, etc.
- *
- * @memberof server
- */
-class Sockets {
-  constructor() {
-    /** @private */
-    this._wss = null;
-    /** @private */
-    this._rooms = new Map();
-    // The special `'*'` romm stores all current connections.
-    this._rooms.set('*', new Set());
-    /** @private */
-    this._initializationCache = new Map();
-
-    /** @private */
-    this._latencyStatsWorker = null; // protected - used in Socket instances
-    /** @private */
-    this._auditState = null;
-
-  }
-
-  /**
-   * Initialize sockets, all sockets are added to two rooms by default:
-   * - to the room corresponding to the client `role`
-   * - to the '*' room that holds all connected sockets
-   *
-   * @private
-   */
-  async start(server, config, onConnectionCallback) {
-    // init audit stuff for network latency estimation
-    const workerPathname = path.join(__dirname, 'audit-network-latency.worker.js');
-    this._latencyStatsWorker = new Worker(workerPathname);
-    this._auditState = await server.getAuditState();
-
-    this._auditState.onUpdate(updates => {
-      if ('averageNetworkLatencyWindow' in updates || 'averageNetworkLatencyPeriod' in updates) {
-        this._latencyStatsWorker.postMessage({
-          type: 'config',
-          value: {
-            averageLatencyWindow: updates.averageNetworkLatencyWindow,
-            averageLatencyPeriod: updates.averageNetworkLatencyPeriod,
-          },
-        });
-      }
-    }, true);
-
-    this._latencyStatsWorker.on('message', msg => {
-      if (msg.type === 'computed-average-latency') {
-        this._auditState.set({ averageNetworkLatency: msg.value });
-      }
-    });
-
-    // init ws server
-    this._wss = new WebSocketServer({
-      noServer: true,
-      path: `/${config.path}`, // @note - update according to existing config files (aka cosima-apps)
-    });
-
-    this._wss.on('connection', (ws, req) => {
-      const queryString = querystring.decode(req.url.split('?')[1]);
-      const { role, key, token } = queryString;
-      const binary = !!(parseInt(queryString.binary));
-
-      if (binary) {
-        ws.binaryType = 'arraybuffer';
-      }
-
-      if (!this._initializationCache.has(key)) {
-        this._initializationCache.set(key, { ws, binary });
-      } else {
-        const cached = this._initializationCache.get(key);
-        this._initializationCache.delete(key);
-
-        // should be in order, but just to be sure
-        const stringWs = cached.binary ? ws : cached.ws;
-        const binaryWs = cached.binary ? cached.ws : ws;
-        const socket = new Socket(stringWs, binaryWs, this._rooms, this, config);
-
-        socket.addToRoom('*');
-        socket.addToRoom(role);
-
-        onConnectionCallback(role, socket, token);
-      }
-    });
-
-    // check if client can connect
-    server.httpServer.on('upgrade', async (req, socket, head) => {
-      const queryString = querystring.decode(req.url.split('?')[1]);
-
-      const { role, token } = queryString;
-
-      if (server.isProtected(role)) {
-        // we don't have any ip in the upgrade request, so we just check the
-        // connection token is pending
-        const allowed = server.isValidConnectionToken(token);
-
-        if (!allowed) {
-          socket.destroy('not allowed');
-        }
-      }
-
-      this._wss.handleUpgrade(req, socket, head, (ws) => {
-        this._wss.emit('connection', ws, req);
-      });
-    });
-  }
-
-  /**
-   * Terminate all existing sockets
-   *
-   * @private
-   */
-  terminate() {
-    // terminate stat worker thread
-    this._latencyStatsWorker.terminate();
-    // clean sockets
-    const sockets = this._rooms.get('*');
-    sockets.forEach(socket => socket.terminate());
-  }
-
-  /** @private */
-  _broadcast(binary, roomIds, excludeSocket, channel, ...args) {
-    const method = binary ? 'sendBinary' : 'send';
-    let targets = new Set();
-
-    if (typeof roomIds === 'string' || Array.isArray(roomIds)) {
-      if (typeof roomIds === 'string') {
-        roomIds = [roomIds];
-      }
-
-      roomIds.forEach(roomId => {
-        if (this._rooms.has(roomId)) {
-          const room = this._rooms.get(roomId);
-          room.forEach(socket => targets.add(socket));
-        }
-      });
-    } else {
-      targets = this._rooms.get('*');
-    }
-
-    targets.forEach(socket => {
-      if (socket.ws.readyState === WebSocket.OPEN) {
-        if (excludeSocket !== null) {
-          if (socket !== excludeSocket) {
-            socket[method](channel, ...args);
-          }
-        } else {
-          socket[method](channel, ...args);
-        }
-      }
-    });
-  }
-
-  /**
-   * Add a socket to a room
-   *
-   * @param {server.Socket} socket - Socket to add to the room.
-   * @param {String} roomId - Id of the room.
-   */
-  addToRoom(socket, roomId) {
-    socket.addToRoom(roomId);
-  }
-
-  /**
-   * Remove a socket from a room
-   *
-   * @param {server.Socket} socket - Socket to remove from the room.
-   * @param {String} roomId - Id of the room.
-   */
-  removeFromRoom(socket, roomId) {
-    socket.removeFromRoom(roomId);
-  }
-
-  /**
-   * Send a message of JSON compatible data types to all client of given room(s).
-   * If no room is specified, the message is sent to all clients.
-   *
-   *
-   * @param {String|Array} roomsIds - Ids of the rooms that must receive
-   *  the message. If `null` the message is sent to all clients.
-   * @param {server.Socket} excludeSocket - Optionnal socket to ignore when
-   *  broadcasting the message, typically the client at the origin of the message.
-   * @param {String} channel - Channel name.
-   * @param {...*} args - Payload of the message. As many arguments as needed, of
-   *  JSON compatible data types (i.e. string, number, boolean, object, array and null).
-   */
-  broadcast(roomIds, excludeSocket, channel, ...args) {
-    this._broadcast(false, roomIds, excludeSocket, channel, ...args);
-  }
-
-  /**
-   * Send a binary message to all client of given room(s). If no room is specified
-   * specified, the message is sent to all clients.
-   *
-   * @param {String|Array} roomsIds - Ids of the rooms that must receive
-   *  the message. If `null` the message is sent to all clients.
-   * @param {server.Socket} excludeSocket - Optionnal socket to ignore when
-   *  broadcasting the message, typically the client at the origin of the message.
-   * @param {string} channel - Channel name.
-   * @param {TypedArray} typedArray - Binary data to be sent.
-   */
-  broadcastBinary(roomIds, excludeSocket, channel, typedArray) {
-    this._broadcast(true, roomIds, excludeSocket, channel, typedArray);
-  }
-}
-
-export default Sockets;