@soundworks/core 3.6.0 → 3.7.0

package/server/AbstractPlugin.js

@@ -13,7 +13,7 @@ var _Signal = _interopRequireDefault(require("../common/Signal.js"));
 
 var _SignalAll = _interopRequireDefault(require("../common/SignalAll.js"));
 
-var _logger = _interopRequireDefault(require("./utils/logger.js"));
+var _logger = _interopRequireDefault(require("../common/logger.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -63,13 +63,13 @@ class AbstractPlugin {
 
     this.server.activities.add(this); // start when all required signals are fired
 
-    this.signals.start.addObserver(value => {
+    this.signals.start.addObserver(() => {
       _logger.default.pluginStart(this.name);
 
       this.start();
     }); // log errors if any
 
-    this.signals.errored.addObserver(value => _logger.default.pluginErrored(this.name));
+    this.signals.errored.addObserver(() => _logger.default.pluginErrored(this.name));
     this.ready = this.ready.bind(this);
   }
   /**
@@ -178,7 +178,10 @@ class AbstractPlugin {
   }
 
   error(msg) {
-    console.log(`> plugin "${this.name}" error: ${msg}`);
+    _logger.default.pluginError(this.name);
+
+    _logger.default.error(`> Error: ${msg}`);
+
     this.signals.errored.msg = msg;
     this.signals.errored.value = true;
   }

package/server/Client.js

@@ -28,9 +28,9 @@ class Client {
   constructor(clientType, socket) {
     /**
      * Client type, as specified when initializing the client side {@link client.Client}.
-       *
-       * @see {@link client.Client#init}
-       * @type {String}
+     *
+     * @see {@link client.Client#init}
+     * @type {String}
      */
     this.type = clientType;
     /**
@@ -42,7 +42,7 @@ class Client {
     this.id = generateId.next().value;
     /**
      * Unique session id (uuidv4).
-       * @type {String}
+     * @type {String}
      */
 
     this.uuid = (0, _uuid.v4)();

package/server/PluginManager.js

@@ -13,7 +13,7 @@ var _Signal = _interopRequireDefault(require("../common/Signal.js"));
 
 var _SignalAll = _interopRequireDefault(require("../common/SignalAll.js"));
 
-var _logger = _interopRequireDefault(require("./utils/logger.js"));
+var _logger = _interopRequireDefault(require("../common/logger.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -28,19 +28,25 @@ const log = (0, _debug.default)('soundworks:lifecycle');
 class PluginManager {
   constructor(server) {
     /** @private */
-    this._registeredPlugins = {};
+    this._server = server;
     /** @private */
 
-    this._instances = {};
+    this._registeredPlugins = new Map();
     /** @private */
 
-    this._server = server; // @todo - move to Promise based logic
+    this._instances = new Map();
+    /** @private */
+
+    this._observers = new Set();
+    /** @private */
+
+    this._pluginsStatuses = {}; // @todo - move to Promise based logic
 
     this.signals = {
       start: new _Signal.default(),
       ready: new _SignalAll.default()
     };
-    this.ready = new Promise((resolve, reject) => {
+    this.ready = new Promise(resolve => {
       this._resolveReadyPromise = resolve;
     });
   }
@@ -56,7 +62,10 @@ class PluginManager {
       log('> pluginManager ready');
 
       this._resolveReadyPromise();
-    }); // start before ready, even if no deps
+    }); // propagate all 'idle' statuses before start
+
+    this._propagateStatusChange(); // start before ready, even if no deps
+
 
     this.signals.start.value = true;
 
@@ -66,6 +75,40 @@ class PluginManager {
 
     return this.ready;
   }
+  /** @private */
+
+
+  _propagateStatusChange(name = null, status = null) {
+    if (name != null && status != null) {
+      this._pluginsStatuses[name] = status;
+      const statuses = this.getStatuses();
+
+      this._observers.forEach(observer => observer(statuses, {
+        [name]: status
+      }));
+    } else {
+      const statuses = this.getStatuses();
+
+      this._observers.forEach(observer => observer(statuses, {}));
+    }
+  }
+  /** @private */
+
+
+  observe(observer) {
+    this._observers.add(observer);
+
+    return () => {
+      this._observers.delete(observer);
+    };
+  }
+  /** @private */
+  // @todo rename to `getStatuses`
+
+
+  getStatuses() {
+    return Object.assign({}, this._pluginsStatuses);
+  }
   /**
    * Register a plugin (server-side) into soundworks.
    *
@@ -85,64 +128,55 @@ class PluginManager {
 
 
   register(name, factory = null, options = {}, deps = []) {
-    if (this._registeredPlugins[name]) {
+    if (this._registeredPlugins.has(name)) {
       const ctor = factory(_AbstractPlugin.default);
       throw new Error(`[soundworks:core] Plugin "${name}" of type "${ctor.name}" already registered`);
     }
 
     const ctor = factory(_AbstractPlugin.default);
-    this._registeredPlugins[name] = {
+
+    this._registeredPlugins.set(name, {
       ctor,
       options,
       deps
-    };
+    });
   }
   /**
    * Retrieve an instance of a registered plugin according to its given name.
    * Except if you know what you are doing, prefer `Experience.require('my-plugin')`
+   *
    * @param {String} name - Name of the registered plugin
    */
+  // @todo - review this API, this is ugly and error prone
 
 
   get(name, _experience = null) {
-    if (!this._registeredPlugins[name]) {
-      throw new Error(`[soundworks:core] Cannot get or require plugin "${name}", plugin is not registered
+    if (!this._registeredPlugins.has(name)) {
+      let msg = `[soundworks:core] Cannot get or require plugin "${name}", plugin is not registered`;
+
+      if (this._registeredPlugins.size > 0) {
+        msg += `
 > registered plugins are:
-${Object.keys(this._registeredPlugins).map(n => `> - ${n}\n`).join('')}
-`);
+${Array.from(this._registeredPlugins.keys()).map(name => `> - ${name}\n`).join('')}`;
+      } else {
+        msg += `
+> no plugin registered`;
+      }
+
+      throw new Error(msg);
     } // required by experience and manager already started
 
 
     if (_experience && this.signals.start.value === true) {
-      throw new Error(`[soundworks:core] Plugin "${name}" required after pluginManager start`);
+      throw new Error(`[soundworks:core] Cannot require plugin ("${name}") after server.start()`);
     }
 
-    if (!this._instances[name]) {
-      log(`> instanciating plugin "${name}"`);
-      const {
-        ctor,
-        options,
-        deps
-      } = this._registeredPlugins[name];
-      const instance = new ctor(this._server, name, options);
-      this.signals.ready.add(instance.signals.ready);
-      instance.signals.start.add(this.signals.start);
-
-      if (deps.length > 0) {
-        deps.forEach(dependencyName => {
-          if (!this._instances[dependencyName]) {
-            this.get(dependencyName, _experience); // propagate client types
-          }
-
-          const dependency = this._instances[dependencyName];
-          instance.signals.start.add(dependency.signals.ready);
-        });
-      }
-
-      this._instances[name] = instance;
+    if (!this._instances.has(name)) {
+      this._createInstance(name);
     }
 
-    const instance = this._instances[name]; // if require by the experience, map client types
+    const instance = this._instances.get(name); // if require by the experience, map client types
+
 
     if (_experience) {
       _experience.clientTypes.forEach(clientType => {
@@ -155,12 +189,74 @@ ${Object.keys(this._registeredPlugins).map(n => `> - ${n}\n`).join('')}
   /** @private */
 
 
+  _createInstance(name) {
+    log(`> instantiating plugin "${name}"`);
+
+    const {
+      ctor,
+      options,
+      deps
+    } = this._registeredPlugins.get(name);
+
+    const instance = new ctor(this._server, name, options);
+    this.signals.ready.add(instance.signals.ready);
+    instance.signals.start.add(this.signals.start);
+
+    if (deps.length > 0) {
+      deps.forEach(dependencyName => {
+        if (!this._instances.has(dependencyName)) {
+          this.get(dependencyName, _experience); // propagate client types
+        }
+
+        const dependency = this._instances.get(dependencyName);
+
+        instance.signals.start.add(dependency.signals.ready);
+      });
+    } // handle plugin status reporting
+
+
+    this._pluginsStatuses[name] = 'idle';
+
+    const onPluginStarted = () => {
+      this._propagateStatusChange(name, 'started');
+    };
+
+    const onPluginErrored = () => {
+      this._propagateStatusChange(name, 'errored');
+
+      instance.signals.started.removeObserver(onPluginStarted);
+      instance.signals.ready.removeObserver(onPluginReady);
+      instance.signals.errored.removeObserver(onPluginErrored);
+    };
+
+    const onPluginReady = () => {
+      this._propagateStatusChange(name, 'ready');
+
+      instance.signals.started.removeObserver(onPluginStarted);
+      instance.signals.ready.removeObserver(onPluginReady);
+      instance.signals.errored.removeObserver(onPluginErrored);
+    }; // listen the signals
+
+
+    instance.signals.started.addObserver(onPluginStarted);
+    instance.signals.ready.addObserver(onPluginReady);
+    instance.signals.errored.addObserver(onPluginErrored);
+
+    this._instances.set(name, instance);
+  }
+  /**
+   * @private
+   * This method is protected (semi-private), only used by server to check
+   * consistency between client and server experiences requirements.
+   */
+
+
   getRequiredPlugins(clientType = null) {
     const plugins = [];
 
-    for (let name in this._instances) {
+    for (let name of this._instances.keys()) {
       if (clientType !== null) {
-        if (this._instances[name].clientTypes.has(clientType)) {
+        if (this._instances.get(name).clientTypes.has(clientType)) {
           plugins.push(name);
         }
       } else {