@soundworks/core 4.0.0-alpha.21 → 4.0.0-alpha.23

package/src/server/Server.js

@@ -4,9 +4,16 @@ import http from 'node:http';
 import https from 'node:https';
 import path from 'node:path';
 import os from 'node:os';
-import { X509Certificate, createPrivateKey } from 'node:crypto';
+import {
+  X509Certificate,
+  createPrivateKey,
+} from 'node:crypto';
 
-import { isPlainObject, idGenerator, getTime } from '@ircam/sc-utils';
+import {
+  isPlainObject,
+  idGenerator,
+  getTime,
+} from '@ircam/sc-utils';
 import chalk from 'chalk';
 import compression from 'compression';
 import express from 'express';
@@ -18,11 +25,18 @@ import pem from 'pem';
 import compile from 'template-literal';
 
 import auditSchema from './audit-schema.js';
-import { encryptData, decryptData } from './crypto.js';
+import {
+  encryptData,
+  decryptData,
+} from './crypto.js';
 import Client from './Client.js';
 import ContextManager from './ContextManager.js';
 import PluginManager from './PluginManager.js';
 import StateManager from './StateManager.js';
+import {
+  kSocketClientId,
+  kSocketTerminate,
+} from './Socket.js';
 import Sockets from './Sockets.js';
 import logger from '../common/logger.js';
 import {
@@ -32,7 +46,7 @@ import {
   CLIENT_HANDSHAKE_ERROR,
   AUDIT_STATE_NAME,
 } from '../common/constants.js';
-
+import version from '../common/version.js';
 
 let _dbNamespaces = new Set();
 
@@ -80,27 +94,6 @@ const DEFAULT_CONFIG = {
 
 const TOKEN_VALID_DURATION = 20; // sec
 
-// set terminal title
-/** @private */
-function setTerminalTitle(server) {
-  let title = '';
-
-  if (server._auditState !== null) {
-    const numClients = server._auditState.get('numClients');
-    let numClientStrings = [];
-    for (let name in numClients) {
-      numClientStrings.push(`${name}: ${numClients[name]}`);
-    }
-
-    title = `${server.config.app.name} | ${numClientStrings.join(' - ')}`;
-  } else {
-    title = `${server.config.app.name}`;
-  }
-
-  const msg = String.fromCharCode(27) + ']0;' + title + String.fromCharCode(7);
-  process.stdout.write(msg);
-}
-
 /**
  * The `Server` class is the main entry point for the server-side of a soundworks
  * application.
@@ -162,6 +155,7 @@ class Server {
     if (!isPlainObject(config)) {
       throw new Error(`[soundworks:Server] Invalid argument for Server constructor, config should be an object`);
     }
+
     /**
      * @description Given config object merged with the following defaults:
      * @example
@@ -225,6 +219,8 @@ class Server {
       }
     }
 
+    this.version = version;
+
     /**
      * Instance of the express router.
      *
@@ -334,7 +330,6 @@ class Server {
     this.stateManager.registerSchema(AUDIT_STATE_NAME, auditSchema);
 
     logger.configure(this.config.env.verbose);
-    setTerminalTitle(this);
   }
 
   /**
@@ -383,7 +378,6 @@ class Server {
     }
     /** @private */
     this._auditState = await this.stateManager.create(AUDIT_STATE_NAME, { numClients });
-    this._auditState.onUpdate(() => setTerminalTitle(this));
 
     // basic http authentication
     if (this.config.env.auth) {
@@ -694,7 +688,7 @@ Invalid certificate files, please check your:
             // this.httpsInfos.isValid = false; // for testing
             if (!this.httpsInfos.isValid) {
               logger.error(chalk.red`    -------------------------------------------`);
-              logger.error(chalk.red`    > INVALID CERTIFICATE`);
+              logger.error(chalk.red`    > INVALID CERTIFICATE                      `);
               logger.error(chalk.red`    i.e. you pretend to be safe but you are not`);
               logger.error(chalk.red`    -------------------------------------------`);
             } else {
@@ -856,16 +850,13 @@ Invalid certificate files, please check your:
    */
   _onSocketConnection(role, socket, connectionToken) {
     const client = new Client(role, socket);
+    socket[kSocketClientId] = client.id;
     const roles = Object.keys(this.config.app.clients);
 
     // this has been validated
     if (this.isProtected(role) && this.isValidConnectionToken(connectionToken)) {
       const { ip } = decryptData(connectionToken);
-      const newData = {
-        ip: ip,
-        id: client.id,
-      };
-
+      const newData = { ip, id: client.id };
       const newToken = encryptData(newData);
 
       client.token = newToken;
@@ -904,11 +895,11 @@ Invalid certificate files, please check your:
       }
 
       // clean sockets
-      socket.terminate();
+      socket[kSocketTerminate]();
     });
 
     socket.addListener(CLIENT_HANDSHAKE_REQUEST, async payload => {
-      const { role, registeredPlugins } = payload;
+      const { role, version, registeredPlugins } = payload;
 
       if (!roles.includes(role)) {
         console.error(`[soundworks.Server] A client with invalid role ("${role}") attempted to connect`);
@@ -920,6 +911,10 @@ Invalid certificate files, please check your:
         return;
       }
 
+      if (version !== this.version) {
+        logger.warnVersionDiscepancies(role, version, this.version);
+      }
+
       try {
         this.pluginManager.checkRegisteredPlugins(registeredPlugins);
       } catch (err) {
@@ -950,7 +945,7 @@ Invalid certificate files, please check your:
       this._onClientConnectCallbacks.forEach(callback => callback(client));
 
       const { id, uuid, token } = client;
-      socket.send(CLIENT_HANDSHAKE_RESPONSE, { id, uuid, token });
+      socket.send(CLIENT_HANDSHAKE_RESPONSE, { id, uuid, token, version: this.version });
     });
   }
 
@@ -1060,6 +1055,12 @@ Invalid certificate files, please check your:
           },
           env: {
             type: config.env.type,
+            // use to configure the socket if the server is running on a different
+            // location than the one the client was served from (cf. #90)
+            useHttps: config.env.useHttps,
+            serverAddress: config.env.serverAddress,
+            port: config.env.port,
+            // other config, to review
             websockets: config.env.websockets,
             subpath: config.env.subpath,
             useMinifiedFile: useMinifiedFile[role],

package/src/server/Socket.js

@@ -5,27 +5,27 @@ import {
   PONG_MESSAGE,
 } from '../common/constants.js';
 import {
-  packBinaryMessage,
-  unpackBinaryMessage,
   packStringMessage,
   unpackStringMessage,
 } from '../common/sockets-utils.js';
+import {
+  kSocketsLatencyStatsWorker,
+  kSocketsDebugPreventHeartBeat,
+  kSocketsRemoveFromAllRooms,
+} from './Sockets.js';
 
-// Status codes:
-//
-// CONNECTING = 0;
-// OPEN = 1;
-// CLOSING = 2;
-// CLOSED = 3;
-// READY_STATES = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
+export const kSocketClientId = Symbol('soundworks:socket-client-id');
+export const kSocketTerminate = Symbol('soundworks:socket-terminate');
 
 /**
- * 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}).
+ * 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._
+ * rather than directly using the Socket instance._
  *
  * The Socket class contains two different WebSockets:
  * - a socket configured with `binaryType = 'blob'` for JSON compatible data
@@ -37,22 +37,17 @@ import {
  * @hideconstructor
  */
 class Socket {
-  constructor(ws, binaryWs, rooms, sockets) {
-    /**
-     * `ws` socket instance configured with `binaryType=blob` (string)
-     *
-     * @type {object}
-     * @private
-     */
-    this.ws = ws;
+  #socket = null;
+  #sockets = null;
+  #listeners = new Map();
+  #heartbeatId = null;
 
+  constructor(ws, sockets) {
     /**
-     * `ws` socket instance configured with `binaryType=arraybuffer` (TypedArray)
-     *
+     * `ws` socket instance configured with `binaryType=blob` (string)
      * @type {object}
-     * @private
      */
-    this.binaryWs = binaryWs;
+    this.#socket = ws;
 
     /**
      * Reference to the sockets object, is mainly dedicated to allow
@@ -62,28 +57,10 @@ class Socket {
      * @example
      * socket.sockets.broadcast('my-room', this, 'update-value', 1);
      */
-    this.sockets = sockets;
+    this.#sockets = sockets;
 
-    /**
-     * Reference to the rooms object
-     *
-     * @type {Map}
-     * @private
-     */
-    this.rooms = rooms;
-
-    /** @private */
-    this._stringListeners = new Map();
-    /** @private */
-    this._binaryListeners = new Map();
-    /** @private */
-    this._heartbeatId = null;
-
-    // heartbeat system (run only on string socket), adapted from:
-    // https://github.com/websockets/ws#how-to-detect-and-close-broken-connections
-    /** @private */
-    this._isAlive = true;
-    let msg = {
+    // @todo - review
+    const msg = {
       type: 'add-measurement',
       value: {
         ping: 0,
@@ -91,43 +68,49 @@ class Socket {
       },
     };
 
-    // ----------------------------------------------------------
-    // String socket
-    // implements ping/pong behavior
-    // ----------------------------------------------------------
-    this.ws.addEventListener('message', e => {
+    let heartbeatMissed = 0;
+    // heartbeat system (run only on string socket), adapted from:
+    // https://github.com/websockets/ws#how-to-detect-and-close-broken-connections
+    this.#socket.addEventListener('message', e => {
       if (e.data === PONG_MESSAGE) {
-        this._isAlive = true;
+        heartbeatMissed = 0;
 
         msg.value.pong = getTime();
-        this.sockets._latencyStatsWorker.postMessage(msg);
+        this.#sockets[kSocketsLatencyStatsWorker].postMessage(msg);
         // do not propagate ping / pong messages
         return;
       }
 
       const [channel, args] = unpackStringMessage(e.data);
-      this._emit(false, channel, ...args);
+      this.#dispatchEvent(channel, ...args);
     });
 
-    this._heartbeatId = setInterval(() => {
-      if (this._isAlive === false) {
-        // emit a 'close' event to go trough all the disconnection pipeline
-        this._emit(false, 'close');
-        return;
+    this.#heartbeatId = setInterval(() => {
+      // we didn't receive the pong message
+      if (heartbeatMissed > 0) {
+        // Emit a 'close' event to go trough all the disconnection pipeline
+        //
+        // @note - this seems to create false positive disconnections when
+        // client is busy, e.g. when loading large sound files so let's just warn
+        // until we gather more feedback
+        // cf. https://making.close.com/posts/reliable-websockets/
+        console.warn(`[Socket] client (id: ${this[kSocketClientId]}) did not respond to ping message in time (missed: ${heartbeatMissed},  interval: ${PING_INTERVAL})`);
+        // this.#dispatchEvent('close');
+        // return;
       }
 
-      this._isAlive = false;
+      heartbeatMissed += 1;
       msg.value.ping = getTime();
 
-      this.ws.send(PING_MESSAGE);
+      this.#socket.send(PING_MESSAGE);
     }, PING_INTERVAL);
 
     // for testing purpose
-    if (this.sockets._DEBUG_PREVENT_HEARTBEAT === true) {
-      clearInterval(this._heartbeatId);
+    if (this.#sockets[kSocketsDebugPreventHeartBeat] === true) {
+      clearInterval(this.#heartbeatId);
     }
 
-    // broadcast all "native" events
+    // propagate "native" events
     [
       'close',
       'error',
@@ -138,165 +121,69 @@ class Socket {
       'unexpected-response',
       'upgrade',
     ].forEach(eventName => {
-      this.ws.addEventListener(eventName, e => {
-        this._emit(false, eventName, e.data);
+      this.#socket.addEventListener(eventName, e => {
+        this.#dispatchEvent(eventName, e.data);
       });
     });
-
-    // ----------------------------------------------------------
-    // Binary socket
-    // ----------------------------------------------------------
-    this.binaryWs.addEventListener('message', e => {
-      const [channel, data] = unpackBinaryMessage(e.data);
-      this._emit(true, channel, data);
-    });
-
-    // broadcast all "native" events
-    [
-      'close',
-      'error',
-      'message',
-      'open',
-      'ping',
-      'pong',
-      'unexpected-response',
-      'upgrade',
-    ].forEach(eventName => {
-      this.binaryWs.addEventListener(eventName, e => {
-        this._emit(true, eventName, e.data);
-      });
-    });
-  }
-
-  /**
-   * Removes all listeners and immediately close the two sockets. Is automatically
-   * called on `server.stop()`
-   *
-   * @private
-   */
-  terminate() {
-    // clear ping/pong check
-    clearInterval(this._heartbeatId);
-
-    // 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.
+   * Dipatch an event to the listeners of the given channel.
    * @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);
+  #dispatchEvent(channel, ...args) {
+    if (this.#listeners.has(channel)) {
+      const callbacks = this.#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
+   * Removes all listeners and immediately close the web socket.
+   *
+   * Is automatically called when socket is closed on the client side or when
+   * Server is stopped
    */
-  _removeAllListeners(listeners, channel) {
-    if (channel === null) {
-      listeners.clear();
-    } else if (listeners.has(channel)) {
-      listeners.delete(channel);
-    }
+  [kSocketTerminate]() {
+    // clear ping / pong interval
+    clearInterval(this.#heartbeatId);
+    // remove socket from all rooms
+    this.#sockets[kSocketsRemoveFromAllRooms](this);
+    // clear references to sockets
+    this.#sockets = null;
+    // clear all listeners
+    this.#listeners.clear();
+    // clear native listeners
+    [
+      'close',
+      'error',
+      'message',
+      'open',
+      'ping',
+      'pong',
+      'unexpected-response',
+      'upgrade',
+    ].forEach(eventName => this.#socket.removeAllListeners(eventName));
+    // terminate the socket
+    this.#socket.terminate();
   }
 
   /**
-   * Add the socket to a room
+   * Reference to the @link{server.Sockets} instance.
    *
-   * @param {string} roomId - Id of the room.
+   * Allows for broadcasting from a given socket instance.
+   *
+   * @type {server.Sockets}
+   * @example
+   * socket.sockets.broadcast('my-room', this, 'update-value', 1);
    */
-  addToRoom(roomId) {
-    if (!this.rooms.has(roomId)) {
-      this.rooms.set(roomId, new Set());
-    }
-
-    const room = this.rooms.get(roomId);
-    room.add(this);
+  get sockets() {
+    return this.#sockets;
   }
 
-  /**
-   * 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);
-    }
+  get readyState() {
+    return this.#socket.readyState;
   }
 
   /**
@@ -309,14 +196,15 @@ class Socket {
   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) => {
+    // ## Status codes:
+    // CONNECTING = 0; Socket has been created. The connection is not yet open.
+    // OPEN = 1; The connection is open and ready to communicate.
+    // CLOSING = 2; The connection is in the process of closing.
+    // CLOSED = 3; The connection is closed or couldn't be opened.
+    if (this.#socket.readyState === 1) {
+      this.#socket.send(msg, (err) => {
         if (err) {
-          console.error('error sending msg:', channel, args, err);
+          console.error('[Socket] error sending msg:', channel, args, err.message);
         }
       });
     }
@@ -326,12 +214,17 @@ class Socket {
    * 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
+   * @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);
+    if (!this.#listeners.has(channel)) {
+      this.#listeners.set(channel, new Set());
+    }
+
+    const callbacks = this.#listeners.get(channel);
+    callbacks.add(callback);
   }
 
   /**
@@ -341,7 +234,14 @@ class Socket {
    * @param {Function} callback - Callback to remove.
    */
   removeListener(channel, callback) {
-    this._removeListener(this._stringListeners, channel, callback);
+    if (this.#listeners.has(channel)) {
+      const callbacks = this.#listeners.get(channel);
+      callbacks.delete(callback);
+
+      if (callbacks.size === 0) {
+        this.#listeners.delete(channel);
+      }
+    }
   }
 
   /**
@@ -350,53 +250,29 @@ class Socket {
    * @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);
-      }
-    });
+    if (channel === null) {
+      this.#listeners.clear();
+    } else if (this.#listeners.has(channel)) {
+      this.#listeners.delete(channel);
+    }
   }
 
   /**
-   * Listen binary messages on a given channel
-   *
-   * @param {string} channel - Channel name.
-   * @param {Function} callback - Callback to execute when a message is received.
+   * Add the socket to a room
+   * @param {string} roomId - Id of the room.
    */
-  addBinaryListener(channel, callback) {
-    this._addListener(this._binaryListeners, channel, callback);
+  addToRoom(roomId) {
+    this.sockets.addToRoom(this, roomId);
   }
 
   /**
-   * Remove a listener of binary compatible messages from a given channel
-   *
-   * @param {string} channel - Channel name.
-   * @param {Function} callback - Callback to remove.
+   * Remove the socket from a room
+   * @param {string} roomId - Id of the room.
    */
-  removeBinaryListener(channel, callback) {
-    this._removeListener(this._binaryListeners, channel, callback);
+  removeFromRoom(roomId) {
+    this.sockets.removeFromRoom(this, roomId);
   }
 
-  /**
-   * 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;