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

package/src/client/Socket.js

@@ -2,34 +2,16 @@ 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';
 
-// WebSocket events:
-//
-// `close`:
-//   Fired when a connection with a websocket is closed.
-//   Also available via the onclose property
-// `error`:
-//   Fired when a connection with a websocket has been closed because of an error,
-//   such as whensome data couldn't be sent.
-//   Also available via the onerror property.
-// `message`:
-//   Fired when data is received through a websocket.
-//   Also available via the onmessage property.
-// `open`:
-//   Fired when a connection with a websocket is opened.
-//   Also available via the onopen property.
+export const kSocketTerminate = Symbol('soundworks:socket-terminate');
 
 /**
  * The Socket class is a simple publish / subscribe wrapper built on top of the
@@ -53,26 +35,10 @@ import {
  * @hideconstructor
  */
 class Socket {
-  constructor() {
-    /**
-     * WebSocket instance configured with `binaryType = 'blob'`.
-     *
-     * @private
-     */
-    this.ws = null;
-    /**
-     * WebSocket instance configured with `binaryType = 'arraybuffer'`.
-     *
-     * @private
-     */
-    this.binaryWs = null;
-    /** @private */
-    this._stringListeners = new Map();
-    /** @private */
-    this._binaryListeners = new Map();
-    /** @private */
-    this._heartbeatId = null;
-  }
+  #socket = null;
+  #listeners = new Map();
+
+  constructor() {}
 
   /**
    * Initialize a websocket connection with the server. Automatically called
@@ -80,114 +46,97 @@ class Socket {
    *
    * @param {string} role - Role of the client (see {@link client.Client#role})
    * @param {object} config - Configuration of the sockets
-   * @protected
-   * @ignore
+   * @private
    */
   async init(role, config) {
-    // unique key that allows to associate the two sockets to the same client.
-    // note: the key is only used to pair to two sockets, so its usage is very
-    // limited in time therefore a random number should hopefully be sufficient.
-    const key = (Math.random() + '').replace(/^0\./, '');
-
-    // open web sockets
     let { path } = config.env.websockets;
-
-    // @note: keep this check
-    // backward compatibility w/ assetsDomain and websocket old config way
     // cf. https://github.com/collective-soundworks/soundworks/issues/35
     if (config.env.subpath) {
       path = `${config.env.subpath}/${path}`;
     }
 
-    let url;
+    const protocol = config.env.useHttps ? 'wss:' : 'ws:';
+    const port = config.env.port;
+    let serverAddress;
     let webSocketOptions;
 
     if (isBrowser()) {
-      const protocol = window.location.protocol.replace(/^http?/, 'ws');
-      const { hostname, port } = window.location;
+      // if a server address is given in config, use it, else fallback to URL hostname
+      if (config.env.serverAddress !== '') {
+        serverAddress = config.env.serverAddress;
+      } else {
+        serverAddress = window.location.hostname;
+      }
 
-      url = `${protocol}//${hostname}:${port}/${path}`;
       webSocketOptions = [];
     } else {
-      const protocol = config.env.useHttps ? 'wss:' : 'ws:';
-      const { serverAddress, port } = config.env;
+      serverAddress = config.env.serverAddress;
 
-      url = `${protocol}//${serverAddress}:${port}/${path}`;
       webSocketOptions = {
         rejectUnauthorized: false,
       };
     }
 
-    let queryParams = `role=${role}&key=${key}`;
+    let queryParams = `role=${role}`;
 
     if (config.token) {
       queryParams += `&token=${config.token}`;
     }
 
+    const url = `${protocol}//${serverAddress}:${port}/${path}?${queryParams}`;
+
     // ----------------------------------------------------------
-    // init string socket
+    // Init socket
     // ----------------------------------------------------------
-    const stringSocketUrl = `${url}?binary=0&${queryParams}`;
-
-    await new Promise(resolve => {
+    return new Promise(resolve => {
       let connectionRefusedLogged = false;
 
       const trySocket = async () => {
-        const ws = new WebSocket(stringSocketUrl, webSocketOptions);
+        const ws = new WebSocket(url, webSocketOptions);
 
-        ws.addEventListener('open', connectEvent => {
+        ws.addEventListener('open', openEvent => {
           // parse incoming messages for pubsub
-          this.ws = ws;
-
-          // Heartbeat ping / pong check, to detect if connection has been
-          // broken but not detected by the client
-          // @note (2024-04): unstable and creates more issues than it solves, disable
-          // for now and review later
-          // const heartbeat = () => {
-          //   clearTimeout(this._heartbeatId);
-
-          //   this._heartbeatId = setTimeout(() => {
-          //     console.log('> HEARTBEAT missed, closing...');
-          //     this.terminate();
-          //   }, PING_INTERVAL + PING_LATENCY_TOLERANCE);
-          // };
+          this.#socket = ws;
 
-          // heartbeat();
-
-          this.ws.addEventListener('message', e => {
+          this.#socket.addEventListener('message', e => {
             if (e.data === PING_MESSAGE) {
               // heartbeat();
-              this.ws.send(PONG_MESSAGE);
+              this.#socket.send(PONG_MESSAGE);
               // do not propagate ping / pong messages
               return;
             }
 
             const [channel, args] = unpackStringMessage(e.data);
-            this._emit(false, channel, ...args);
+            this.#dispatchEvent(channel, ...args);
           });
 
-          // broadcast all `WebSocket` native events
-          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);
-          });
+          // propagate "native" events
+          // `close`:
+          //   Fired when a connection with a websocket is closed.
+          //   Also available via the onclose property
+          // `error`:
+          //   Fired when a connection with a websocket has been closed because of an error,
+          //   such as whensome data couldn't be sent.
+          //   Also available via the onerror property.
+          // `message`:
+          //   Fired when data is received through a websocket.
+          //   Also available via the onmessage property.
+          // `open`:
+          //   Fired when a connection with a websocket is opened.
+          //   Also available via the onopen property.
+          [
+            'close',
+            'error',
+            'upgrade',
+            'message',
+          ].forEach(eventName => {
+            this.#socket.addEventListener(eventName, e => {
+              this.#dispatchEvent(eventName, e);
+            });
+          })
 
           // forward open event
-          this._emit(false, 'open', connectEvent);
-
+          this.#dispatchEvent('open', openEvent);
           // continue with raw socket
           resolve();
         });
@@ -203,11 +152,13 @@ class Socket {
 
             // for node clients, retry connection
             if (e.error && e.error.code === 'ECONNREFUSED') {
+              // we want to log the warning just once
               if (!connectionRefusedLogged) {
                 logger.log('[soundworks.Socket] Connection refused, waiting for the server to start');
                 connectionRefusedLogged = true;
               }
 
+              // retry in 1 second
               setTimeout(trySocket, 1000);
             }
           }
@@ -216,39 +167,6 @@ class Socket {
 
       trySocket();
     });
-
-    // ----------------------------------------------------------
-    // init binary socket
-    // ----------------------------------------------------------
-    const binarySocketUrl = `${url}?binary=1&${queryParams}`;
-
-    await new Promise(resolve => {
-      const ws = new WebSocket(binarySocketUrl, webSocketOptions);
-      ws.binaryType = 'arraybuffer';
-
-      ws.addEventListener('open', connectEvent => {
-        // parse incoming messages for pubsub
-        this.binaryWs = ws;
-        this.binaryWs.addEventListener('message', e => {
-          const [channel, data] = unpackBinaryMessage(e.data);
-          this._emit(true, channel, data);
-        });
-
-        // broadcast all `WebSocket` native events
-        ['close', 'error', 'upgrade', 'message'].forEach(eventName => {
-          this.binaryWs.addEventListener(eventName, (e) => {
-            this._emit(true, eventName, e);
-          });
-        });
-
-        // forward open event
-        this._emit(true, 'open', connectEvent);
-        resolve();
-      });
-    });
-
-    // wait for both sockets connected
-    return Promise.resolve();
   }
 
   /**
@@ -257,28 +175,18 @@ class Socket {
    *
    * Is also called when a disconnection is detected by the heartbeat (note that
    * in this case, the launcher will call `client.stop()` but the listeners are
-   * already cleared so the event will be trigerred only once)
-   *
-   * @private
+   * already cleared so the event will be trigerred only once.
    */
-  async terminate() {
-    const closeListeners = this._stringListeners.get('close');
-    const closeBinaryListeners = this._binaryListeners.get('close');
-
+  async [kSocketTerminate]() {
+    const closeListeners = this.#listeners.get('close');
     this.removeAllListeners();
-    this.removeAllBinaryListeners();
 
-    this.ws.close();
-    this.binaryWs.close();
+    this.#socket.close();
 
     if (closeListeners) {
       closeListeners.forEach(listener => listener());
     }
 
-    if (closeBinaryListeners) {
-      closeBinaryListeners.forEach(listener => listener());
-    }
-
     return Promise.resolve();
   }
 
@@ -286,63 +194,14 @@ class Socket {
    * @param {boolean} binary - Emit to either the string or binary socket.
    * @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
-   */
-  _removeAllListeners(listeners, channel = null) {
-    if (channel === null) {
-      listeners.clear();
-    } else if (listeners.has(channel)) {
-      listeners.delete(channel);
-    }
-  }
-
   /**
    * Send messages with JSON compatible data types on a given channel.
    *
@@ -351,8 +210,10 @@ class Socket {
    *  JSON compatible data types (i.e. string, number, boolean, object, array and null).
    */
   send(channel, ...args) {
-    const msg = packStringMessage(channel, ...args);
-    this.ws.send(msg);
+    if (this.#socket.readyState === 1) {
+      const msg = packStringMessage(channel, ...args);
+      this.#socket.send(msg);
+    }
   }
 
   /**
@@ -364,7 +225,12 @@ class Socket {
    *  {@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);
   }
 
   /**
@@ -374,7 +240,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);
+      }
+    }
   }
 
   /**
@@ -383,47 +256,11 @@ 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);
-  }
-
-  /**
-   * Listen binary messages on a given channel
-   *
-   * @param {string} channel - Channel name.
-   * @param {Function} callback - Callback to execute when a message is received.
-   */
-  addBinaryListener(channel, callback) {
-    this._addListener(this._binaryListeners, channel, callback);
-  }
-
-  /**
-   * Remove a listener of binary compatible messages from a given channel
-   *
-   * @param {string} channel - Channel name.
-   * @param {Function} callback - Callback to remove.
-   */
-  removeBinaryListener(channel, callback) {
-    this._removeListener(this._binaryListeners, channel, callback);
-  }
-
-  /**
-   * 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);
+    if (channel === null) {
+      this.#listeners.clear();
+    } else if (this.#listeners.has(channel)) {
+      this.#listeners.delete(channel);
+    }
   }
 }
 

package/src/client/index.js

@@ -1,3 +1,9 @@
+/**
+ * @license
+ * Copyright (c) 2014-present IRCAM – Centre Pompidou (France, Paris)
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
 /**
  * Client-side part of the `soundworks` framework.
  *

package/src/common/constants.js

@@ -2,7 +2,6 @@
 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';
 

package/src/common/logger.js

@@ -126,6 +126,21 @@ const logger = {
     console.log(`    ${name} ${chalk.red('errors')}`);
   },
 
+  warnVersionDiscepancies(clientRole, clientVersion, serverVersion) {
+    console.warn(`
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+WARNING
+
+Version discrepancies between server and "${clientRole}" client:
++ server: ${serverVersion} | client: ${clientVersion}
+
+This might lead to unexpected behavior, you should consider to re-install your
+dependencies on both your server and clients.
+
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!`);
+  },
+
   log(msg) {
     if (!this.verbose) {
       return;

package/src/common/sockets-utils.js

@@ -1,66 +1,3 @@
-import 'fast-text-encoding';
-
-const encoder = new TextEncoder('utf-8');
-const decoder = new 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 globalThis[type](buffer.slice(startOffset));
-
-  return [channel, data];
-}
-
 /** @private */
 export function packStringMessage(channel, ...args) {
   return JSON.stringify([channel, args]);

package/src/common/version.js

@@ -0,0 +1,2 @@
+// [WARNING] This file is generated, do not edit
+export default '4.0.0-alpha.23';

package/src/server/Plugin.js

@@ -33,6 +33,9 @@ import BasePlugin from '../common/BasePlugin.js';
  * @inheritdoc
  */
 class Plugin extends BasePlugin {
+  #server = null;
+  #clients = new Set();
+
   /**
    * @param {server.Server} server - The soundworks server instance.
    * @param {string} id - User defined id of the plugin as defined in
@@ -40,16 +43,25 @@ class Plugin extends BasePlugin {
    */
   constructor(server, id) {
     super(id);
+    this.#server = server;
+  }
 
-    /**
-     * Instance of soundworks server.
-     * @type {server.Server}
-     * @see {@link server.Server}
-     */
-    this.server = server;
+  /**
+   * Instance of soundworks server.
+   * @type {server.Server}
+   * @see {@link server.Server}
+   */
+  get server() {
+    return this.#server;
+  }
 
-    /** @private */
-    this.clients = new Set();
+  /**
+   * Set of the clients registered in the plugin.
+   * @type {Set<server.Client>}
+   * @see {@link server.Client}
+   */
+  get clients() {
+    return this.#clients;
   }
 
   /**
@@ -60,7 +72,7 @@ class Plugin extends BasePlugin {
    * @param {server.Client} client
    */
   async addClient(client) {
-    this.clients.add(client);
+    this.#clients.add(client);
   }
 
   /**
@@ -71,7 +83,7 @@ class Plugin extends BasePlugin {
    * @param {server.Client} client
    */
   async removeClient(client) {
-    this.clients.delete(client);
+    this.#clients.delete(client);
   }
 }