@soundworks/core 3.7.0 → 4.0.0-alpha.0

package/{server → src/server}/Sockets.js

@@ -1,95 +1,115 @@
-"use strict";
+import { Worker } from 'node:worker_threads';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
+import { WebSocketServer } from 'ws';
+import WebSocket from 'ws';
+import querystring from 'querystring';
 
-var _ws = _interopRequireDefault(require("ws"));
+import Socket from './Socket.js';
 
-var _querystring = _interopRequireDefault(require("querystring"));
-
-var _Socket = _interopRequireDefault(require("./Socket.js"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
 
 /**
  * Websocket server that creates and host all {@link server.Socket} instance.
- *
- * (@note - could be usefull for broadcasting messages, creating rooms, etc.
+ * 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() {
-    /**
-     * Store sockets per room. The romm `'*'` store all current connections.
-     * @private
-     */
+    /** @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 by default added to two rooms:
-   * - to the room corresponding to the client `clientType`
+   * - to the room corresponding to the client `role`
    * - to the '*' 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 });
+      }
+    });
 
-  start(httpServer, config, onConnectionCallback) {
-    const path = config.path; // init global room
-
-    this._rooms.set('*', new Set());
-
-    this.wss = new _ws.default.Server({
-      server: httpServer,
-      path: `/${path}` // @note - update according to existing config files (aka cosima-apps)
-
+    // init ws server
+    this._wss = new WebSocketServer({
+      server: server.httpServer,
+      path: `/${config.path}`, // @note - update according to existing config files (aka cosima-apps)
     });
-    this.wss.on('connection', (ws, req) => {
-      const queryString = _querystring.default.decode(req.url.split('?')[1]);
 
-      const {
-        clientType,
-        key
-      } = queryString;
-      const binary = !!parseInt(queryString.binary);
+    this._wss.on('connection', (ws, req) => {
+      const queryString = querystring.decode(req.url.split('?')[1]);
+      const { role, key } = queryString;
+      const binary = !!(parseInt(queryString.binary));
 
       if (binary) {
         ws.binaryType = 'arraybuffer';
       }
 
       if (!this._initializationCache.has(key)) {
-        this._initializationCache.set(key, {
-          ws,
-          binary
-        });
+        this._initializationCache.set(key, { ws, binary });
       } else {
         const cached = this._initializationCache.get(key);
+        this._initializationCache.delete(key);
 
-        this._initializationCache.delete(key); // should be in order, but just to be sure
-
-
+        // 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.default(stringWs, binaryWs, this._rooms, this, config);
+        const socket = new Socket(stringWs, binaryWs, this._rooms, this, config);
+
         socket.addToRoom('*');
-        socket.addToRoom(clientType);
-        onConnectionCallback(clientType, socket);
+        socket.addToRoom(role);
+
+        onConnectionCallback(role, socket);
       }
     });
   }
 
+  /** @protected */
   terminate() {
+    // terminate stat worker thread
+    this._latencyStatsWorker.terminate();
+    // clean sockets
     const sockets = this._rooms.get('*');
-
     sockets.forEach(socket => socket.terminate());
   }
-  /** @private */
-
 
+  /** @private */
   _broadcast(binary, roomIds, excludeSocket, channel, ...args) {
     const method = binary ? 'sendBinary' : 'send';
     let targets = new Set();
@@ -102,7 +122,6 @@ class Sockets {
       roomIds.forEach(roomId => {
         if (this._rooms.has(roomId)) {
           const room = this._rooms.get(roomId);
-
           room.forEach(socket => targets.add(socket));
         }
       });
@@ -111,7 +130,7 @@ class Sockets {
     }
 
     targets.forEach(socket => {
-      if (socket.ws.readyState === _ws.default.OPEN) {
+      if (socket.ws.readyState === WebSocket.OPEN) {
         if (excludeSocket !== null) {
           if (socket !== excludeSocket) {
             socket[method](channel, ...args);
@@ -122,28 +141,27 @@ class Sockets {
       }
     });
   }
+
   /**
    * 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=null] - Id of the room
    */
-
-
   removeFromRoom(socket, roomId) {
     socket.removeFromRoom(roomId);
   }
+
   /**
    * Send a string message to all client of given room(s). If no room
    * not specified, the message is sent to all clients
@@ -156,11 +174,10 @@ class Sockets {
    * @param {String} channel - Channel of the message
    * @param {...*} args - Arguments of the message (as many as needed, of any type)
    */
-
-
   broadcast(roomIds, excludeSocket, channel, ...args) {
     this._broadcast(false, roomIds, excludeSocket, channel, ...args);
   }
+
   /**
    * Send a binary message (TypedArray) to all client of given room(s). If no room
    * not specified, the message is sent to all clients
@@ -173,13 +190,9 @@ class Sockets {
    * @param {String} channel - Channel of the message
    * @param {...*} args - Arguments of the message (as many as needed, of any type)
    */
-
-
   broadcastBinary(roomIds, excludeSocket, channel, typedArray) {
     this._broadcast(true, roomIds, excludeSocket, channel, typedArray);
   }
-
 }
 
-var _default = Sockets;
-exports.default = _default;
+export default Sockets;