kuzzle 2.19.2 → 2.19.3

package/lib/core/network/protocols/internalProtocol.js

@@ -19,12 +19,14 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Protocol = require('./protocol');
-const ClientConnection = require('../clientConnection');
+const Protocol = require("./protocol");
+const ClientConnection = require("../clientConnection");
 
-const debug = require('../../../util/debug')('kuzzle:network:protocols:internal');
+const debug = require("../../../util/debug")(
+  "kuzzle:network:protocols:internal"
+);
 
 /**
  * Internal protocol to use SDK realtime subscription from plugins.
@@ -35,10 +37,10 @@ const debug = require('../../../util/debug')('kuzzle:network:protocols:internal'
  *  - 'core:network:internal:message'
  */
 class InternalProtocol extends Protocol {
-  constructor () {
-    super('internal');
+  constructor() {
+    super("internal");
 
-    this.connection = new ClientConnection(this.name, ['127.0.0.1']);
+    this.connection = new ClientConnection(this.name, ["127.0.0.1"]);
 
     /**
      * List of channel IDs
@@ -47,10 +49,10 @@ class InternalProtocol extends Protocol {
     this.channels = new Set();
   }
 
-  async init (entryPoint) {
+  async init(entryPoint) {
     await super.init(null, entryPoint);
 
-    debug('initializing InternalProtocol');
+    debug("initializing InternalProtocol");
 
     this.entryPoint.newConnection(this.connection);
 
@@ -59,46 +61,47 @@ class InternalProtocol extends Protocol {
      *
      * @returns {string} connectionId
      */
-    global.kuzzle.onAsk('core:network:internal:connectionId:get', () => (
-      this.connection.id
-    ));
+    global.kuzzle.onAsk(
+      "core:network:internal:connectionId:get",
+      () => this.connection.id
+    );
   }
 
-  joinChannel (channel, connectionId) {
-    debug('joinChannel: %s', channel, connectionId);
+  joinChannel(channel, connectionId) {
+    debug("joinChannel: %s", channel, connectionId);
 
     this.channels.add(channel);
   }
 
-  leaveChannel (channel, connectionId) {
-    debug('leaveChannel: %s', channel, connectionId);
+  leaveChannel(channel, connectionId) {
+    debug("leaveChannel: %s", channel, connectionId);
 
     this.channels.delete(channel);
   }
 
-  disconnect (connectionId) {
-    debug('disconnect: %s', connectionId);
+  disconnect(connectionId) {
+    debug("disconnect: %s", connectionId);
 
     // Never happens, the InternalProtocol always keep his only connection open
   }
 
-  broadcast (data) {
-    debug('broadcast: %a', data);
+  broadcast(data) {
+    debug("broadcast: %a", data);
 
     this._send(data);
   }
 
-  notify (data) {
-    debug('notify: %a', data);
+  notify(data) {
+    debug("notify: %a", data);
 
     this._send(data);
   }
 
-  _send (data) {
+  _send(data) {
     for (let i = 0; i < data.channels.length; i++) {
       const message = { ...data.payload, room: data.channels[i] };
 
-      global.kuzzle.emit('core:network:internal:message', message);
+      global.kuzzle.emit("core:network:internal:message", message);
     }
   }
 }

package/lib/core/network/protocols/mqttProtocol.js

@@ -19,25 +19,25 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const net = require('net');
+const net = require("net");
 
-const aedes = require('aedes');
+const aedes = require("aedes");
 
-const ClientConnection = require('../clientConnection');
-const Protocol = require('./protocol');
-const { Request } = require('../../../api/request');
-const { removeStacktrace } = require('../../../util/stackTrace');
-const kerror = require('../../../kerror').wrap('network', 'mqtt');
-const debug = require('../../../util/debug')('kuzzle:network:protocols:mqtt');
+const ClientConnection = require("../clientConnection");
+const Protocol = require("./protocol");
+const { Request } = require("../../../api/request");
+const { removeStacktrace } = require("../../../util/stackTrace");
+const kerror = require("../../../kerror").wrap("network", "mqtt");
+const debug = require("../../../util/debug")("kuzzle:network:protocols:mqtt");
 
 /**
  * @class MqttProtocol
  */
 class MqttProtocol extends Protocol {
-  constructor () {
-    super('mqtt');
+  constructor() {
+    super("mqtt");
 
     this.aedes = new aedes.Server();
     this.server = net.createServer(this.aedes.handle);
@@ -46,32 +46,35 @@ class MqttProtocol extends Protocol {
     this.connectionsById = new Map();
 
     // needs to be bound to this object's context
-    this.publishCallback = function pubcb (error) {
+    this.publishCallback = function pubcb(error) {
       if (error) {
         global.kuzzle.info(`[MQTT] Publishing message failed: ${error}`);
       }
     };
   }
 
-  async init (entryPoint) {
+  async init(entryPoint) {
     await super.init(null, entryPoint);
 
     if (this.config.enabled === false) {
       return false;
     }
 
-    debug('initializing MQTT Server with config: %a', this.config);
+    debug("initializing MQTT Server with config: %a", this.config);
 
-    this.config = Object.assign({
-      allowPubSub: false,
-      developmentMode: false,
-      disconnectDelay: 250,
-      requestTopic: 'Kuzzle/request',
-      responseTopic: 'Kuzzle/response',
-      server: {
-        port: 1883
-      }
-    }, this.config);
+    this.config = Object.assign(
+      {
+        allowPubSub: false,
+        developmentMode: false,
+        disconnectDelay: 250,
+        requestTopic: "Kuzzle/request",
+        responseTopic: "Kuzzle/response",
+        server: {
+          port: 1883,
+        },
+      },
+      this.config
+    );
 
     /*
      * To avoid ill-use of our topics, we need to configure authorizations:
@@ -84,18 +87,20 @@ class MqttProtocol extends Protocol {
     this.aedes.authorizeSubscribe = this._authorizeSubscribe.bind(this);
 
     // Message events
-    this.aedes.on('client', this.onConnection.bind(this));
-    this.aedes.on('clientError', this.onDisconnection.bind(this));
-    this.aedes.on('clientDisconnect', this.onDisconnection.bind(this));
-    this.aedes.on('publish', this.onMessage.bind(this));
+    this.aedes.on("client", this.onConnection.bind(this));
+    this.aedes.on("clientError", this.onDisconnection.bind(this));
+    this.aedes.on("clientDisconnect", this.onDisconnection.bind(this));
+    this.aedes.on("publish", this.onMessage.bind(this));
 
-    await new Promise(res => this.server.listen(this.config.server.port, res));
+    await new Promise((res) =>
+      this.server.listen(this.config.server.port, res)
+    );
 
     return true;
   }
 
-  broadcast (data) {
-    debug('broadcast %a', data);
+  broadcast(data) {
+    debug("broadcast %a", data);
 
     const payload = JSON.stringify(data.payload);
 
@@ -104,8 +109,8 @@ class MqttProtocol extends Protocol {
     }
   }
 
-  disconnect (connectionId, message = 'Connection closed by remote host') {
-    debug('disconnect: connection id: %s, message %s', connectionId, message);
+  disconnect(connectionId, message = "Connection closed by remote host") {
+    debug("disconnect: connection id: %s, message %s", connectionId, message);
 
     const client = this.connectionsById.get(connectionId);
 
@@ -114,26 +119,26 @@ class MqttProtocol extends Protocol {
     }
   }
 
-  joinChannel () {
+  joinChannel() {
     // do nothing
   }
 
-  leaveChannel () {
+  leaveChannel() {
     // do nothing
   }
 
-  notify (data) {
-    debug('notify %a', data);
+  notify(data) {
+    debug("notify %a", data);
 
     const client = this.connectionsById.get(data.connectionId);
 
-    if (! client) {
+    if (!client) {
       return;
     }
 
     const payload = Buffer.from(JSON.stringify(data.payload));
 
-    data.channels.forEach(topic => {
+    data.channels.forEach((topic) => {
       client.publish({ payload, topic }, this.publishCallback);
     });
   }
@@ -141,13 +146,14 @@ class MqttProtocol extends Protocol {
   /**
    * @param {Client} client
    */
-  onConnection (client) {
-    debug('onConnection: %s', client.id);
+  onConnection(client) {
+    debug("onConnection: %s", client.id);
 
     const connection = new ClientConnection(
       this.name,
       [client.conn.remoteAddress],
-      {});
+      {}
+    );
     this.entryPoint.newConnection(connection);
 
     this.connections.set(client, connection);
@@ -157,21 +163,19 @@ class MqttProtocol extends Protocol {
   /**
    * @param {Client} client
    */
-  onDisconnection (client) {
-    debug('onDisconnection %s', client.id);
+  onDisconnection(client) {
+    debug("onDisconnection %s", client.id);
 
     if (this.connections.has(client)) {
-      setTimeout(
-        () => {
-          const connection = this.connections.get(client);
-
-          if (connection) {
-            this.connections.delete(client);
-            this.connectionsById.delete(connection.id);
-            this.entryPoint.removeConnection(connection.id);
-          }
-        },
-        this.config.disconnectDelay);
+      setTimeout(() => {
+        const connection = this.connections.get(client);
+
+        if (connection) {
+          this.connections.delete(client);
+          this.connectionsById.delete(connection.id);
+          this.entryPoint.removeConnection(connection.id);
+        }
+      }, this.config.disconnectDelay);
     }
   }
 
@@ -179,10 +183,11 @@ class MqttProtocol extends Protocol {
    * @param packet
    * @param client
    */
-  onMessage (packet, client) {
-    if ( packet.topic !== this.config.requestTopic
-      || packet.payload === null
-      || client.id === null
+  onMessage(packet, client) {
+    if (
+      packet.topic !== this.config.requestTopic ||
+      packet.payload === null ||
+      client.id === null
     ) {
       return;
     }
@@ -190,32 +195,36 @@ class MqttProtocol extends Protocol {
     const connection = this.connections.get(client);
 
     if (connection === undefined) {
-      debug('no connection id for client id %s - packet: %o', client.id, packet);
-      global.kuzzle.log.error(`[MQTT] Received a packet from an unregistered client: ${client.id}`);
+      debug(
+        "no connection id for client id %s - packet: %o",
+        client.id,
+        packet
+      );
+      global.kuzzle.log.error(
+        `[MQTT] Received a packet from an unregistered client: ${client.id}`
+      );
       return;
     }
 
     try {
       const payload = JSON.parse(packet.payload.toString());
 
-      debug('onMessage payload: %o', payload);
+      debug("onMessage payload: %o", payload);
 
       const request = new Request(payload, { connection });
 
-      this.entryPoint.execute(
-        connection,
-        request,
-        response => this._respond(client, response));
-    }
-    catch (error) {
+      this.entryPoint.execute(connection, request, (response) =>
+        this._respond(client, response)
+      );
+    } catch (error) {
       this._respondError(client, error);
     }
   }
 
-  _respond (client, response) {
-    debug('sending response: %o', response.content);
+  _respond(client, response) {
+    debug("sending response: %o", response.content);
 
-    if (global.NODE_ENV === 'development' && this.config.developmentMode) {
+    if (global.NODE_ENV === "development" && this.config.developmentMode) {
       this.broadcast({
         channels: [this.config.responseTopic],
         payload: response.content,
@@ -229,48 +238,49 @@ class MqttProtocol extends Protocol {
         payload: Buffer.from(JSON.stringify(response.content)),
         topic: this.config.responseTopic,
       },
-      this.publishCallback);
+      this.publishCallback
+    );
   }
 
-  _respondError (client, error) {
+  _respondError(client, error) {
     const connection = this.connections.get(client);
 
-    const errReq = new Request({}, {
-      connection,
-      error: kerror.getFrom(error, 'unexpected_error', error.message)
-    });
+    const errReq = new Request(
+      {},
+      {
+        connection,
+        error: kerror.getFrom(error, "unexpected_error", error.message),
+      }
+    );
     this._respond(client, removeStacktrace(errReq.response.toJSON()));
   }
 
-  _authorizePublish (client, packet, callback) {
+  _authorizePublish(client, packet, callback) {
     const topic = packet.topic.toString();
 
     if (this.config.allowPubSub) {
       if (topic === this.config.responseTopic) {
-        callback(new Error('Cannot publish: this topic is read-only'));
-      }
-      else if (topic.includes('#') || topic.includes('+')) {
-        callback(new Error('Cannot publish: wildcards are disabled'));
-      }
-      else {
+        callback(new Error("Cannot publish: this topic is read-only"));
+      } else if (topic.includes("#") || topic.includes("+")) {
+        callback(new Error("Cannot publish: wildcards are disabled"));
+      } else {
         callback(null);
       }
-    }
-    else {
-      callback(topic === this.config.requestTopic
-        ? null
-        : new Error('Cannot publish on this topic: unauthorized'));
+    } else {
+      callback(
+        topic === this.config.requestTopic
+          ? null
+          : new Error("Cannot publish on this topic: unauthorized")
+      );
     }
   }
 
-  _authorizeSubscribe (client, sub, callback) {
+  _authorizeSubscribe(client, sub, callback) {
     if (sub.topic === this.config.requestTopic) {
-      callback(new Error('Cannot subscribe: this topic is write-only'));
-    }
-    else if (sub.topic.includes('#') || sub.topic.includes('+')) {
-      callback(new Error('Cannot subscribe: wildcards are disabled'));
-    }
-    else {
+      callback(new Error("Cannot subscribe: this topic is write-only"));
+    } else if (sub.topic.includes("#") || sub.topic.includes("+")) {
+      callback(new Error("Cannot subscribe: wildcards are disabled"));
+    } else {
       callback(null, sub);
     }
   }

package/lib/core/network/protocols/protocol.js

@@ -19,14 +19,14 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const assert = require('assert');
+const assert = require("assert");
 
-const bytes = require('../../../util/bytes');
+const bytes = require("../../../util/bytes");
 
 class Protocol {
-  constructor (name) {
+  constructor(name) {
     this.maxRequestSize = null;
     this.entryPoint = null;
     this.name = name;
@@ -34,9 +34,9 @@ class Protocol {
 
     this.initCalled = false;
 
-    Reflect.defineProperty(this, '_kuzzle', {
+    Reflect.defineProperty(this, "_kuzzle", {
       value: null,
-      writable: true
+      writable: true,
     });
   }
 
@@ -46,23 +46,25 @@ class Protocol {
    *
    * @returns {Promise<boolean>}
    */
-  async init (name, entryPoint) {
+  async init(name, entryPoint) {
     this.entryPoint = entryPoint;
 
     // name should be passed in the constructor
     assert(
-      this.name && ! name,
-      'A name has been given in the constructor and init method. Passing the name in the init method is deprecated.');
+      this.name && !name,
+      "A name has been given in the constructor and init method. Passing the name in the init method is deprecated."
+    );
 
-    if (! this.name) {
+    if (!this.name) {
       this.name = name;
     }
 
     this.maxRequestSize = bytes(entryPoint.config.maxRequestSize);
 
     assert(
-      typeof this.name === 'string' && this.name.length > 0,
-      'Invalid "name" parameter value: expected a non empty string value');
+      typeof this.name === "string" && this.name.length > 0,
+      'Invalid "name" parameter value: expected a non empty string value'
+    );
 
     if (entryPoint.config.protocols && entryPoint.config.protocols[this.name]) {
       this.config = entryPoint.config.protocols[this.name];
@@ -70,28 +72,29 @@ class Protocol {
 
     assert(
       Number.isInteger(this.maxRequestSize),
-      'Invalid "maxRequestSize" parameter value: expected a numeric value');
+      'Invalid "maxRequestSize" parameter value: expected a numeric value'
+    );
 
     this.initCalled = true;
 
     return true;
   }
 
-  broadcast () {
+  broadcast() {
     // do nothing by default
   }
 
-  joinChannel (channel, connectionId) {
+  joinChannel(channel, connectionId) {
     // do nothing by default
     return { channel, connectionId };
   }
 
-  leaveChannel (channel, connectionId) {
+  leaveChannel(channel, connectionId) {
     // do nothing by default
     return { channel, connectionId };
   }
 
-  notify () {
+  notify() {
     // do nothing by default
   }
 }