@soundworks/core 3.6.0 → 3.7.0

package/server/Server.js

@@ -11,20 +11,26 @@ var _http = _interopRequireDefault(require("http"));
 
 var _https = _interopRequireDefault(require("https"));
 
-var _lodash = _interopRequireDefault(require("lodash.merge"));
-
 var _path = _interopRequireDefault(require("path"));
 
-var _pem = _interopRequireDefault(require("pem"));
-
 var _os = _interopRequireDefault(require("os"));
 
-var _polka = _interopRequireDefault(require("polka"));
+var _crypto = require("crypto");
 
-var _serveStatic = _interopRequireDefault(require("serve-static"));
+var _chalk = _interopRequireDefault(require("chalk"));
 
 var _compression = _interopRequireDefault(require("compression"));
 
+var _keyv = _interopRequireDefault(require("keyv"));
+
+var _keyvFile = _interopRequireDefault(require("keyv-file"));
+
+var _lodash = _interopRequireDefault(require("lodash.merge"));
+
+var _pem = _interopRequireDefault(require("pem"));
+
+var _polka = _interopRequireDefault(require("polka"));
+
 var _Client = _interopRequireDefault(require("./Client.js"));
 
 var _PluginManager = _interopRequireDefault(require("./PluginManager.js"));
@@ -33,17 +39,11 @@ var _Sockets = _interopRequireDefault(require("./Sockets.js"));
 
 var _SharedStateManagerServer = _interopRequireDefault(require("../common/SharedStateManagerServer.js"));
 
-var _logger = _interopRequireDefault(require("./utils/logger.js"));
-
-var _keyv = _interopRequireDefault(require("keyv"));
-
-var _keyvFile = _interopRequireDefault(require("keyv-file"));
+var _logger = _interopRequireDefault(require("../common/logger.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 let _dbNamespaces = new Set();
-
-let _dbStore = null;
 /**
  * Server side entry point for a `soundworks` application.
  *
@@ -62,6 +62,7 @@ let _dbStore = null;
  * soundworks.server.start();
  */
 
+
 class Server {
   constructor() {
     /**
@@ -139,8 +140,13 @@ class Server {
      * @param {String}
      */
 
-    this.templateDirectory = null; // private stuff
+    this.templateDirectory = null;
+    /**
+     * If https is required, will contain informations about the certificates
+     * (self-signed, validity dates, etc.)
+     */
 
+    this.httpsInfos = null;
     /**
      * Required activities that must be started. Only used in Experience
      * and Plugin - do not expose.
@@ -148,13 +154,6 @@ class Server {
      */
 
     this.activities = new Set();
-    /**
-     * Key and certificates (may be generated and self-signed) for https server.
-     * @todo - put in config...
-     * @private
-     */
-
-    this._httpsInfos = null;
     /**
      * Mapping between a `clientType` and its related activities.
      * @private
@@ -224,7 +223,7 @@ class Server {
    */
 
 
-  async init(config, clientConfigFunction = (clientType, serverConfig, httpRequest) => ({
+  async init(config, clientConfigFunction = (clientType, _serverConfig, _httpRequest) => ({
     clientType
   })) {
     const defaultConfig = {
@@ -310,216 +309,248 @@ class Server {
 
 
   async start() {
-    try {
-      // ------------------------------------------------------------
-      // init acitvities
-      // ------------------------------------------------------------
-      // we should at least have one activity registered for each client here
-      // i.e. the Experience so it's ok
-      this.activities.forEach(activity => {
-        activity.clientTypes.forEach(clientType => {
-          if (!this._clientTypeActivitiesMap[clientType]) {
-            this._clientTypeActivitiesMap[clientType] = new Set();
-          }
+    // ------------------------------------------------------------
+    // init acitvities
+    // ------------------------------------------------------------
+    // we should at least have one activity registered for each client here
+    // i.e. the Experience so it's ok
+    this.activities.forEach(activity => {
+      activity.clientTypes.forEach(clientType => {
+        if (!(clientType in this.config.app.clients)) {
+          throw new Error(`[soundworks:core] no config found for client type ${clientType}`);
+        }
 
-          this._clientTypeActivitiesMap[clientType].add(activity);
-        });
-      }); // start http server
+        if (!this._clientTypeActivitiesMap[clientType]) {
+          this._clientTypeActivitiesMap[clientType] = new Set();
+        }
 
-      const useHttps = this.config.env.useHttps || false;
-      return Promise.resolve() // ------------------------------------------------------------
-      // create HTTP(S) SERVER
-      // ------------------------------------------------------------
-      .then(() => {
-        // create http server
-        if (!useHttps) {
-          const httpServer = _http.default.createServer();
+        this._clientTypeActivitiesMap[clientType].add(activity);
+      });
+    }); // start http server
+
+    const useHttps = this.config.env.useHttps || false;
+    return Promise.resolve() // ------------------------------------------------------------
+    // create HTTP(S) SERVER
+    // ------------------------------------------------------------
+    .then(async () => {
+      // create http server
+      if (!useHttps) {
+        const httpServer = _http.default.createServer();
+
+        return Promise.resolve(httpServer);
+      } else {
+        const httpsInfos = this.config.env.httpsInfos;
 
-          return Promise.resolve(httpServer);
-        } else {
-          const httpsInfos = this.config.env.httpsInfos;
+        if (httpsInfos.key && httpsInfos.cert) {
+          // use given certificate
+          try {
+            const key = _fs.default.readFileSync(httpsInfos.key);
 
-          if (httpsInfos.key && httpsInfos.cert) {
-            // use given certificate
-            try {
-              const key = _fs.default.readFileSync(httpsInfos.key);
+            const cert = _fs.default.readFileSync(httpsInfos.cert); // this fails with self-signed certificates for whatever reason...
 
-              const cert = _fs.default.readFileSync(httpsInfos.cert);
 
-              this._httpsInfos = {
-                key,
-                cert
-              };
+            const x509 = new _crypto.X509Certificate(cert);
+            this.httpsInfos = {
+              selfSigned: false,
+              CN: x509.subject.split('=')[1],
+              altNames: x509.subjectAltName.split(',').map(e => e.trim().split(':')[1]),
+              validFrom: x509.validFrom,
+              validTo: x509.validTo
+            };
 
-              const httpsServer = _https.default.createServer(this._httpsInfos);
+            const httpsServer = _https.default.createServer({
+              key,
+              cert
+            });
 
-              return Promise.resolve(httpsServer);
-            } catch (err) {
-              console.error(`Invalid certificate files, please check your:
+            return Promise.resolve(httpsServer);
+          } catch (err) {
+            _logger.default.error(`
+Invalid certificate files, please check your:
 - key file: ${httpsInfos.key}
 - cert file: ${httpsInfos.cert}
-                `);
-              throw err;
-            }
-          } else {
-            return new Promise(async (resolve, reject) => {
-              const key = await this.db.get('httpsKey');
-              const cert = await this.db.get('httpsCert');
+              `);
 
-              if (key && cert) {
-                this._httpsInfos = {
-                  key,
-                  cert
-                };
+            throw err;
+          }
+        } else {
+          const key = await this.db.get('httpsKey');
+          const cert = await this.db.get('httpsCert');
 
-                const httpsServer = _https.default.createServer(this._httpsInfos);
+          if (key && cert) {
+            this.httpsInfos = {
+              selfSigned: true
+            };
 
-                resolve(httpsServer);
-              } else {
-                // generate certificate on the fly (for development purposes)
-                _pem.default.createCertificate({
-                  days: 1,
-                  selfSigned: true
-                }, async (err, keys) => {
-                  if (err) {
-                    return console.error(err.stack);
-                  }
+            const httpsServer = _https.default.createServer({
+              key,
+              cert
+            });
+
+            return Promise.resolve(httpsServer);
+          } else {
+            return new Promise(resolve => {
+              // generate certificate on the fly (for development purposes)
+              _pem.default.createCertificate({
+                days: 1,
+                selfSigned: true
+              }, async (err, keys) => {
+                if (err) {
+                  _logger.default.error(err.stack);
+
+                  return;
+                }
 
-                  this._httpsInfos = {
-                    key: keys.serviceKey,
-                    cert: keys.certificate
-                  };
-                  await this.db.set('httpsKey', this._httpsInfos.key);
-                  await this.db.set('httpsCert', this._httpsInfos.cert);
+                const key = keys.serviceKey;
+                const cert = keys.certificate;
+                this.httpsInfos = {
+                  selfSigned: true
+                }; // we store the generated cert so that we don't have to re-accept
+                // the cert each time the server restarts
 
-                  const httpsServer = _https.default.createServer(this._httpsInfos);
+                await this.db.set('httpsKey', key);
+                await this.db.set('httpsCert', cert);
 
-                  resolve(httpsServer);
+                const httpsServer = _https.default.createServer({
+                  key,
+                  cert
                 });
-              }
+
+                resolve(httpsServer);
+              });
             });
           }
         }
-      }).then(httpServer => {
-        this.httpServer = httpServer;
-        this.router.server = httpServer;
-        return Promise.resolve();
-      }).then(() => {
-        let nodeOnly = true; // do not throw if no browser clients are defined, very usefull for
-        // cleaning tests in particular
-
-        for (let clientType in this.config.app.clients) {
-          if (this.config.app.clients[clientType].target === 'browser') {
-            nodeOnly = false;
-          }
+      }
+    }).then(httpServer => {
+      this.httpServer = httpServer;
+      this.router.server = httpServer;
+      return Promise.resolve();
+    }).then(() => {
+      let nodeOnly = true; // do not throw if no browser clients are defined, very usefull for
+      // cleaning tests in particular
+
+      for (let clientType in this.config.app.clients) {
+        if (this.config.app.clients[clientType].target === 'browser') {
+          nodeOnly = false;
         }
+      }
 
-        if (!nodeOnly) {
-          if (this.templateEngine === null) {
-            throw new Error('Undefined "server.templateEngine": please provide a valid template engine');
-          }
+      if (!nodeOnly) {
+        if (this.templateEngine === null) {
+          throw new Error('Undefined "server.templateEngine": please provide a valid template engine');
+        }
 
-          if (this.templateDirectory === null) {
-            throw new Error('Undefined "server.templateDirectory": please provide a valid template directory');
-          }
-        } // ------------------------------------------------------------
-        // INIT ROUTING
-        // ------------------------------------------------------------
+        if (this.templateDirectory === null) {
+          throw new Error('Undefined "server.templateDirectory": please provide a valid template directory');
+        }
+      } // ------------------------------------------------------------
+      // INIT ROUTING
+      // ------------------------------------------------------------
 
 
-        _logger.default.title(`configured clients and routing`);
+      _logger.default.title(`configured clients and routing`);
 
-        const routes = [];
-        let defaultClientType = null;
+      const routes = [];
+      let defaultClientType = null;
 
-        for (let clientType in this.config.app.clients) {
-          if (this.config.app.clients[clientType].default === true) {
-            defaultClientType = clientType;
-          }
-        } // we must open default route last
+      for (let clientType in this.config.app.clients) {
+        if (this.config.app.clients[clientType].default === true) {
+          defaultClientType = clientType;
+        }
+      } // we must open default route last
 
 
-        for (let clientType in this._clientTypeActivitiesMap) {
-          // do nothing if client type is not registered in config
-          if (!(clientType in this.config.app.clients)) {
-            continue;
-          }
+      for (let clientType in this._clientTypeActivitiesMap) {
+        // do nothing if client type is not registered in config
+        if (!(clientType in this.config.app.clients)) {
+          continue;
+        }
 
-          if (clientType !== defaultClientType) {
-            const clientTarget = this.config.app.clients[clientType].target;
+        if (clientType !== defaultClientType) {
+          const clientTarget = this.config.app.clients[clientType].target;
 
-            const path = this._openClientRoute(clientType, clientTarget, this.router);
+          const path = this._openClientRoute(clientType, clientTarget, this.router);
 
-            routes.push({
-              clientType,
-              path
-            });
-          }
-        } // open default route last
+          routes.push({
+            clientType,
+            path
+          });
+        }
+      } // open default route last
 
 
-        for (let clientType in this._clientTypeActivitiesMap) {
-          // do nothing if client type is not registered in config
-          if (!(clientType in this.config.app.clients)) {
-            continue;
-          }
+      for (let clientType in this._clientTypeActivitiesMap) {
+        // do nothing if client type is not registered in config
+        if (!(clientType in this.config.app.clients)) {
+          continue;
+        }
 
-          if (clientType === defaultClientType) {
-            const clientTarget = this.config.app.clients[clientType].target;
+        if (clientType === defaultClientType) {
+          const clientTarget = this.config.app.clients[clientType].target;
 
-            const path = this._openClientRoute(clientType, clientTarget, this.router, true);
+          const path = this._openClientRoute(clientType, clientTarget, this.router, true);
 
-            routes.unshift({
-              clientType,
-              path
-            });
-          }
+          routes.unshift({
+            clientType,
+            path
+          });
         }
+      }
 
-        _logger.default.clientConfigAndRouting(routes, this.config);
-
-        return Promise.resolve();
-      }).then(() => {
-        // ------------------------------------------------------------
-        // START SOCKET SERVER
-        // ------------------------------------------------------------
-        this.sockets.start(this.httpServer, this.config.env.websockets, (clientType, socket) => this._onSocketConnection(clientType, socket));
-        return Promise.resolve();
-      }).then(async () => {
-        // ------------------------------------------------------------
-        // START SERVICE MANAGER
-        // ------------------------------------------------------------
-        return this.pluginManager.start();
-      }).then(() => {
-        // ------------------------------------------------------------
-        // START HTTP SERVER
-        // ------------------------------------------------------------
-        return new Promise((resolve, reject) => {
-          const port = this.config.env.port;
-          const useHttps = this.config.env.useHttps || false;
-          const protocol = useHttps ? 'https' : 'http';
-
-          const ifaces = _os.default.networkInterfaces();
-
-          this.router.listen(port, async () => {
-            _logger.default.title(`${protocol} server listening on`);
-
-            Object.keys(ifaces).forEach(dev => {
-              ifaces[dev].forEach(details => {
-                if (details.family === 'IPv4') {
-                  _logger.default.ip(protocol, details.address, port);
-                }
-              });
+      _logger.default.clientConfigAndRouting(routes, this.config);
+
+      return Promise.resolve();
+    }).then(() => {
+      // ------------------------------------------------------------
+      // START SOCKET SERVER
+      // ------------------------------------------------------------
+      this.sockets.start(this.httpServer, this.config.env.websockets, (clientType, socket) => this._onSocketConnection(clientType, socket));
+      return Promise.resolve();
+    }).then(async () => {
+      // ------------------------------------------------------------
+      // START SERVICE MANAGER
+      // ------------------------------------------------------------
+      return this.pluginManager.start();
+    }).then(() => {
+      // ------------------------------------------------------------
+      // START HTTP SERVER
+      // ------------------------------------------------------------
+      return new Promise(resolve => {
+        const port = this.config.env.port;
+        const useHttps = this.config.env.useHttps || false;
+        const protocol = useHttps ? 'https' : 'http';
+
+        const ifaces = _os.default.networkInterfaces();
+
+        this.router.listen(port, async () => {
+          _logger.default.title(`${protocol} server listening on`);
+
+          Object.keys(ifaces).forEach(dev => {
+            ifaces[dev].forEach(details => {
+              if (details.family === 'IPv4') {
+                _logger.default.ip(protocol, details.address, port);
+              }
             });
-            await this._emit('started');
-            resolve();
           });
+
+          if (this.httpsInfos !== null) {
+            _logger.default.title(`https certificates infos`);
+
+            if (this.httpsInfos.selfSigned) {
+              _logger.default.log(`    self-signed: ${this.httpsInfos.selfSigned ? 'true' : 'false'}`);
+            } else {
+              _logger.default.log(`    valid from: ${this.httpsInfos.validFrom}`);
+
+              _logger.default.log(`    valid to:   ${this.httpsInfos.validTo}`);
+            }
+          }
+
+          await this._emit('started');
+          resolve();
         });
       });
-      return Promise.resolve();
-    } catch (err) {
-      console.error(err);
-    }
+    });
   } // @todo - handle gracefull close of the server
 
 
@@ -619,39 +650,47 @@ class Server {
     const activities = this._clientTypeActivitiesMap[clientType];
 
     if (activities == undefined) {
-      throw new Error(`No activity registered for "${clientType}" clients, make sure an Experience has been initialized for this client (see src/server/index.js)`);
+      _logger.default.error(`[soundworks:core] No activity registered for "${clientType}", make sure an Experience has been created for this client`);
     }
 
     socket.addListener('close', () => {
       // clean sockets
       socket.terminate(); // remove client from activities
 
-      activities.forEach(activity => activity.disconnect(client)); // destroy client
+      if (activities) {
+        activities.forEach(activity => activity.disconnect(client));
+      } // destroy client
+
 
       client.destroy();
     });
     socket.addListener('s:client:handshake', data => {
-      // in development, if plugin required client-side but not server-side,
-      // complain properly client-side.
-      if (this.config.env.type !== 'production') {
-        // check coherence between client-side and server-side plugin requirements
-        const clientRequiredPlugins = data.requiredPlugins || [];
-        const serverRequiredPlugins = this.pluginManager.getRequiredPlugins(clientType);
-        const missingPlugins = [];
-        clientRequiredPlugins.forEach(pluginId => {
-          if (serverRequiredPlugins.indexOf(pluginId) === -1) {
-            missingPlugins.push(pluginId);
-          }
-        });
-
-        if (missingPlugins.length > 0) {
-          const err = {
-            type: 'plugins',
-            data: missingPlugins
-          };
-          socket.send('s:client:error', err);
-          return;
+      // client should throw error if no activity registered server-side (cf. #16)
+      if (activities === undefined) {
+        const err = {
+          type: 'no-activity'
+        };
+        socket.send('s:client:error', err);
+        return;
+      } // check coherence between client-side and server-side plugin requirements
+
+
+      const clientRequiredPlugins = data.requiredPlugins || [];
+      const serverRequiredPlugins = this.pluginManager.getRequiredPlugins(clientType);
+      const missingPlugins = [];
+      clientRequiredPlugins.forEach(pluginId => {
+        if (serverRequiredPlugins.indexOf(pluginId) === -1) {
+          missingPlugins.push(pluginId);
         }
+      });
+
+      if (missingPlugins.length > 0) {
+        const err = {
+          type: 'plugins',
+          data: missingPlugins
+        };
+        socket.send('s:client:error', err);
+        return;
       }
 
       activities.forEach(activity => activity.connect(client));
@@ -700,7 +739,7 @@ class Server {
       namespace,
       store
     });
-    db.on('error', err => console.log(chalk.red('[soundworks:core] db ${namespace} error:'), err));
+    db.on('error', err => _logger.default.error('[soundworks:core] db ${namespace} error: ${err}'));
     return db;
   }
 

package/server/Socket.js

@@ -7,14 +7,12 @@ exports.default = void 0;
 
 var _socketsEncoderDecoder = require("../common/sockets-encoder-decoder.js");
 
-const noop = () => {};
-
-let counter = 0;
-const CONNECTING = 0;
-const OPEN = 1;
-const CLOSING = 2;
-const CLOSED = 3;
-const READY_STATES = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
+const noop = () => {}; // const CONNECTING = 0;
+// const OPEN = 1;
+// const CLOSING = 2;
+// const CLOSED = 3;
+// const READY_STATES = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
+
 /**
  * Simple wrapper with simple pubsub system built on top of `ws` sockets.
  * The abstraction contains two different socket:
@@ -27,6 +25,7 @@ const READY_STATES = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
  * @memberof server
  */
 
+
 class Socket {
   constructor(ws, binaryWs, rooms, sockets, options = {}) {
     /**
@@ -115,7 +114,7 @@ class Socket {
       this._isAlive = false;
       this.ws.ping(noop);
     }, this.config.pingInterval);
-    this.ws.addListener('error', err => {// console.log(this.clientId, err);
+    this.ws.addListener('error', _err => {// console.log(this.clientId, err);
     });
   }
   /**
@@ -128,7 +127,7 @@ class Socket {
   terminate() {
     clearInterval(this._intervalId); // clean rooms
 
-    for (let [key, room] of this.rooms) {
+    for (let [_key, room] of this.rooms) {
       room.delete(this);
     } // clear references to sockets and rooms
 

package/server/Sockets.js

@@ -181,6 +181,5 @@ class Sockets {
 
 }
 
-;
 var _default = Sockets;
 exports.default = _default;