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

package/src/server/Socket.js

@@ -1,4 +1,9 @@
-import { getTime } from '@ircam/sc-gettime';
+import { getTime } from '@ircam/sc-utils';
+import {
+  PING_INTERVAL,
+  PING_MESSAGE,
+  PONG_MESSAGE,
+} from '../common/constants.js';
 import {
   packBinaryMessage,
   unpackBinaryMessage,
@@ -32,17 +37,7 @@ import {
  * @hideconstructor
  */
 class Socket {
-  constructor(ws, binaryWs, rooms, sockets, options = {}) {
-    /**
-     * Configuration object
-     *
-     * @type {object}
-     */
-    this.config = {
-      pingInterval: 5 * 1000,
-      ...options,
-    };
-
+  constructor(ws, binaryWs, rooms, sockets) {
     /**
      * `ws` socket instance configured with `binaryType=blob` (string)
      *
@@ -81,16 +76,58 @@ class Socket {
     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 = {
+      type: 'add-measurement',
+      value: {
+        ping: 0,
+        pong: 0,
+      },
+    };
 
     // ----------------------------------------------------------
-    // init string socket
+    // String socket
+    // implements ping/pong behavior
     // ----------------------------------------------------------
     this.ws.addEventListener('message', e => {
+      if (e.data === PONG_MESSAGE) {
+        this._isAlive = true;
+
+        msg.value.pong = getTime();
+        this.sockets._latencyStatsWorker.postMessage(msg);
+        // do not propagate ping / pong messages
+        return;
+      }
+
       const [channel, args] = unpackStringMessage(e.data);
       this._emit(false, channel, ...args);
     });
 
-    // broadcast all `ws` "native" events
+    this._heartbeatId = 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.send(PING_MESSAGE);
+    }, PING_INTERVAL);
+
+    // for testing purpose
+    if (this.sockets._DEBUG_PREVENT_HEARTBEAT === true) {
+      clearInterval(this._heartbeatId);
+    }
+
+    // broadcast all "native" events
     [
       'close',
       'error',
@@ -107,14 +144,14 @@ class Socket {
     });
 
     // ----------------------------------------------------------
-    // init binary socket
+    // Binary socket
     // ----------------------------------------------------------
     this.binaryWs.addEventListener('message', e => {
       const [channel, data] = unpackBinaryMessage(e.data);
       this._emit(true, channel, data);
     });
 
-    // broadcast all `ws` "native" events
+    // broadcast all "native" events
     [
       'close',
       'error',
@@ -129,38 +166,6 @@ class Socket {
         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);
   }
 
   /**
@@ -171,7 +176,8 @@ class Socket {
    */
   terminate() {
     // clear ping/pong check
-    clearInterval(this._intervalId);
+    clearInterval(this._heartbeatId);
+
     // clean rooms
     for (let [_key, room] of this.rooms) {
       room.delete(this);

package/src/server/Sockets.js

@@ -1,14 +1,12 @@
 import { Worker } from 'node:worker_threads';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { WebSocketServer } from 'ws';
-import WebSocket from 'ws';
 import querystring from 'querystring';
+import { default as WebSocket, WebSocketServer } from 'ws';
 
 import Socket from './Socket.js';
+import networkLatencyWorker from './audit-network-latency.worker.js';
 
-const __dirname = fileURLToPath(new URL('.', import.meta.url));
+// this crashes when bundling server to cjs module for Max, fallback to cjs worker
+// const __dirname = fileURLToPath(new URL('.', import.meta.url));
 
 /**
  * Manager all {@link server.Socket} instances.
@@ -34,6 +32,8 @@ class Sockets {
     /** @private */
     this._auditState = null;
 
+    /** @private */
+    this._DEBUG_PREVENT_HEARTBEAT = false;
   }
 
   /**
@@ -45,8 +45,9 @@ class Sockets {
    */
   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);
+    // @see note about __dirname
+    // const workerPathname = path.join(__dirname, 'audit-network-latency.worker.js');
+    this._latencyStatsWorker = new Worker(networkLatencyWorker, { eval: true });
     this._auditState = await server.getAuditState();
 
     this._auditState.onUpdate(updates => {
@@ -69,13 +70,13 @@ class Sockets {
 
     // init ws server
     this._wss = new WebSocketServer({
-      server: server.httpServer,
+      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 } = queryString;
+      const { role, key, token } = queryString;
       const binary = !!(parseInt(queryString.binary));
 
       if (binary) {
@@ -96,8 +97,29 @@ class Sockets {
         socket.addToRoom('*');
         socket.addToRoom(role);
 
-        onConnectionCallback(role, socket);
+        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);
+      });
     });
   }
 

package/src/server/StateManager.js

@@ -1,12 +1,11 @@
-import EventEmitter from 'node:events';
-
-import clonedeep from 'lodash.clonedeep';
+import { idGenerator, isString, isPlainObject } from '@ircam/sc-utils';
+import clonedeep from 'lodash/cloneDeep.js';
 
 import BaseStateManager from '../common/BaseStateManager.js';
+import BatchedTransport from '../common/BatchedTransport.js';
 import ParameterBag from '../common/ParameterBag.js';
 import SharedStatePrivate from '../common/SharedStatePrivate.js';
 import {
-  SERVER_ID,
   CREATE_REQUEST,
   CREATE_RESPONSE,
   CREATE_ERROR,
@@ -16,16 +15,22 @@ import {
   ATTACH_ERROR,
   OBSERVE_REQUEST,
   OBSERVE_RESPONSE,
+  OBSERVE_ERROR,
   OBSERVE_NOTIFICATION,
   UNOBSERVE_NOTIFICATION,
   DELETE_SCHEMA,
+  GET_SCHEMA_REQUEST,
+  GET_SCHEMA_RESPONSE,
+  GET_SCHEMA_ERROR,
   PRIVATE_STATES,
 } from '../common/constants.js';
-import { idGenerator } from '../common/utils.js';
+
 
 const generateStateId = idGenerator();
 const generateRemoteId = idGenerator();
 
+const kIsObservableState = Symbol('StateManager::isObservableState');
+
 /**
  * @typedef {object} server.StateManager~schema
  *
@@ -306,19 +311,25 @@ const generateRemoteId = idGenerator();
  */
 class StateManager extends BaseStateManager {
   constructor() {
-    // acts as a client of itself locally
-    const localClientId = SERVER_ID;
-    const localTransport = new EventEmitter();
-
-    super(localClientId, localTransport);
+    super();
 
     this._clientByNodeId = new Map();
-    this._serverStatesById = new Map();
+    this._sharedStatePrivateById = new Map();
     this._schemas = new Map();
     this._observers = new Set();
     this._hooksBySchemaName = new Map(); // protected
+  }
+
+  init(id, transport) {
+    super.init(id, transport);
+    // add itself as client of the state manager server
+    this.addClient(id, transport);
+  }
 
-    this.addClient(localClientId, localTransport);
+  [kIsObservableState](state) {
+    const { schemaName, isCollectionController } = state;
+    // is observable only if not in private state and not a controller state
+    return !PRIVATE_STATES.includes(schemaName) && !isCollectionController;
   }
 
   /**
@@ -334,114 +345,177 @@ class StateManager extends BaseStateManager {
    * @private
    */
   addClient(nodeId, transport) {
-    const client = { id: nodeId, transport };
+    const batchedTransport = new BatchedTransport(transport);
+    const client = {
+      id: nodeId,
+      transport: batchedTransport,
+    };
+
     this._clientByNodeId.set(nodeId, client);
 
     // ---------------------------------------------
     // CREATE
     // ---------------------------------------------
-    client.transport.addListener(CREATE_REQUEST, (reqId, schemaName, requireSchema, initValues = {}) => {
-      if (this._schemas.has(schemaName)) {
-        try {
-          const schema = this._schemas.get(schemaName);
-          const stateId = generateStateId.next().value;
-          const remoteId = generateRemoteId.next().value;
-          // id, schemaName, schema, manager, initValues = {}
-          const state = new SharedStatePrivate(stateId, schemaName, schema, this, initValues);
-
-          state._attachClient(remoteId, client, true); // attach client to the state
-          this._serverStatesById.set(stateId, state);
-
-          const currentValues = state._parameters.getValues();
-          const sendedSchema = requireSchema ? schema : null;
-
-          client.transport.emit(CREATE_RESPONSE, reqId, stateId, remoteId, schemaName, sendedSchema, currentValues);
-
-          this._observers.forEach(observer => {
-            observer.transport.emit(OBSERVE_NOTIFICATION, [schemaName, stateId, nodeId]);
-          });
-        } catch(err) {
-          client.transport.emit(CREATE_ERROR, reqId, err.message);
-          console.error(err.message);
+    client.transport.addListener(
+      CREATE_REQUEST,
+      (reqId, schemaName, requireSchema, initValues = {}) => {
+        if (this._schemas.has(schemaName)) {
+          try {
+            const schema = this._schemas.get(schemaName);
+            const stateId = generateStateId.next().value;
+            const remoteId = generateRemoteId.next().value;
+            const state = new SharedStatePrivate(stateId, schemaName, schema, this, initValues);
+
+            // attach client to the state as owner
+            const isOwner = true;
+            const filter = null;
+            state._attachClient(remoteId, client, isOwner, filter);
+
+            this._sharedStatePrivateById.set(stateId, state);
+
+            const currentValues = state._parameters.getValues();
+            const schemaOption = requireSchema ? schema : null;
+
+            client.transport.emit(
+              CREATE_RESPONSE,
+              reqId, stateId, remoteId, schemaName, schemaOption, currentValues,
+            );
+
+            const isObservable = this[kIsObservableState](state);
+
+            if (isObservable) {
+              this._observers.forEach(observer => {
+                observer.transport.emit(OBSERVE_NOTIFICATION, schemaName, stateId, nodeId);
+              });
+            }
+          } catch (err) {
+            const msg = `[stateManager] Cannot create state "${schemaName}", ${err.message}`;
+            console.error(msg);
+
+            client.transport.emit(CREATE_ERROR, reqId, msg);
+          }
+        } else {
+          const msg = `[stateManager] Cannot create state "${schemaName}", schema does not exists`;
+          console.error(msg);
+
+          client.transport.emit(CREATE_ERROR, reqId, msg);
         }
-      } else {
-        const msg = `Cannot create state "${schemaName}", schema does not exists`;
-        console.error(msg);
-        client.transport.emit(CREATE_ERROR, reqId, msg);
-      }
-    });
+      },
+    );
 
     // ---------------------------------------------
     // ATTACH (when creator, is attached by default)
     // ---------------------------------------------
-    client.transport.addListener(ATTACH_REQUEST, (reqId, schemaName, stateId = null, requireSchema = true) => {
-      if (this._schemas.has(schemaName)) {
-        let state = null;
-
-        if (stateId !== null && this._serverStatesById.has(stateId)) {
-          state = this._serverStatesById.get(stateId);
-        } else if (stateId === null) {
-          // if no `stateId` given, we try to find the first state with the given
-          // `schemaName` in the list, this allow a client to attach to a global
-          // state created by the server (or some persistant client) without
-          // having to know the `stateId` (e.g. some global state...)
-          for (let existingState of this._serverStatesById.values()) {
-            if (existingState.schemaName === schemaName) {
-              state = existingState;
-              break;
+    client.transport.addListener(
+      ATTACH_REQUEST,
+      (reqId, schemaName, stateId = null, requireSchema = true, filter = null) => {
+        if (this._schemas.has(schemaName)) {
+          let state = null;
+
+          if (stateId !== null && this._sharedStatePrivateById.has(stateId)) {
+            state = this._sharedStatePrivateById.get(stateId);
+          } else if (stateId === null) {
+            // if no `stateId` given, we try to find the first state with the given
+            // `schemaName` in the list, this allow a client to attach to a global
+            // state created by the server (or some persistant client) without
+            // having to know the `stateId` (e.g. some global state...)
+            for (let existingState of this._sharedStatePrivateById.values()) {
+              if (existingState.schemaName === schemaName) {
+                state = existingState;
+                break;
+              }
             }
           }
-        }
 
-        if (state !== null) {
-          // @note - we use a unique remote id to allow a client to attach
-          // several times to the same state.
-          // i.e. same state -> several remote attach on the same node
-          const remoteId = generateRemoteId.next().value;
-          const schema = this._schemas.get(schemaName);
-          const currentValues = state._parameters.getValues();
-
-          state._attachClient(remoteId, client, false);
-          // send schema for client-side instanciation
-          const sendedSchema = requireSchema ? schema : null;
-          client.transport.emit(ATTACH_RESPONSE, reqId, state.id, remoteId, schemaName, sendedSchema, currentValues);
+          if (state !== null) {
+            // @note - we use a unique remote id to allow a client to attach
+            // several times to the same state.
+            // i.e. same state -> several remote attach on the same node
+            const remoteId = generateRemoteId.next().value;
+            const isOwner = false;
+            const currentValues = state._parameters.getValues();
+            const schema = this._schemas.get(schemaName);
+            const schemaOption = requireSchema ? schema : null;
+
+            // if filter given, check that all filter entries are valid schema keys
+            // @todo - improve error reportin: report invalid filters
+            if (filter !== null) {
+              const keys = Object.keys(schema);
+              const isValid = filter.reduce((acc, key) => acc && keys.includes(key), true);
+
+              if (!isValid) {
+                const msg = `[stateManager] Cannot attach, invalid filter (${filter.join(', ')}) for schema "${schemaName}"`;
+                console.error(msg);
+
+                return client.transport.emit(ATTACH_ERROR, reqId, msg);
+              }
+            }
+
+            state._attachClient(remoteId, client, isOwner, filter);
+
+            client.transport.emit(
+              ATTACH_RESPONSE,
+              reqId, state.id, remoteId, schemaName, schemaOption, currentValues, filter,
+            );
+
+          } else {
+            const msg = `[stateManager] Cannot attach, no existing state for schema "${schemaName}" with stateId: "${stateId}"`;
+            console.error(msg);
+
+            client.transport.emit(ATTACH_ERROR, reqId, msg);
+          }
         } else {
-          const msg = `Cannot attach, no existing state for schema "${schemaName}" with stateId: "${stateId}"`;
-          client.transport.emit(ATTACH_ERROR, reqId, msg);
+          const msg = `[stateManager] Cannot attach, schema "${schemaName}" does not exists`;
           console.error(msg);
+
+          client.transport.emit(ATTACH_ERROR, reqId, msg);
         }
-      } else {
-        const msg = `Cannot attach, schema "${schemaName}" does not exists`;
-        client.transport.emit(ATTACH_ERROR, reqId, msg);
-        console.error(msg);
-      }
-    });
+      },
+    );
 
     // ---------------------------------------------
     // OBSERVE PEERS (be notified when a state is created, lazy)
     // ---------------------------------------------
-    client.transport.addListener(OBSERVE_REQUEST, reqId => {
-      const statesInfos = [];
-
-      this._serverStatesById.forEach(state => {
-        const { schemaName, id, _creatorId } = state;
-        // only track application states
-        // (e.g. do not propagate infos about audit state)
-        if (!PRIVATE_STATES.includes(schemaName)) {
-          statesInfos.push([schemaName, id, _creatorId]);
-        }
-      });
+    client.transport.addListener(OBSERVE_REQUEST, (reqId, observedSchemaName) => {
+      if (observedSchemaName === null || this._schemas.has(observedSchemaName)) {
+        const statesInfos = [];
 
-      // add client to observers first because if some (sync) server side
-      // callback throws, the client would never be added to the list
-      this._observers.add(client);
+        this._sharedStatePrivateById.forEach(state => {
+          const isObservable = this[kIsObservableState](state);
 
-      client.transport.emit(OBSERVE_RESPONSE, reqId, ...statesInfos);
+          if (isObservable) {
+            const { schemaName, id, _creatorId } = state;
+            statesInfos.push([schemaName, id, _creatorId]);
+          }
+        });
+
+        // add client to observers first because if some synchronous server side
+        // callback throws, the client would never be added to the list
+        this._observers.add(client);
+
+        client.transport.emit(OBSERVE_RESPONSE, reqId, ...statesInfos);
+      } else {
+        const msg = `[stateManager] Cannot observe, schema "${observedSchemaName}" does not exists`;
+        client.transport.emit(OBSERVE_ERROR, reqId, msg);
+      }
     });
 
     client.transport.addListener(UNOBSERVE_NOTIFICATION, () => {
       this._observers.delete(client);
     });
+
+    // ---------------------------------------------
+    // GET SCHEMA
+    // ---------------------------------------------
+    client.transport.addListener(GET_SCHEMA_REQUEST, (reqId, schemaName) => {
+      if (this._schemas.has(schemaName)) {
+        const schema = this._schemas.get(schemaName);
+        client.transport.emit(GET_SCHEMA_RESPONSE, reqId, schemaName, schema);
+      } else {
+        const msg = `[stateManager] Cannot get schema, schema "${schemaName}" does not exists`;
+        client.transport.emit(GET_SCHEMA_ERROR, reqId, msg);
+      }
+    });
   }
 
   /**
@@ -455,18 +529,22 @@ class StateManager extends BaseStateManager {
    * @private
    */
   removeClient(nodeId) {
-    for (let [_id, state] of this._serverStatesById.entries()) {
+    for (let [_id, state] of this._sharedStatePrivateById.entries()) {
       let deleteState = false;
 
       // define if the client is the creator of the state, in which case
       // everybody must delete it
-      for (let [remoteId, attachedClient] of state._attachedClients.entries()) {
+      for (let [remoteId, clientInfos] of state._attachedClients) {
+        const attachedClient = clientInfos.client;
+
         if (nodeId === attachedClient.id && remoteId === state._creatorRemoteId) {
           deleteState = true;
         }
       }
 
-      for (let [remoteId, attachedClient] of state._attachedClients.entries()) {
+      for (let [remoteId, clientInfos] of state._attachedClients) {
+        const attachedClient = clientInfos.client;
+
         if (nodeId === attachedClient.id) {
           state._detachClient(remoteId, attachedClient);
         }
@@ -477,7 +555,7 @@ class StateManager extends BaseStateManager {
             attachedClient.transport.emit(`${DELETE_NOTIFICATION}-${state.id}-${remoteId}`);
           }
 
-          this._serverStatesById.delete(state.id);
+          this._sharedStatePrivateById.delete(state.id);
         }
       }
     }
@@ -514,10 +592,18 @@ class StateManager extends BaseStateManager {
    * })
    */
   registerSchema(schemaName, schema) {
+    if (!isString(schemaName)) {
+      throw new Error(`[stateManager.registerSchema] Invalid schema name "${schemaName}", should be a string`);
+    }
+
     if (this._schemas.has(schemaName)) {
       throw new Error(`[stateManager.registerSchema] cannot register schema with name: "${schemaName}", schema name already exists`);
     }
 
+    if (!isPlainObject(schema)) {
+      throw new Error(`[stateManager.registerSchema] Invalid schema, should be an object`);
+    }
+
     ParameterBag.validateSchema(schema);
 
     this._schemas.set(schemaName, clonedeep(schema));
@@ -536,14 +622,15 @@ class StateManager extends BaseStateManager {
    */
   deleteSchema(schemaName) {
     // @note: deleting schema
-    for (let [_id, state] of this._serverStatesById.entries()) {
+    for (let [_id, state] of this._sharedStatePrivateById) {
       if (state.schemaName === schemaName) {
-        for (let [remoteId, attached] of state._attachedClients.entries()) {
+        for (let [remoteId, clientInfos] of state._attachedClients) {
+          const attached = clientInfos.client;
           state._detachClient(remoteId, attached);
           attached.transport.emit(`${DELETE_NOTIFICATION}-${state.id}-${remoteId}`);
         }
 
-        this._serverStatesById.delete(this.id);
+        this._sharedStatePrivateById.delete(state.id);
       }
     }