@soundworks/core 3.7.0 → 4.0.0-alpha.0

package/{common → src/common}/SharedStatePrivate.js

@@ -1,18 +1,18 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _ParameterBag = _interopRequireDefault(require("./ParameterBag.js"));
-
-var _sharedStateUtils = require("./shared-state-utils");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+import ParameterBag from '../common/ParameterBag.js';
+import {
+  DELETE_REQUEST,
+  DELETE_RESPONSE,
+  DELETE_NOTIFICATION,
+  DETACH_REQUEST,
+  DETACH_RESPONSE,
+  UPDATE_REQUEST,
+  UPDATE_RESPONSE,
+  UPDATE_ABORT,
+  UPDATE_NOTIFICATION,
+} from '../common/constants.js';
 
 /**
- * The "real" state, this instance is kept private by the SharedStateServerManager.
+ * The "real" state, this instance is kept private by the server.StateManager.
  * It cannot be accessed without a SharedState proxy
  * @private
  */
@@ -20,8 +20,9 @@ class SharedStatePrivate {
   constructor(id, schemaName, schema, manager, initValues = {}) {
     this.id = id;
     this.schemaName = schemaName;
+
     this._manager = manager;
-    this._parameters = new _ParameterBag.default(schema, initValues);
+    this._parameters = new ParameterBag(schema, initValues);
     this._attachedClients = new Map(); // other peers interested in watching / controlling the state
 
     this._creatorRemoteId = null;
@@ -34,29 +35,25 @@ class SharedStatePrivate {
     if (isOwner) {
       this._creatorRemoteId = remoteId;
       this._creatorId = client.id;
-    } // attach client listeners
-
+    }
 
-    client.transport.addListener(`${_sharedStateUtils.UPDATE_REQUEST}-${this.id}-${remoteId}`, async (reqId, updates, context) => {
+    // attach client listeners
+    client.transport.addListener(`${UPDATE_REQUEST}-${this.id}-${remoteId}`, async (reqId, updates, context) => {
       // apply registered hooks
       const hooks = this._manager._hooksBySchemaName.get(this.schemaName);
-
       const values = this._parameters.getValues();
+      let hookAborted = false;
 
-      let hookAborted = false; // cf. https://github.com/collective-soundworks/soundworks/issues/45
-
+      // cf. https://github.com/collective-soundworks/soundworks/issues/45
       for (let hook of hooks.values()) {
         const result = await hook(updates, values, context);
 
-        if (result === null) {
-          // explicit abort if hook returns null
+        if (result === null) { // explicit abort if hook returns null
           hookAborted = true;
           break;
-        } else if (result === undefined) {
-          // implicit continue if hook returns undefined
+        } else if (result === undefined) { // implicit continue if hook returns undefined
           continue;
-        } else {
-          // the hook returned an updates object
+        } else { // the hook returned an updates object
           updates = result;
         }
       }
@@ -74,21 +71,18 @@ class SharedStatePrivate {
           //    objects as dirty, because if the state is attached locally, we
           //    compare the Object instances instead of their values.
           //    @note - this should be made more robust but how?
-          const [newValue, changed] = this._parameters.set(name, updates[name]); // if `filterChange` is set to `false` we don't check if the value
-          // has been changed or not, it is always propagated to client states
-
-
-          const {
-            event,
-            filterChange
-          } = this._parameters.getSchema(name); // if event type reset internal value to null
+          const [newValue, changed] = this._parameters.set(name, updates[name]);
 
+          // if `filterChange` is set to `false` we don't check if the value
+          // has been changed or not, it is always propagated to client states
+          const { event, filterChange } = this._parameters.getSchema(name);
 
+          // if event type reset internal value to null
           if (event) {
             this._parameters.set(name, null);
           }
 
-          if (filterChange && changed || !filterChange) {
+          if ((filterChange && changed) || !filterChange) {
             filteredUpdates[name] = newValue;
             hasUpdates = true;
           }
@@ -97,47 +91,51 @@ class SharedStatePrivate {
         if (hasUpdates) {
           // send response to requester
           // client.transport.emit(`${UPDATE_RESPONSE}-${this.id}-${remoteId}`, reqId, filteredUpdates);
+
           // @note: 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, therefore network messages
           // order would be broken,
+
           // 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)
+
           // this problem could be solved properly with a reducer system:
           // if (dirty) {
           //   -> call (async) reducer
           //   -> get values from reducer
           //.  -> dispatch to everybody
           // }
+
           for (let [peerRemoteId, peer] of this._attachedClients.entries()) {
             // propagate notification to all other attached clients except server
             if (remoteId !== peerRemoteId && peer.id !== -1) {
-              peer.transport.emit(`${_sharedStateUtils.UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`, filteredUpdates, context);
+              peer.transport.emit(`${UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`, filteredUpdates, context);
             }
           }
 
           if (client.id !== -1) {
-            client.transport.emit(`${_sharedStateUtils.UPDATE_RESPONSE}-${this.id}-${remoteId}`, reqId, filteredUpdates, context);
+            client.transport.emit(`${UPDATE_RESPONSE}-${this.id}-${remoteId}`, reqId, filteredUpdates, context);
           }
 
           for (let [peerRemoteId, peer] of this._attachedClients.entries()) {
             // propagate notification to server
             if (remoteId !== peerRemoteId && peer.id === -1) {
-              peer.transport.emit(`${_sharedStateUtils.UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`, filteredUpdates, context);
+              peer.transport.emit(`${UPDATE_NOTIFICATION}-${this.id}-${peerRemoteId}`, filteredUpdates, context);
             }
           }
 
           if (client.id === -1) {
-            client.transport.emit(`${_sharedStateUtils.UPDATE_RESPONSE}-${this.id}-${remoteId}`, reqId, filteredUpdates, context);
+            client.transport.emit(`${UPDATE_RESPONSE}-${this.id}-${remoteId}`, reqId, filteredUpdates, context);
           }
         } else {
           // propagate back to the requester that the update has been aborted
           // ignore all other attached clients.
-          client.transport.emit(`${_sharedStateUtils.UPDATE_ABORT}-${this.id}-${remoteId}`, reqId, updates, context);
+          client.transport.emit(`${UPDATE_ABORT}-${this.id}-${remoteId}`, reqId, updates, context);
         }
       } else {
         // retrieve values from inner state (also handle immediate approriately)
@@ -145,54 +143,50 @@ class SharedStatePrivate {
 
         for (let name in updates) {
           oldValues[name] = this._parameters.get(name);
-        } // aborted by hook (updates have been overriden to {})
-
-
-        client.transport.emit(`${_sharedStateUtils.UPDATE_ABORT}-${this.id}-${remoteId}`, reqId, oldValues, context);
+        }
+        // aborted by hook (updates have been overriden to {})
+        client.transport.emit(`${UPDATE_ABORT}-${this.id}-${remoteId}`, reqId, oldValues, context);
       }
     });
 
     if (isOwner) {
       // delete only if creator
-      client.transport.addListener(`${_sharedStateUtils.DELETE_REQUEST}-${this.id}-${remoteId}`, reqId => {
-        this._manager._serverStatesById.delete(this.id); // --------------------------------------------------------------------
+      client.transport.addListener(`${DELETE_REQUEST}-${this.id}-${remoteId}`, (reqId) => {
+        this._manager._serverStatesById.delete(this.id);
+        // --------------------------------------------------------------------
         // WARNING - MAKE SURE WE DON'T HAVE PROBLEM W/ THAT
         // --------------------------------------------------------------------
         // @todo - propagate server-side last, because if a subscription function sends a
         // message to a client, network messages order are kept coherent
         // this._subscriptions.forEach(func => func(updated));
-
-
         for (let [remoteId, attached] of this._attachedClients.entries()) {
           this._detachClient(remoteId, attached);
 
           if (remoteId === this._creatorRemoteId) {
-            attached.transport.emit(`${_sharedStateUtils.DELETE_RESPONSE}-${this.id}-${remoteId}`, reqId);
+            attached.transport.emit(`${DELETE_RESPONSE}-${this.id}-${remoteId}`, reqId);
           } else {
-            attached.transport.emit(`${_sharedStateUtils.DELETE_NOTIFICATION}-${this.id}-${remoteId}`);
+            attached.transport.emit(`${DELETE_NOTIFICATION}-${this.id}-${remoteId}`);
           }
         }
       });
     } else {
       // detach only if not creator
-      client.transport.addListener(`${_sharedStateUtils.DETACH_REQUEST}-${this.id}-${remoteId}`, reqId => {
+      client.transport.addListener(`${DETACH_REQUEST}-${this.id}-${remoteId}`, (reqId) => {
         this._detachClient(remoteId, client);
-
-        client.transport.emit(`${_sharedStateUtils.DETACH_RESPONSE}-${this.id}-${remoteId}`, reqId);
+        client.transport.emit(`${DETACH_RESPONSE}-${this.id}-${remoteId}`, reqId);
       });
     }
   }
 
   _detachClient(remoteId, client) {
-    this._attachedClients.delete(remoteId); // delete listeners
-
-
-    client.transport.removeAllListeners(`${_sharedStateUtils.UPDATE_REQUEST}-${this.id}-${remoteId}`);
-    client.transport.removeAllListeners(`${_sharedStateUtils.DELETE_REQUEST}-${this.id}-${remoteId}`);
-    client.transport.removeAllListeners(`${_sharedStateUtils.DETACH_REQUEST}-${this.id}-${remoteId}`);
+    this._attachedClients.delete(remoteId);
+    // delete listeners
+    client.transport.removeAllListeners(`${UPDATE_REQUEST}-${this.id}-${remoteId}`);
+    client.transport.removeAllListeners(`${DELETE_REQUEST}-${this.id}-${remoteId}`);
+    client.transport.removeAllListeners(`${DETACH_REQUEST}-${this.id}-${remoteId}`);
   }
-
 }
 
-var _default = SharedStatePrivate;
-exports.default = _default;
+export default SharedStatePrivate;
+
+

package/src/common/constants.js

@@ -0,0 +1,51 @@
+// id of the server when owner of a state
+export const SERVER_ID = -1;
+
+// shared states channels
+export const CREATE_REQUEST = 's:c:req';
+export const CREATE_RESPONSE = 's:c:res';
+export const CREATE_ERROR = 's:c:err';
+
+export const DELETE_REQUEST = 's:dl:req';
+export const DELETE_RESPONSE = 's:dl:res';
+export const DELETE_ERROR = 's:dl:err';
+export const DELETE_NOTIFICATION = 's:dl:not';
+
+export const ATTACH_REQUEST = 's:a:req';
+export const ATTACH_RESPONSE = 's:a:res';
+export const ATTACH_ERROR = 's:a:err';
+
+export const DETACH_REQUEST = 's:dt:req';
+export const DETACH_RESPONSE = 's:dt:res';
+export const DETACH_ERROR = 's:dt:err';
+
+export const OBSERVE_REQUEST = 's:o:req';
+export const OBSERVE_RESPONSE = 's:o:res';
+export const OBSERVE_NOTIFICATION = 's:o:not';
+
+export const UNOBSERVE_NOTIFICATION = 's:uo:not';
+
+export const UPDATE_REQUEST = 's:u:req';
+export const UPDATE_RESPONSE = 's:u:res';
+export const UPDATE_ABORT = 's:u:ab';
+export const UPDATE_NOTIFICATION = 's:u:not';
+
+export const DELETE_SCHEMA = 's:d:s';
+
+// context channels
+export const CONTEXT_ENTER_REQUEST = 'c:en:req';
+export const CONTEXT_ENTER_RESPONSE = 'c:en:res';
+export const CONTEXT_ENTER_ERROR = 'c:en:err';
+
+export const CONTEXT_EXIT_REQUEST = 'c:ex:req';
+export const CONTEXT_EXIT_RESPONSE = 'c:ex:res';
+export const CONTEXT_EXIT_ERROR = 'c:ex:err';
+
+// client handshake
+export const CLIENT_HANDSHAKE_REQUEST = 'cl:h:req';
+export const CLIENT_HANDSHAKE_RESPONSE = 'cl:h:res';
+export const CLIENT_HANDSHAKE_ERROR = 'cl:h:err';
+
+// audit state schema name
+export const AUDIT_STATE_NAME = 's:c:audit';
+export const PRIVATE_STATES = [AUDIT_STATE_NAME];

package/src/common/logger.js

@@ -0,0 +1,154 @@
+import chalk from 'chalk';
+import columnify from 'columnify';
+
+/**
+ * @private
+ */
+const logger = {
+  verbose: true,
+
+  configure(verbose) {
+    this.verbose = verbose;
+  },
+
+  title(msg) {
+    if (!this.verbose) {
+      return;
+    }
+
+
+    console.log(chalk.cyan(`+ ${msg}`));
+  },
+
+  clientConfigAndRouting(routes, config) {
+    if (!this.verbose) {
+      return;
+    }
+
+
+    const clientsConfig = config.app.clients;
+    const serverAddress = config.env.serverAddress;
+    const auth = config.env.auth;
+    const table = [];
+
+    for (let role in clientsConfig) {
+      const client = clientsConfig[role];
+
+      if (client.target === 'node') {
+        const line = {
+          role: `> ${role}`,
+          target: chalk.red(client.target),
+          path: `serverAddress: ${chalk.green(serverAddress)}`,
+          default: undefined,
+          auth: undefined,
+        };
+
+        table.push(line);
+      } else if (client.target === 'browser') {
+        const line = {
+          role: `> ${role}`,
+          target: chalk.red(client.target),
+          path: routes.find(r => r.role === role) ?
+            chalk.green(routes.find(r => r.role === role).path) :
+            chalk.red('no route defined'),
+          default: (client.default ? 'x' : undefined),
+          auth: auth && auth.clients.indexOf(role) !== -1 ? 'x' : undefined,
+        };
+
+        table.push(line);
+      } else {
+        console.log(`@warning: no target defined for client ${role}`);
+      }
+    }
+
+    console.log(``);
+    console.log(columnify(table, {
+      showHeaders: true,
+      minWidth: 6,
+      columnSplitter: ' | ',
+      config: {
+        default: { align: 'center' },
+        auth: { align: 'center' },
+      },
+    }));
+    console.log(``);
+
+    // check if a route is defined but not in config
+    if (clientsConfig) {
+      const configClientTypes = Object.keys(clientsConfig);
+      routes.forEach(r => {
+        if (configClientTypes.indexOf(r.role) === -1) {
+          console.log(`@warning: no client config found for route ${r.role}`);
+        }
+      });
+    } else {
+      console.log(`@warning: no config found for clients`);
+    }
+  },
+
+  ip(protocol, address, port) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.log(`    ${protocol}://${address}:${chalk.green(port)}`);
+  },
+
+  pluginStart(name) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.log(`    ${name} ${chalk.yellow('start...')}`);
+  },
+
+  pluginStarted(name) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.log(`    ${name} ${chalk.cyan('started')}`);
+  },
+
+  pluginReady(name) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.log(`    ${name} ${chalk.green('ready')}`);
+  },
+
+  pluginErrored(name) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.log(`    ${name} ${chalk.red('errors')}`);
+  },
+
+  log(msg) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.log(msg);
+  },
+
+  warn(msg) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.warn(chalk.yellow(msg));
+  },
+
+  error(msg) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.error(chalk.red(msg));
+  },
+};
+
+export default logger;

package/src/common/promise-store.js

@@ -0,0 +1,25 @@
+import { idGenerator } from './utils.js';
+
+const generateRequestId = idGenerator();
+const requestPromises = new Map();
+
+export function storeRequestPromise(resolve, reject) {
+  const reqId = generateRequestId.next().value;
+  requestPromises.set(reqId, { resolve, reject });
+
+  return reqId;
+}
+
+export function resolveRequest(reqId, data) {
+  const { resolve } = requestPromises.get(reqId);
+  requestPromises.delete(reqId);
+
+  resolve(data);
+}
+
+export function rejectRequest(reqId, data) {
+  const { reject } = requestPromises.get(reqId);
+  requestPromises.delete(reqId);
+
+  reject(data);
+}

package/src/common/sockets-utils.js

@@ -0,0 +1,73 @@
+import 'fast-text-encoding';
+import root from 'window-or-global';
+
+const encoder = new root.TextEncoder('utf-8');
+const decoder = new root.TextDecoder('utf-8');
+
+const types = [
+  'Int8Array',
+  'Uint8Array',
+  'Uint8ClampedArray',
+  'Int16Array',
+  'Uint16Array',
+  'Int32Array',
+  'Uint32Array',
+  'Float32Array',
+  'Float64Array',
+  'BigInt64Array',
+  'BigUint64Array',
+];
+
+// @note - probably some room for optimizations
+
+/** @private */
+export function packBinaryMessage(channel, data) {
+  const channelBuffer = encoder.encode(channel);
+  const channelSize = channelBuffer.byteLength;
+  const startOffset = Math.ceil((channelSize + 3) / data.BYTES_PER_ELEMENT) * data.BYTES_PER_ELEMENT;
+  const bufferSize = startOffset + data.byteLength;
+  const typeName = data.constructor.name;
+  const typeIndex = types.indexOf(typeName);
+
+  if (typeIndex === -1) {
+    throw new Error(`Invalid TypedArray type: ${typeName}`);
+  }
+
+  const view = new Uint8Array(bufferSize);
+  view[0] = channelSize;
+  view[1] = typeIndex;
+  view[2] = startOffset;
+
+  view.set(channelBuffer, 3, channelSize);
+  view.set(new Uint8Array(data.buffer), startOffset, data.byteLength);
+
+  return view.buffer;
+}
+
+/** @private */
+export function unpackBinaryMessage(buffer /* arraybuffer */) {
+  const infos = new Uint8Array(buffer, 0, 3);
+  const channelSize = infos[0];
+  const typeIndex = infos[1];
+  const startOffset = infos[2];
+
+  // need to slice as the library recreates a UInt8Array from the whole buffer
+  // @todo - see if this copy could be avoided (probably needs a pull request)
+  const channelBuffer = new Uint8Array(buffer.slice(3, 3 + channelSize));
+  const channel = decoder.decode(channelBuffer);
+  const type = types[typeIndex];
+  // slice (copy) the underlying ArrayBuffer to create a clean TypedArray
+  const data = new root[type](buffer.slice(startOffset));
+
+  return [channel, data];
+}
+
+/** @private */
+export function packStringMessage(channel, ...args) {
+  return JSON.stringify([channel, args]);
+}
+
+/** @private */
+export function unpackStringMessage(data) {
+  return JSON.parse(data);
+}

package/src/common/utils.js

@@ -0,0 +1,22 @@
+// https://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
+export const isBrowser = new Function('try {return this===window;}catch(e){ return false;}');
+
+export function* idGenerator() {
+  for (let i = 0; true; i++) {
+    if (i === Number.MAX_SAFE_INTEGER) {
+      i = 0;
+    }
+
+    yield i;
+  }
+}
+
+export function isString(val) {
+  return (typeof val === 'string' || val instanceof String);
+}
+
+export function isFunction(func) {
+  return Object.prototype.toString.call(func) == '[object Function]' ||
+    Object.prototype.toString.call(func) == '[object AsyncFunction]';
+}
+

package/src/server/Client.js

@@ -0,0 +1,50 @@
+import { v4 as uuid } from 'uuid';
+
+import { idGenerator } from '../common/utils.js';
+
+const generateId = idGenerator();
+
+/**
+ * Server-side representation of a `soundworks` client.
+ *
+ * @memberof server
+ * @hideconstructor
+ * @see {@link client.Client}
+ */
+class Client {
+  /**
+   * @param {String} role - Role of the client
+   * @param {server.Socket} socket - Socket connection with the client
+   */
+  constructor(role, socket) {
+    /**
+     * Client role, as specified in client side config {@link client.Client}.
+     *
+     * @type {String}
+     */
+    this.role = role;
+
+    /**
+     * Session Id (incremented positive number).
+     *
+     * @type {Number}
+     */
+    this.id = generateId.next().value;
+
+    /**
+     * Unique session Id (uuidv4).
+     *
+     * @type {String}
+     */
+    this.uuid = uuid();
+
+    /**
+     * Socket connection with the remote client {@link client.Client}.
+     *
+     * @type {server.Socket}
+     */
+    this.socket = socket;
+  }
+}
+
+export default Client;