@soundworks/core 4.0.0-alpha.19 → 4.0.0-alpha.20

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## v4.0.0-alpha.20 - 19/02/2024
+
+- Refactor heartbeat - #86
+- Refactor state collection - #85
+- Fix issue with self signed certs and config generated by wizard - #84
+
 ## v4.0.0-alpha.19 - 17/01/2024
 
 - Hotfix for #85

package/README.md

@@ -24,7 +24,7 @@ npx @soundworks/create@latest
 
 ![soundworks-create](./misc/assets/soundworks-create-min.gif)
 
-See [https://soundworks.dev/tutorials/getting-started.html](https://soundworks.dev/tutorials/getting-started.html) for more informations on the wizard and how to start using **soundworks**.
+See [https://soundworks.dev/tutorials/getting-started.html](https://soundworks.dev/tutorials/getting-started.html) for more information on the wizard and how to start using **soundworks**.
 
 ## Misc
 
@@ -36,7 +36,7 @@ However, for maintenance reasons, we aim at following the TC39 and W3C specifica
 
 ### Manual install
 
-Note that the `@soundworks/core` package is automatically installed when creating an application using the `@soundworks/create` wizard, so most of the time you should not have to install this package manually. See [https://soundworks.dev/guides/getting-started.html](https://soundworks.dev/guides/getting-started.html) for more informations on the **soundworks** wizard.
+Note that the `@soundworks/core` package is automatically installed when creating an application using the `@soundworks/create` wizard, so most of the time you should not have to install this package manually. See [https://soundworks.dev/guides/getting-started.html](https://soundworks.dev/guides/getting-started.html) for more information on the **soundworks** wizard.
 
 ```
 npm install @soundworks/core

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soundworks/core",
-  "version": "4.0.0-alpha.19",
+  "version": "4.0.0-alpha.20",
   "description": "Open-source creative coding framework for distributed applications based on Web technologies",
   "authors": [
     "Benjamin Matuszewski",

package/src/client/Socket.js

@@ -1,13 +1,19 @@
 import { isBrowser } from '@ircam/sc-utils';
 import WebSocket from 'isomorphic-ws';
 
+import {
+  PING_INTERVAL,
+  PING_LATENCY_TOLERANCE,
+  PING_MESSAGE,
+  PONG_MESSAGE,
+} from '../common/constants.js';
+import logger from '../common/logger.js';
 import {
   packBinaryMessage,
   unpackBinaryMessage,
   packStringMessage,
   unpackStringMessage,
 } from '../common/sockets-utils.js';
-import logger from '../common/logger.js';
 
 // WebSocket events:
 //
@@ -64,6 +70,8 @@ class Socket {
     this._stringListeners = new Map();
     /** @private */
     this._binaryListeners = new Map();
+    /** @private */
+    this._heartbeatId = null;
   }
 
   /**
@@ -130,20 +138,51 @@ class Socket {
         ws.addEventListener('open', connectEvent => {
           // parse incoming messages for pubsub
           this.ws = ws;
+          // ping / pong to check connection
+          const heartbeat = () => {
+            clearTimeout(this._heartbeatId);
+
+            this._heartbeatId = setTimeout(() => {
+              this.terminate();
+            }, PING_INTERVAL + PING_LATENCY_TOLERANCE);
+          };
+
+          heartbeat();
+
           this.ws.addEventListener('message', e => {
+            if (e.data === PING_MESSAGE) {
+              heartbeat();
+              this.ws.send(PONG_MESSAGE);
+              // do not propagate ping / pong messages
+              return;
+            }
+
             const [channel, args] = unpackStringMessage(e.data);
             this._emit(false, channel, ...args);
           });
 
           // broadcast all `WebSocket` native events
-          ['close', 'error', 'upgrade', 'message'].forEach(eventName => {
-            this.ws.addEventListener(eventName, (e) => {
-              this._emit(false, eventName, e);
-            });
+          this.ws.addEventListener('close', (e) => {
+            clearTimeout(this._heartbeatId);
+            this._emit(false, 'close', e);
+          });
+
+          this.ws.addEventListener('error', (e) => {
+            clearTimeout(this._heartbeatId);
+            this._emit(false, 'error', e);
+          });
+
+          this.ws.addEventListener('upgrade', (e) => {
+            this._emit(false, 'upgrade', e);
+          });
+
+          this.ws.addEventListener('message', (e) => {
+            this._emit(false, 'message', e);
           });
 
           // forward open event
           this._emit(false, 'open', connectEvent);
+
           // continue with raw socket
           resolve();
         });
@@ -173,36 +212,6 @@ class Socket {
       trySocket();
     });
 
-    // @todo - review/fix
-    // - the `ws.on` method only exists on node implementation, and the 'ping'
-    //   message is not received on addEventListener
-    // - there seems to be no way to access the ping event in browsers...
-    //
-    // let pingTimeoutId = null;
-    // const pingInterval = config.env.websockets.pingInterval;
-    // // detect broken connection
-    // // cf. https://github.com/websockets/ws#how-to-detect-and-close-broken-connections
-    // const heartbeat = () => {
-    //   try {
-    //     console.log('ping received');
-    //     clearTimeout(pingTimeoutId);
-
-    //   // pingTimeoutId = setTimeout(() => {
-    //   //   console.log('terminate');
-    //   //   this.terminate();
-    //   // }, pingInterval + 2000);
-    //   } catch (err) {
-    //     console.error(err);
-    //   }
-    // };
-    //
-    // this.ws.on('ping', heartbeat);
-    // this.ws.addEventListener('close', () => {
-    //   clearTimeout(pingTimeoutId);
-    // });
-
-    // heartbeat();
-
     // ----------------------------------------------------------
     // init binary socket
     // ----------------------------------------------------------

package/src/common/BaseSharedStateCollection.js

@@ -1,8 +1,3 @@
-import {
-  kCreateCollectionController,
-  kAttachInCollection,
-} from './BaseStateManager.js';
-
 /** @private */
 class BaseSharedStateCollection {
   constructor(stateManager, schemaName, options = {}) {
@@ -10,7 +5,7 @@ class BaseSharedStateCollection {
     this._schemaName = schemaName;
     this._options = Object.assign({ excludeLocal: false }, options);
 
-    this._controller = null;
+    this._schema = null;
     this._states = [];
 
     this._onUpdateCallbacks = new Set();
@@ -21,15 +16,10 @@ class BaseSharedStateCollection {
 
   /** @private */
   async _init() {
-    this._controller = await this._stateManager[kCreateCollectionController](this._schemaName);
-    this._controller.onUpdate(async (updates, context) => {
-      for (let state of this._states) {
-        await state._commit(updates, context, true, false);
-      }
-    });
+    this._schema = await this._stateManager.getSchema(this._schemaName);
 
     this._unobserve = await this._stateManager.observe(this._schemaName, async (schemaName, stateId) => {
-      const state = await this._stateManager[kAttachInCollection](schemaName, stateId);
+      const state = await this._stateManager.attach(schemaName, stateId);
       this._states.push(state);
 
       state.onDetach(() => {
@@ -52,6 +42,7 @@ class BaseSharedStateCollection {
   /**
    * Size of the collection, alias `size`
    * @type {number}
+   * @readonly
    */
   get length() {
     return this._states.length;
@@ -60,6 +51,7 @@ class BaseSharedStateCollection {
   /**
    * Size of the collection, , alias `length`
    * @type {number}
+   * @readonly
    */
   get size() {
     return this._states.length;
@@ -71,7 +63,7 @@ class BaseSharedStateCollection {
    * @readonly
    */
   get schemaName() {
-    return this._controller.schemaName;
+    return this._schemaName;
   }
 
   /**
@@ -86,7 +78,11 @@ class BaseSharedStateCollection {
    * const schema = collection.getSchema();
    */
   getSchema(name = null) {
-    return this._controller.getSchema(name);
+    if (name) {
+      return this._schema[name];
+    }
+
+    return this._schema;
   }
 
   /**
@@ -97,7 +93,11 @@ class BaseSharedStateCollection {
    * const defaults = state.getDefaults();
    */
   getDefaults() {
-    return this._controller.getDefaults();
+    const defaults = {};
+    for (let name in this._schema) {
+      defaults[name] = this._schema[name].default;
+    }
+    return defaults;
   }
 
   /**
@@ -130,7 +130,6 @@ class BaseSharedStateCollection {
     // to be cleaned soon
     const promises = this._states.map(state => state.set(updates, context));
     return Promise.all(promises);
-    // return await this._controller.set(updates, context);
   }
 
   /**
@@ -199,8 +198,6 @@ class BaseSharedStateCollection {
     this._unobserve();
     this._onUpdateCallbacks.clear();
 
-    await this._controller.delete();
-
     const promises = this._states.map(state => state.detach());
     await Promise.all(promises);
 

package/src/common/BaseStateManager.js

@@ -2,6 +2,7 @@ import { isString, isFunction, isPlainObject } from '@ircam/sc-utils';
 import SharedState from './BaseSharedState.js';
 import SharedStateCollection from './BaseSharedStateCollection.js';
 import BatchedTransport from './BatchedTransport.js';
+import ParameterBag from './ParameterBag.js';
 import PromiseStore from './PromiseStore.js';
 import {
   CREATE_REQUEST,
@@ -16,11 +17,11 @@ import {
   OBSERVE_NOTIFICATION,
   UNOBSERVE_NOTIFICATION,
   DELETE_SCHEMA,
+  GET_SCHEMA_REQUEST,
+  GET_SCHEMA_RESPONSE,
+  GET_SCHEMA_ERROR,
 } from './constants.js';
 
-export const kCreateCollectionController = Symbol('BaseStateManager::createCollectionController');
-export const kAttachInCollection = Symbol('BaseStateManager::attachInCollection');
-
 /**
  * @private
  */
@@ -150,6 +151,22 @@ class BaseStateManager {
     this.client.transport.addListener(DELETE_SCHEMA, schemaName => {
       this._cachedSchemas.delete(schemaName);
     });
+
+    // ---------------------------------------------
+    // GET SCHEMA
+    // ---------------------------------------------
+    this.client.transport.addListener(GET_SCHEMA_RESPONSE, (reqId, schemaName, schema) => {
+      if (!this._cachedSchemas.has(schemaName)) {
+        this._cachedSchemas.set(schemaName, schema);
+      }
+      // return a populated schema
+      const parameterBag = new ParameterBag(schema);
+      this._promiseStore.resolve(reqId, parameterBag.getSchema());
+    });
+
+    this.client.transport.addListener(GET_SCHEMA_ERROR, (reqId, msg) => {
+      this._promiseStore.reject(reqId, msg);
+    });
   }
 
   /** @private */
@@ -167,6 +184,28 @@ class BaseStateManager {
     return filter;
   }
 
+  /**
+   * Return the schema from a given registered schema name
+   *
+   * @param {String} schemaName - Name of the schema as given on registration
+   *  (cf. ServerStateManager)
+   * @example
+   * const schema = await client.stateManager.getSchema('my-schema');
+   */
+  async getSchema(schemaName) {
+    if (this._cachedSchemas.has(schemaName)) {
+      const schema = this._cachedSchemas.get(schemaName);
+      // return a populated schema
+      const parameterBag = new ParameterBag(schema);
+      return parameterBag.getSchema();
+    }
+
+    return new Promise((resolve, reject) => {
+      const reqId = this._promiseStore.add(resolve, reject, 'get-schema');
+      this.client.transport.emit(GET_SCHEMA_REQUEST, reqId, schemaName);
+    });
+  }
+
   /**
    * Create a `SharedState` instance from a registered schema.
    *
@@ -187,18 +226,6 @@ class BaseStateManager {
     });
   }
 
-
-  /**
-   * @private
-   */
-  async [kCreateCollectionController](schemaName) {
-    return new Promise((resolve, reject) => {
-      const reqId = this._promiseStore.add(resolve, reject, 'create-collection-controller-request');
-      const requireSchema = this._cachedSchemas.has(schemaName) ? false : true;
-      this.client.transport.emit(CREATE_REQUEST, reqId, schemaName, requireSchema, {}, true);
-    });
-  }
-
   /**
    * Attach to an existing `SharedState` instance.
    *
@@ -221,14 +248,6 @@ class BaseStateManager {
     });
   }
 
-  async [kAttachInCollection](schemaName, stateId) {
-    return new Promise((resolve, reject) => {
-      const reqId = this._promiseStore.add(resolve, reject, 'attach-in-collection-request');
-      const requireSchema = this._cachedSchemas.has(schemaName) ? false : true;
-      this.client.transport.emit(ATTACH_REQUEST, reqId, schemaName, stateId, requireSchema, true);
-    });
-  }
-
   /**
    * Observe all the `SharedState` instances that are created on the network.
    * This can be usefull for clients with some controller role that might want to track
@@ -391,7 +410,7 @@ class BaseStateManager {
       await collection._init();
     } catch (err) {
       console.log(err.message);
-      throw new Error(`Cannot create collection, schema "${schemaName}" does not exists`);
+      throw new Error(`[stateManager] Cannot create collection, schema "${schemaName}" does not exists`);
     }
 
     return collection;

package/src/common/ParameterBag.js

@@ -226,7 +226,6 @@ class ParameterBag {
 
       this._schema[name].initValue = initValue;
       this._values[name] = initValue;
-
     }
   }
 

package/src/common/SharedStatePrivate.js

@@ -14,13 +14,13 @@ import {
 /**
  * The "real" state, this instance is kept private by the server.StateManager.
  * It can only be accessed through a SharedState proxy.
+ *
  * @private
  */
 class SharedStatePrivate {
   constructor(id, schemaName, schema, manager, initValues = {}) {
     this.id = id;
     this.schemaName = schemaName;
-    this.isCollectionController = false;
 
     this._manager = manager;
     this._parameters = new ParameterBag(schema, initValues);
@@ -30,16 +30,11 @@ class SharedStatePrivate {
     this._creatorId = null;
   }
 
-  _attachClient(remoteId, client, isOwner = false, inCollection = false) {
-
-    // isOwner && inCollection  -> collection controller
-    // !isOwner && inCollection -> attached in collection
-
-    const clientInfos = { client, isOwner, inCollection };
+  _attachClient(remoteId, client, isOwner = false) {
+    const clientInfos = { client, isOwner };
     this._attachedClients.set(remoteId, clientInfos);
 
     if (isOwner) {
-      this.isCollectionController = inCollection;
       this._creatorRemoteId = remoteId;
       this._creatorId = client.id;
     }
@@ -87,96 +82,63 @@ class SharedStatePrivate {
         }
 
         if (hasUpdates) {
-
-          // Collection controller logic
-          if (isOwner && inCollection) {
-            // notify the collection controller back
+          // Normal case
+          //
+          // We need to handle cases where:
+          // - client state (client.id: 2) sends a request
+          // - server attached state (client.id: -1) spot a problem and overrides the value
+          // We want the remote client (id: 2) to receive in the right order:
+          // * 1. the value it requested,
+          // * 2. the value overriden by the server-side attached state (id: -1)
+          //
+          // such problem is now better solved with the the upateHook system, none
+          // nonetheway we don't want to introduce inconsistencies here
+          //
+          // Then we propagate server-side last, because as the server transport
+          // is synchronous it can break ordering if a subscription function makes
+          // itself an update in reaction to an update. Propagating to server last
+          // alllows to maintain network messages order consistent.
+          //
+          // @note - remoteId correspond to unique remote state id
+
+          // propagate RESPONSE to the client that originates the request if not the server
+          if (client.id !== -1) {
             client.transport.emit(
               `${UPDATE_RESPONSE}-${this.id}-${remoteId}`,
               reqId, filteredUpdates, context,
             );
+          }
 
-            // loop through all private states
-            for (let [_stateId, state] of this._manager._sharedStatePrivateById) {
-              // pick all states with same schema name and not this
-              if (state !== this && this.schemaName === state.schemaName) {
-                // notify all attached clients except those who belong to a collection
-                // i.e. !isOwner && inCollection, they will be notified by their own
-                // collection controller
-                for (let [remoteId, clientInfos] of state._attachedClients) {
-                  if (!clientInfos.isOwner && clientInfos.inCollection) {
-                    continue;
-                  } else {
-                    const peer = clientInfos.client;
-
-                    peer.transport.emit(
-                      `${UPDATE_NOTIFICATION}-${state.id}-${remoteId}`,
-                      filteredUpdates, context,
-                    );
-                  }
-                }
-              }
-            }
-          } else {
+          // propagate NOTIFICATION to all other attached clients except server
+          for (let [peerRemoteId, clientInfos] of this._attachedClients) {
+            const peer = clientInfos.client;
 
-            // Normal case
-            //
-            // We need to handle cases where:
-            // - client state (client.id: 2) sends a request
-            // - server attached state (client.id: -1) spot a problem and overrides the value
-            // We want the remote client (id: 2) to receive in the right order:
-            // * 1. the value it requested,
-            // * 2. the value overriden by the server-side attached state (id: -1)
-            //
-            // such problem is now better solved with the the upateHook system, none
-            // nonetheway we don't want to introduce inconsistencies here
-            //
-            // Then we propagate server-side last, because as the server transport
-            // is synchronous it can break ordering if a subscription function makes
-            // itself an update in reaction to an update. Propagating to server last
-            // alllows to maintain network messages order consistent.
-            //
-            // @note - remoteId correspond to unique remote state id
-
-            // propagate RESPONSE to the client that originates the request if not the server
-            if (client.id !== -1) {
-              client.transport.emit(
-                `${UPDATE_RESPONSE}-${this.id}-${remoteId}`,
-                reqId, filteredUpdates, context,
+            if (remoteId !== peerRemoteId && peer.id !== -1) {
+              peer.transport.emit(
+                `${UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`,
+                filteredUpdates, context,
               );
             }
+          }
 
-            // propagate NOTIFICATION to all other attached clients except server
-            for (let [peerRemoteId, clientInfos] of this._attachedClients) {
-              const peer = clientInfos.client;
+          // propagate RESPONSE to server if it is the requester
+          if (client.id === -1) {
+            client.transport.emit(
+              `${UPDATE_RESPONSE}-${this.id}-${remoteId}`,
+              reqId, filteredUpdates, context,
+            );
+          }
 
-              if (remoteId !== peerRemoteId && peer.id !== -1) {
-                peer.transport.emit(
-                  `${UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`,
-                  filteredUpdates, context,
-                );
-              }
-            }
+          // propagate NOTIFICATION other attached state that belongs to server
+          for (let [peerRemoteId, clientInfos] of this._attachedClients) {
+            const peer = clientInfos.client;
 
-            // propagate RESPONSE to server if it is the requester
-            if (client.id === -1) {
-              client.transport.emit(
-                `${UPDATE_RESPONSE}-${this.id}-${remoteId}`,
-                reqId, filteredUpdates, context,
+            if (remoteId !== peerRemoteId && peer.id === -1) {
+              peer.transport.emit(
+                `${UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`,
+                filteredUpdates, context,
               );
             }
-
-            // propagate NOTIFICATION other attached state that belongs to server
-            for (let [peerRemoteId, clientInfos] of this._attachedClients) {
-              const peer = clientInfos.client;
-
-              if (remoteId !== peerRemoteId && peer.id === -1) {
-                peer.transport.emit(
-                  `${UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`,
-                  filteredUpdates, context,
-                );
-              }
-            }
           }
         } else {
           // propagate back to the requester that the update has been aborted

package/src/common/constants.js

@@ -1,6 +1,11 @@
 // id of the server when owner of a state
 export const SERVER_ID = -1;
 
+export const PING_INTERVAL = 10 * 1000;
+export const PING_LATENCY_TOLERANCE = 1000;
+export const PING_MESSAGE = 'h:ping';
+export const PONG_MESSAGE = 'h:pong';
+
 // batched transport channel
 export const BATCHED_TRANSPORT_CHANNEL = 'b:t';
 
@@ -36,6 +41,10 @@ export const UPDATE_NOTIFICATION = 's:u:not';
 
 export const DELETE_SCHEMA = 's:d:s';
 
+export const GET_SCHEMA_REQUEST = 's:s:req';
+export const GET_SCHEMA_RESPONSE = 's:s:res';
+export const GET_SCHEMA_ERROR = 's:s:err';
+
 // context channels
 export const CONTEXT_ENTER_REQUEST = 'c:en:req';
 export const CONTEXT_ENTER_RESPONSE = 'c:en:res';

package/src/server/Server.js

@@ -9,6 +9,7 @@ import { isPlainObject, idGenerator, getTime } from '@ircam/sc-utils';
 import chalk from 'chalk';
 import compression from 'compression';
 import express from 'express';
+import equal from 'fast-deep-equal';
 import Keyv from 'keyv';
 import { KeyvFile } from 'keyv-file';
 import merge from 'lodash/merge.js';
@@ -214,11 +215,11 @@ class Server {
         throw new Error(`[soundworks:Server] Invalid "env.httpsInfos" config, should contain both "cert" and "key" entries`);
       }
       // @todo - move that to constructor
-      if (!fs.existsSync(httpsInfos.cert)) {
+      if (httpsInfos.cert !== null && !fs.existsSync(httpsInfos.cert)) {
         throw new Error(`[soundworks:Server] Invalid "env.httpsInfos" config, "cert" file not found`);
       }
 
-      if (!fs.existsSync(httpsInfos.key)) {
+      if (httpsInfos.key !== null && !fs.existsSync(httpsInfos.key)) {
         throw new Error(`[soundworks:Server] Invalid "env.httpsInfos" config, "key" file not found`);
       }
     }
@@ -444,19 +445,22 @@ class Server {
       this.router.use(soundworksAuth);
     }
 
-    // start http server
-    const useHttps = this.config.env.useHttps || false;
-
     // ------------------------------------------------------------
     // create HTTP(S) SERVER
     // ------------------------------------------------------------
+    const useHttps = this.config.env.useHttps || false;
+
     if (!useHttps) {
       this.httpServer = http.createServer(this.router);
     } else {
       const httpsInfos = this.config.env.httpsInfos;
+      let useSelfSigned = false;
+
+      if (!httpsInfos || equal(httpsInfos, { cert: null, key: null })) {
+        useSelfSigned = true;
+      }
 
-      // if certs have been given in config
-      if (httpsInfos !== null) {
+      if (!useSelfSigned) {
         try {
           // existance of file is checked in contructor
           let cert = fs.readFileSync(httpsInfos.cert);

package/src/server/Socket.js

@@ -1,4 +1,9 @@
 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,53 @@ 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);
+
+    // broadcast all "native" events
     [
       'close',
       'error',
@@ -107,14 +139,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 +161,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 +171,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/StateManager.js

@@ -22,6 +22,9 @@ import {
   OBSERVE_NOTIFICATION,
   UNOBSERVE_NOTIFICATION,
   DELETE_SCHEMA,
+  GET_SCHEMA_REQUEST,
+  GET_SCHEMA_RESPONSE,
+  GET_SCHEMA_ERROR,
   PRIVATE_STATES,
 } from '../common/constants.js';
 
@@ -355,7 +358,7 @@ class StateManager extends BaseStateManager {
     // ---------------------------------------------
     client.transport.addListener(
       CREATE_REQUEST,
-      (reqId, schemaName, requireSchema, initValues = {}, inCollection = false) => {
+      (reqId, schemaName, requireSchema, initValues = {}) => {
         if (this._schemas.has(schemaName)) {
           try {
             const schema = this._schemas.get(schemaName);
@@ -365,7 +368,7 @@ class StateManager extends BaseStateManager {
 
             // attach client to the state as owner
             const isOwner = true;
-            state._attachClient(remoteId, client, isOwner, inCollection);
+            state._attachClient(remoteId, client, isOwner);
 
             this._sharedStatePrivateById.set(stateId, state);
 
@@ -385,13 +388,13 @@ class StateManager extends BaseStateManager {
               });
             }
           } catch (err) {
-            const msg = `Cannot create state "${schemaName}", ${err.message}`;
+            const msg = `[stateManager] Cannot create state "${schemaName}", ${err.message}`;
             console.error(msg);
 
             client.transport.emit(CREATE_ERROR, reqId, msg);
           }
         } else {
-          const msg = `Cannot create state "${schemaName}", schema does not exists`;
+          const msg = `[stateManager] Cannot create state "${schemaName}", schema does not exists`;
           console.error(msg);
 
           client.transport.emit(CREATE_ERROR, reqId, msg);
@@ -404,7 +407,7 @@ class StateManager extends BaseStateManager {
     // ---------------------------------------------
     client.transport.addListener(
       ATTACH_REQUEST,
-      (reqId, schemaName, stateId = null, requireSchema = true, inCollection = false) => {
+      (reqId, schemaName, stateId = null, requireSchema = true) => {
         if (this._schemas.has(schemaName)) {
           let state = null;
 
@@ -429,7 +432,7 @@ class StateManager extends BaseStateManager {
             // i.e. same state -> several remote attach on the same node
             const remoteId = generateRemoteId.next().value;
             const isOwner = false;
-            state._attachClient(remoteId, client, isOwner, inCollection);
+            state._attachClient(remoteId, client, isOwner);
 
             const currentValues = state._parameters.getValues();
             const schema = this._schemas.get(schemaName);
@@ -441,13 +444,13 @@ class StateManager extends BaseStateManager {
             );
 
           } else {
-            const msg = `Cannot attach, no existing state for schema "${schemaName}" with stateId: "${stateId}"`;
+            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, schema "${schemaName}" does not exists`;
+          const msg = `[stateManager] Cannot attach, schema "${schemaName}" does not exists`;
           console.error(msg);
 
           client.transport.emit(ATTACH_ERROR, reqId, msg);
@@ -477,7 +480,7 @@ class StateManager extends BaseStateManager {
 
         client.transport.emit(OBSERVE_RESPONSE, reqId, ...statesInfos);
       } else {
-        const msg = `Cannot observe, schema "${observedSchemaName}" does not exists`;
+        const msg = `[stateManager] Cannot observe, schema "${observedSchemaName}" does not exists`;
         client.transport.emit(OBSERVE_ERROR, reqId, msg);
       }
     });
@@ -485,6 +488,19 @@ class StateManager extends BaseStateManager {
     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);
+      }
+    });
   }
 
   /**