kuzzle 2.19.2 → 2.19.3

package/lib/core/network/entryPoint.js

@@ -19,34 +19,30 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const fs = require('fs');
-const path = require('path');
+const fs = require("fs");
+const path = require("path");
 
-const Bluebird = require('bluebird');
+const Bluebird = require("bluebird");
 
-const { RequestContext } = require('../../api/request');
-const Context = require('./context');
-const debug = require('../../util/debug')('kuzzle:network:embedded');
-const MqttProtocol = require('./protocols/mqttProtocol');
-const InternalProtocol = require('./protocols/internalProtocol');
-const HttpWsProtocol = require('./protocols/httpwsProtocol');
-const Manifest = require('./protocolManifest');
-const { removeStacktrace } = require('../../util/stackTrace');
-const kerror = require('../../kerror');
-const { AccessLogger } = require('./accessLogger');
+const { RequestContext } = require("../../api/request");
+const Context = require("./context");
+const debug = require("../../util/debug")("kuzzle:network:embedded");
+const MqttProtocol = require("./protocols/mqttProtocol");
+const InternalProtocol = require("./protocols/internalProtocol");
+const HttpWsProtocol = require("./protocols/httpwsProtocol");
+const Manifest = require("./protocolManifest");
+const { removeStacktrace } = require("../../util/stackTrace");
+const kerror = require("../../kerror");
+const { AccessLogger } = require("./accessLogger");
 
-const networkError = kerror.wrap('network', 'entrypoint');
+const networkError = kerror.wrap("network", "entrypoint");
 
-const DEFAULT_PROTOCOLS = [
-  HttpWsProtocol,
-  MqttProtocol,
-  InternalProtocol,
-];
+const DEFAULT_PROTOCOLS = [HttpWsProtocol, MqttProtocol, InternalProtocol];
 
 class EntryPoint {
-  constructor () {
+  constructor() {
     this.config = global.kuzzle.config.server;
 
     this.protocols = new Map();
@@ -58,19 +54,19 @@ class EntryPoint {
     this.isShuttingDown = false;
   }
 
-  dispatch (event, data) {
+  dispatch(event, data) {
     switch (event) {
-      case 'notify':
+      case "notify":
         this._notify(data);
         return;
-      case 'broadcast':
+      case "broadcast":
         this._broadcast(data);
         return;
-      case 'shutdown':
+      case "shutdown":
         this.isShuttingDown = true;
-        return ;
+        return;
       default:
-        throw networkError.get('unexpected_event', event);
+        throw networkError.get("unexpected_event", event);
     }
   }
 
@@ -80,14 +76,14 @@ class EntryPoint {
    *
    * @returns {Promise}
    */
-  async init () {
+  async init() {
     for (const ProtocolClass of DEFAULT_PROTOCOLS) {
       const protocol = new ProtocolClass();
 
       this.protocols.set(protocol.name, protocol);
     }
 
-    return this.protocols.get('internal').init(this);
+    return this.protocols.get("internal").init(this);
   }
 
   /**
@@ -96,11 +92,11 @@ class EntryPoint {
    *
    * @returns {Promise}
    */
-  async startListening () {
+  async startListening() {
     // We need to verify the port ourselves, to make sure Node.js won't open
     // a named pipe if the provided port number is a string
-    if (! Number.isInteger(this.config.port)) {
-      throw networkError.get('invalid_port', this.config.port);
+    if (!Number.isInteger(this.config.port)) {
+      throw networkError.get("invalid_port", this.config.port);
     }
 
     await this.accessLogger.init();
@@ -113,9 +109,9 @@ class EntryPoint {
         continue;
       }
 
-      initPromises.push(protocol.init(this)
-        .then(enabled => {
-          if (! enabled) {
+      initPromises.push(
+        protocol.init(this).then((enabled) => {
+          if (!enabled) {
             this.protocols.delete(protocol.name);
           }
         })
@@ -124,7 +120,6 @@ class EntryPoint {
 
     await Bluebird.all(initPromises);
 
-
     await this.loadMoreProtocols();
   }
 
@@ -135,80 +130,95 @@ class EntryPoint {
    * @param {string} channel
    * @param {string} connectionId
    */
-  joinChannel (channel, connectionId) {
+  joinChannel(channel, connectionId) {
     debug('[server] client "%s" joining channel "%s"', connectionId, channel);
 
     const client = this._clients.get(connectionId);
 
-    if (! client || ! client.protocol) {
+    if (!client || !client.protocol) {
       return;
     }
 
     try {
       this.protocols.get(client.protocol).joinChannel(channel, connectionId);
-    }
-    catch (e) {
-      global.kuzzle.log.error(`[join] protocol ${client && client.protocol} failed: ${e.message}`);
+    } catch (e) {
+      global.kuzzle.log.error(
+        `[join] protocol ${client && client.protocol} failed: ${e.message}`
+      );
     }
   }
 
-  leaveChannel (channel, connectionId) {
+  leaveChannel(channel, connectionId) {
     debug(
       '[server] connection "%s" leaving channel "%s"',
       connectionId,
-      channel);
+      channel
+    );
 
     const client = this._clients.get(connectionId);
 
-    if (! client || ! client.protocol) {
+    if (!client || !client.protocol) {
       return;
     }
 
     try {
       this.protocols.get(client.protocol).leaveChannel(channel, connectionId);
-    }
-    catch (e) {
-      global.kuzzle.log.error(`[leave channel] protocol ${client && client.protocol} failed: ${e.message}`);
+    } catch (e) {
+      global.kuzzle.log.error(
+        `[leave channel] protocol ${client && client.protocol} failed: ${
+          e.message
+        }`
+      );
     }
   }
 
   /**
    * Loads installed protocols in memory
    */
-  async loadMoreProtocols () {
-    const dir = path.join(__dirname, '../../../protocols/enabled');
+  async loadMoreProtocols() {
+    const dir = path.join(__dirname, "../../../protocols/enabled");
     let dirs;
 
     try {
       dirs = fs.readdirSync(dir);
-    }
-    catch (e) {
+    } catch (e) {
       // ignore if there is no protocols directory
       return;
     }
 
     dirs = dirs
-      .map(d => path.join(dir, d))
-      .filter(d => fs.statSync(d).isDirectory());
+      .map((d) => path.join(dir, d))
+      .filter((d) => fs.statSync(d).isDirectory());
 
-    await Bluebird.map(dirs, protoDir => {
+    await Bluebird.map(dirs, (protoDir) => {
       const protocol = new (require(protoDir))();
       const manifest = new Manifest(protoDir, protocol);
 
       manifest.load();
 
-      const initTimeout = global.kuzzle.config.services.common.defaultInitTimeout;
+      const initTimeout =
+        global.kuzzle.config.services.common.defaultInitTimeout;
 
       return Bluebird.resolve()
         .then(() => protocol.init(this, new Context()))
-        .catch(error => {
-          global.kuzzle.log.error(`Error during "${manifest.name}" protocol init:`);
+        .catch((error) => {
+          global.kuzzle.log.error(
+            `Error during "${manifest.name}" protocol init:`
+          );
           throw error;
         })
-        .timeout(initTimeout, `Protocol "${manifest.name}" initialization timed out after ${initTimeout}ms. Try to increase the configuration "services.common.defaultInitTimeout".`)
+        .timeout(
+          initTimeout,
+          `Protocol "${manifest.name}" initialization timed out after ${initTimeout}ms. Try to increase the configuration "services.common.defaultInitTimeout".`
+        )
         .then(() => {
           if (this.protocols.has(manifest.name)) {
-            throw kerror.get('protocol', 'runtime', 'already_exists', manifest.name);
+            throw kerror.get(
+              "protocol",
+              "runtime",
+              "already_exists",
+              manifest.name
+            );
           }
 
           this.protocols.set(manifest.name, protocol);
@@ -221,7 +231,7 @@ class EntryPoint {
    * @param {Request} request
    * @param {object} extra
    */
-  logAccess (connection, request, extra = null) {
+  logAccess(connection, request, extra = null) {
     this.accessLogger.log(connection, request, extra);
   }
 
@@ -236,19 +246,19 @@ class EntryPoint {
    * @param {Request} request
    * @param cb
    */
-  execute (connection, request, cb) {
+  execute(connection, request, cb) {
     if (this.isShuttingDown) {
-      debug('Shutting down. Dropping request: %a', request);
+      debug("Shutting down. Dropping request: %a", request);
       this._isShuttingDownError(connection, request, cb);
       return;
     }
 
-    debug('Funneling request: %a', request);
+    debug("Funneling request: %a", request);
 
     global.kuzzle.funnel.execute(request, (error, result) => {
       const _res = result || request;
 
-      if (error && ! _res.error) {
+      if (error && !_res.error) {
         _res.setError(error);
       }
 
@@ -264,78 +274,83 @@ class EntryPoint {
    *
    * @param {ClientConnection} connection
    */
-  newConnection (connection) {
+  newConnection(connection) {
     this._clients.set(connection.id, connection);
 
-    global.kuzzle.emit('connection:new', connection);
+    global.kuzzle.emit("connection:new", connection);
     global.kuzzle.router.newConnection(new RequestContext({ connection }));
     debug(
-      'New connection created: %s (protocol: %s)',
+      "New connection created: %s (protocol: %s)",
       connection.id,
-      connection.protocol);
+      connection.protocol
+    );
   }
 
   /**
    * @param {string} connectionId
    */
-  removeConnection (connectionId) {
+  removeConnection(connectionId) {
     const connection = this._clients.get(connectionId);
 
     if (connection) {
-      global.kuzzle.emit('connection:remove', connection);
+      global.kuzzle.emit("connection:remove", connection);
 
       global.kuzzle.router.removeConnection(new RequestContext({ connection }));
 
       this._clients.delete(connectionId);
 
       debug(
-        'Removed connection: %s (protocol: %s)',
+        "Removed connection: %s (protocol: %s)",
         connection.id,
-        connection.protocol);
+        connection.protocol
+      );
     }
   }
 
   // --------------------------------------------------------------------
 
-  _broadcast (data) {
+  _broadcast(data) {
     const sanitized = removeStacktrace(data);
 
-    debug('[server] broadcasting data through all protocols: %a', sanitized);
+    debug("[server] broadcasting data through all protocols: %a", sanitized);
 
     for (const [name, protocol] of this.protocols.entries()) {
       try {
         protocol.broadcast(sanitized);
-      }
-      catch (e) {
-        global.kuzzle.log.error(`[broadcast] protocol ${name} failed: ${e.message}\n${e.stack}`);
+      } catch (e) {
+        global.kuzzle.log.error(
+          `[broadcast] protocol ${name} failed: ${e.message}\n${e.stack}`
+        );
       }
     }
   }
 
-  _isShuttingDownError (connection, request, cb) {
-    request.setError(networkError.get('shutting_down'));
+  _isShuttingDownError(connection, request, cb) {
+    request.setError(networkError.get("shutting_down"));
     this.logAccess(connection, request);
 
     cb(removeStacktrace(request.response.toJSON()));
   }
 
-  _notify (data) {
+  _notify(data) {
     debug(
       '[server] sending notification to client with connection id "%s": %a',
       data.connectionId,
-      data);
+      data
+    );
 
     const client = this._clients.get(data.connectionId);
 
-    if (! client || ! client.protocol) {
+    if (!client || !client.protocol) {
       return;
     }
 
     try {
       this.protocols.get(client.protocol).notify(removeStacktrace(data));
-    }
-    catch (e) {
-      global.kuzzle.log.error(`[notify] protocol ${client.protocol} failed: ${e.message}`);
+    } catch (e) {
+      global.kuzzle.log.error(
+        `[notify] protocol ${client.protocol} failed: ${e.message}`
+      );
     }
   }
 }

package/lib/core/network/httpRouter/index.js

@@ -19,15 +19,15 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { Request } = require('../../../api/request');
-const { KuzzleError } = require('../../../kerror/errors');
-const RoutePart = require('./routePart');
-const { has } = require('../../../util/safeObject');
+const { Request } = require("../../../api/request");
+const { KuzzleError } = require("../../../kerror/errors");
+const RoutePart = require("./routePart");
+const { has } = require("../../../util/safeObject");
 
-const kerror = require('../../../kerror').wrap('network', 'http');
-const debug = require('../../../util/debug')('kuzzle:http:router');
+const kerror = require("../../../kerror").wrap("network", "http");
+const debug = require("../../../util/debug")("kuzzle:http:router");
 
 /**
  * Attach handler to routes and dispatch a HTTP
@@ -41,20 +41,22 @@ const debug = require('../../../util/debug')('kuzzle:http:router');
  * @class Router
  */
 class Router {
-  constructor () {
+  constructor() {
     this.defaultHeaders = {
-      'Accept-Encoding': 'identity',
-      'Access-Control-Allow-Headers': global.kuzzle.config.http.accessControlAllowHeaders,
-      'Access-Control-Allow-Methods': global.kuzzle.config.http.accessControlAllowMethods,
-      'content-type': 'application/json'
+      "Accept-Encoding": "identity",
+      "Access-Control-Allow-Headers":
+        global.kuzzle.config.http.accessControlAllowHeaders,
+      "Access-Control-Allow-Methods":
+        global.kuzzle.config.http.accessControlAllowMethods,
+      "content-type": "application/json",
     };
 
     if (global.kuzzle.config.http.cookieAuthentication) {
-      this.defaultHeaders['Access-Control-Allow-Credentials'] = 'true';
+      this.defaultHeaders["Access-Control-Allow-Credentials"] = "true";
     }
 
     if (global.kuzzle.config.server.protocols.http.allowCompression === true) {
-      this.defaultHeaders['Accept-Encoding'] = 'gzip,deflate,identity';
+      this.defaultHeaders["Accept-Encoding"] = "gzip,deflate,identity";
     }
 
     this.routes = {
@@ -63,14 +65,18 @@ class Router {
       HEAD: new RoutePart(),
       PATCH: new RoutePart(),
       POST: new RoutePart(),
-      PUT: new RoutePart()
+      PUT: new RoutePart(),
     };
 
     // Add an automatic HEAD route on the '/' url, answering with default headers
-    attach('/', (request, cb) => {
-      request.setResult({}, 200);
-      cb(request);
-    }, this.routes.HEAD);
+    attach(
+      "/",
+      (request, cb) => {
+        request.setResult({}, 200);
+        cb(request);
+      },
+      this.routes.HEAD
+    );
   }
 
   /**
@@ -79,7 +85,7 @@ class Router {
    * @param {string} path
    * @param {Function} handler
    */
-  get (path, handler) {
+  get(path, handler) {
     attach(path, handler, this.routes.GET);
   }
 
@@ -89,7 +95,7 @@ class Router {
    * @param {string} path
    * @param {Function} handler
    */
-  post (path, handler) {
+  post(path, handler) {
     attach(path, handler, this.routes.POST);
   }
 
@@ -99,7 +105,7 @@ class Router {
    * @param {string} path
    * @param {Function} handler
    */
-  put (path, handler) {
+  put(path, handler) {
     attach(path, handler, this.routes.PUT);
   }
 
@@ -109,7 +115,7 @@ class Router {
    * @param {string} path
    * @param {Function} handler
    */
-  patch (path, handler) {
+  patch(path, handler) {
     attach(path, handler, this.routes.PATCH);
   }
 
@@ -119,7 +125,7 @@ class Router {
    * @param {string} path
    * @param {Function} handler
    */
-  delete (path, handler) {
+  delete(path, handler) {
     attach(path, handler, this.routes.DELETE);
   }
 
@@ -129,7 +135,7 @@ class Router {
    * @param {string} path
    * @param {Function} handler
    */
-  head (path, handler) {
+  head(path, handler) {
     attach(path, handler, this.routes.HEAD);
   }
 
@@ -139,10 +145,10 @@ class Router {
    * @param {HttpMessage} message - Parsed HTTP message
    * @param {function} cb
    */
-  route (message, cb) {
-    debug('Routing HTTP message: %a', message);
+  route(message, cb) {
+    debug("Routing HTTP message: %a", message);
 
-    if (! has(this.routes, message.method)) {
+    if (!has(this.routes, message.method)) {
       this.routeUnhandledHttpMethod(message, cb);
       return;
     }
@@ -158,27 +164,26 @@ class Router {
       applyACAOHeader(message, routeHandler.request);
 
       if (routeHandler.handler === null) {
-        throw kerror.get('url_not_found', routeHandler.url);
+        throw kerror.get("url_not_found", routeHandler.url);
       }
 
       routeHandler.invokeHandler(cb);
-    }
-    catch (err) {
+    } catch (err) {
       let request;
-      if (! routeHandler || ! routeHandler._request) {
+      if (!routeHandler || !routeHandler._request) {
         request = new Request({ requestId: message.requestId }, {});
         // Set Headers if not present
         request.response.setHeaders(this.defaultHeaders, true);
 
         applyACAOHeader(message, request);
-      }
-      else {
+      } else {
         request = routeHandler.request;
       }
 
-      const e = err instanceof KuzzleError
-        ? err
-        : kerror.getFrom(err, 'unexpected_error', err.message);
+      const e =
+        err instanceof KuzzleError
+          ? err
+          : kerror.getFrom(err, "unexpected_error", err.message);
 
       replyWithError(cb, request, e);
     }
@@ -190,27 +195,28 @@ class Router {
    * @param  {HttpMessage} message
    * @param {function} cb
    */
-  routeUnhandledHttpMethod (message, cb) {
-    const
-      requestContext = global.kuzzle.router.connections.get(message.connection.id),
+  routeUnhandledHttpMethod(message, cb) {
+    const requestContext = global.kuzzle.router.connections.get(
+        message.connection.id
+      ),
       request = new Request(
         { requestId: message.requestId },
-        requestContext && requestContext.toJSON());
+        requestContext && requestContext.toJSON()
+      );
 
     // Set Headers if not present
     request.response.setHeaders(this.defaultHeaders, true);
 
     applyACAOHeader(message, request);
 
-    if (message.method === 'OPTIONS') {
+    if (message.method === "OPTIONS") {
       request.input.headers = message.headers;
       request.setResult({}, 200);
 
-      global.kuzzle.pipe('http:options', request, (error, result) => {
+      global.kuzzle.pipe("http:options", request, (error, result) => {
         if (error) {
           replyWithError(cb, request, error);
-        }
-        else {
+        } else {
           cb(result);
         }
       });
@@ -218,10 +224,7 @@ class Router {
       return;
     }
 
-    replyWithError(
-      cb,
-      request,
-      kerror.get('unsupported_verb', message.method));
+    replyWithError(cb, request, kerror.get("unsupported_verb", message.method));
   }
 }
 
@@ -231,12 +234,12 @@ class Router {
  * @param {HttpMessage} message
  * @param {Request} request
  */
-function applyACAOHeader (message, request) {
+function applyACAOHeader(message, request) {
   if (message.headers && message.headers.origin) {
     request.response.setHeaders(
       {
-        'Access-Control-Allow-Origin': message.headers.origin,
-        'Vary': 'Origin',
+        "Access-Control-Allow-Origin": message.headers.origin,
+        Vary: "Origin",
       },
       true
     );
@@ -250,11 +253,11 @@ function applyACAOHeader (message, request) {
  * @param {Function} handler
  * @param {RoutePart} target
  */
-function attach (path, handler, target) {
-  const sanitized = path[path.length - 1] === '/' ? path.slice(0, -1) : path;
+function attach(path, handler, target) {
+  const sanitized = path[path.length - 1] === "/" ? path.slice(0, -1) : path;
 
-  if (! attachParts(sanitized.split('/'), handler, target)) {
-    throw kerror.get('duplicate_url', sanitized);
+  if (!attachParts(sanitized.split("/"), handler, target)) {
+    throw kerror.get("duplicate_url", sanitized);
   }
 }
 
@@ -266,16 +269,16 @@ function attach (path, handler, target) {
  * @param {Array<string>} placeholders
  * @returns {Boolean} If false, failed to attach because of a duplicate
  */
-function attachParts (parts, handler, target, placeholders = []) {
+function attachParts(parts, handler, target, placeholders = []) {
   let part;
 
   do {
     part = parts.shift();
   } while (parts.length > 0 && part.length === 0);
 
-  if (part && part[0] === ':') {
+  if (part && part[0] === ":") {
     placeholders.push(part.substring(1));
-    part = '*';
+    part = "*";
   }
 
   const next = target.getNext(part);
@@ -301,7 +304,7 @@ function attachParts (parts, handler, target, placeholders = []) {
  * @param {Request} request
  * @param {Error} error
  */
-function replyWithError (cb, request, error) {
+function replyWithError(cb, request, error) {
   request.setError(error);
 
   cb(request);