kuzzle 2.19.2 → 2.19.3

package/lib/cluster/node.js

@@ -19,25 +19,25 @@
  * limitations under the License.
  */
 
-'use strict';
-
-const os = require('os');
-const net = require('net');
-const assert = require('assert');
-
-const Bluebird = require('bluebird');
-const EventEmitter = require('eventemitter3');
-const _ = require('lodash');
-
-const debug = require('../util/debug')('kuzzle:cluster:sync');
-const { Mutex } = require('../util/mutex');
-const { ClusterIdCardHandler } = require('./idCardHandler');
-const ClusterPublisher = require('./publisher');
-const ClusterSubscriber = require('./subscriber');
-const ClusterState = require('./state');
-const ClusterCommand = require('./command');
-const kuzzleStateEnum = require('../kuzzle/kuzzleStateEnum');
-const { fromKoncordeIndex } = require('../util/koncordeCompat');
+"use strict";
+
+const os = require("os");
+const net = require("net");
+const assert = require("assert");
+
+const Bluebird = require("bluebird");
+const EventEmitter = require("eventemitter3");
+const _ = require("lodash");
+
+const debug = require("../util/debug")("kuzzle:cluster:sync");
+const { Mutex } = require("../util/mutex");
+const { ClusterIdCardHandler } = require("./idCardHandler");
+const ClusterPublisher = require("./publisher");
+const ClusterSubscriber = require("./subscriber");
+const ClusterState = require("./state");
+const ClusterCommand = require("./command");
+const kuzzleStateEnum = require("../kuzzle/kuzzleStateEnum");
+const { fromKoncordeIndex } = require("../util/koncordeCompat");
 
 /**
  * Test an IP address and determine if it's in the public or private range.
@@ -45,19 +45,23 @@ const { fromKoncordeIndex } = require('../util/koncordeCompat');
  * @param  {String}  ip
  * @return {Boolean}
  */
-function isPrivateIP (ip) {
+function isPrivateIP(ip) {
   if (net.isIPv6(ip)) {
-    const prefix = ip.split(':')[0];
+    const prefix = ip.split(":")[0];
 
-    return (prefix.startsWith('fd') && prefix.length === 4) || prefix === 'fe80';
+    return (
+      (prefix.startsWith("fd") && prefix.length === 4) || prefix === "fe80"
+    );
   }
 
   // IPv4
-  const exploded = ip.split('.').map(s => Number.parseInt(s));
+  const exploded = ip.split(".").map((s) => Number.parseInt(s));
 
-  return exploded[0] === 10
-    || (exploded[0] === 172 && exploded[1] >= 16 && exploded[1] <= 31)
-    || (exploded[0] === 192 && exploded[1] === 168);
+  return (
+    exploded[0] === 10 ||
+    (exploded[0] === 172 && exploded[1] >= 16 && exploded[1] <= 31) ||
+    (exploded[0] === 192 && exploded[1] === 168)
+  );
 }
 
 /**
@@ -66,23 +70,25 @@ function isPrivateIP (ip) {
  * @param  {String}  ip
  * @return {Boolean}
  */
-function isInternalIP (ip) {
+function isInternalIP(ip) {
   // To my knowledge, there aren't any reserved, non-loopback and non-routable
   // IPv6 addresses
   if (net.isIPv6(ip)) {
     return false;
   }
 
-  const exploded = ip.split('.').map(s => Number.parseInt(s));
+  const exploded = ip.split(".").map((s) => Number.parseInt(s));
 
   // 127.x.x: loopback addresses are already flagged as "internal" by
   // os.networkInterfaces.
-  return exploded[0] === 127
+  return (
+    exploded[0] === 127 ||
     // 169.254.x.x addresses are APIPA addresses: temporary and non-routable.
     // We need to remove them from the accepted list of IP addresses
     // (this is a "just in case" scenario: APIPA addresses are obsolete and
     // should not be used anymore, but we never know...)
-    || (exploded[0] === 169 && exploded[1] === 254);
+    (exploded[0] === 169 && exploded[1] === 254)
+  );
 }
 
 /**
@@ -93,8 +99,8 @@ function isInternalIP (ip) {
  * @param  {String} [options.ip] Used to target public or private addresses
  * @return {String|null}
  */
-function getIP ({ family = 'IPv4', interface: netInterface, ip } = {}) {
-  const mustBePrivate = ip === 'private';
+function getIP({ family = "IPv4", interface: netInterface, ip } = {}) {
+  const mustBePrivate = ip === "private";
 
   let interfaces = [];
 
@@ -107,23 +113,25 @@ function getIP ({ family = 'IPv4', interface: netInterface, ip } = {}) {
     }
   }
 
-  debug('Found interfaces %o', interfaces);
+  debug("Found interfaces %o", interfaces);
 
-  interfaces = interfaces.filter(n => {
-    return ! n.internal
-      && ! isInternalIP(n.address)
-      && n.family === family
-      && (! ip || mustBePrivate === isPrivateIP(n.address));
+  interfaces = interfaces.filter((n) => {
+    return (
+      !n.internal &&
+      !isInternalIP(n.address) &&
+      n.family === family &&
+      (!ip || mustBePrivate === isPrivateIP(n.address))
+    );
   });
 
-  debug('Filtered interfaces %o', interfaces);
+  debug("Filtered interfaces %o", interfaces);
 
   if (interfaces.length === 0) {
     return null;
   }
 
   // take the first IP from the list if no interface has been defined
-  if (! netInterface) {
+  if (!netInterface) {
     return interfaces[0].address;
   }
 
@@ -136,7 +144,6 @@ function getIP ({ family = 'IPv4', interface: netInterface, ip } = {}) {
   return null;
 }
 
-
 /**
  * @typedef {nodeActivityEnum}
  */
@@ -148,11 +155,11 @@ const nodeActivityEnum = Object.freeze({
 // Handles the node logic: discovery, eviction, heartbeat, ...
 // Dependencies: core:cache module must be started
 class ClusterNode {
-  constructor () {
+  constructor() {
     this.config = global.kuzzle.config.cluster;
     this.heartbeatDelay = this.config.heartbeat;
 
-    const family = this.config.ipv6 ? 'IPv6' : 'IPv4';
+    const family = this.config.ipv6 ? "IPv6" : "IPv4";
 
     this.ip = getIP({
       family,
@@ -160,8 +167,11 @@ class ClusterNode {
       ip: this.config.ip,
     });
 
-    debug('Found IP address: %s with config %o', this.ip, this.config);
-    assert(this.ip !== null, `[CLUSTER] No suitable IP address found with the provided configuration (family: ${family}, interface: ${this.config.interface}, ip: ${this.config.ip})`);
+    debug("Found IP address: %s with config %o", this.ip, this.config);
+    assert(
+      this.ip !== null,
+      `[CLUSTER] No suitable IP address found with the provided configuration (family: ${family}, interface: ${this.config.interface}, ip: ${this.config.ip})`
+    );
 
     this.nodeId = null;
     this.heartbeatTimer = null;
@@ -186,11 +196,11 @@ class ClusterNode {
     this.activity = [];
   }
 
-  get syncAddress () {
+  get syncAddress() {
     return `tcp://${this.ip}:${this.config.ports.sync}`;
   }
 
-  async init () {
+  async init() {
     // The publisher needs to be created and initialized before the handshake:
     // other nodes we'll connect to during the handshake will start to subscribe
     // to this node right away
@@ -201,7 +211,7 @@ class ClusterNode {
     // and to introduce oneself to other nodes)
     await this.command.init();
 
-    global.kuzzle.onPipe('kuzzle:shutdown', () => this.shutdown());
+    global.kuzzle.onPipe("kuzzle:shutdown", () => this.shutdown());
 
     await this.handshake();
 
@@ -209,7 +219,9 @@ class ClusterNode {
     this.registerAskEvents();
 
     if (this.countActiveNodes() < this.config.minimumNodes) {
-      global.kuzzle.log.info('[CLUSTER] Not enough nodes active. Waiting for other nodes to join the cluster...');
+      global.kuzzle.log.info(
+        "[CLUSTER] Not enough nodes active. Waiting for other nodes to join the cluster..."
+      );
 
       while (this.countActiveNodes() < this.config.minimumNodes) {
         await Bluebird.delay(100);
@@ -223,7 +235,7 @@ class ClusterNode {
    * Shutdown event: clears all timers, sends a termination status to other
    * nodes, and removes entries from the cache
    */
-  async shutdown () {
+  async shutdown() {
     clearInterval(this.heartbeatTimer);
     await this.idCardHandler.dispose();
 
@@ -244,7 +256,7 @@ class ClusterNode {
    * @param {number} lastMessageId - remote node last message ID
    * @return {boolean} false if the node was already known, true otherwise
    */
-  async addNode (id, ip, lastMessageId) {
+  async addNode(id, ip, lastMessageId) {
     if (this.remoteNodes.has(id)) {
       return false;
     }
@@ -259,11 +271,14 @@ class ClusterNode {
     global.kuzzle.log.info(`[CLUSTER] Node "${id}" joined the cluster`);
     this.trackActivity(id, ip, nodeActivityEnum.ADDED);
 
-    if ( global.kuzzle.state === kuzzleStateEnum.NOT_ENOUGH_NODES
-      && this.countActiveNodes() >= this.config.minimumNodes
+    if (
+      global.kuzzle.state === kuzzleStateEnum.NOT_ENOUGH_NODES &&
+      this.countActiveNodes() >= this.config.minimumNodes
     ) {
       global.kuzzle.state = kuzzleStateEnum.RUNNING;
-      global.kuzzle.log.warn(`[CLUSTER] Minimum number of nodes reached (${this.countActiveNodes()}). This node is now accepting requests again.`);
+      global.kuzzle.log.warn(
+        `[CLUSTER] Minimum number of nodes reached (${this.countActiveNodes()}). This node is now accepting requests again.`
+      );
     }
 
     return true;
@@ -276,7 +291,7 @@ class ClusterNode {
    * @param  {Error} [error]
    * @return {void}
    */
-  async evictSelf (reason, error = null) {
+  async evictSelf(reason, error = null) {
     global.kuzzle.log.error(`[CLUSTER] ${reason}`);
 
     if (error) {
@@ -295,19 +310,22 @@ class ClusterNode {
    * @param {boolean} [options.broadcast] - broadcast the eviction to the cluster
    * @param {string}  [options.reason] - reason of eviction
    */
-  async evictNode (nodeId, { broadcast = false, reason = '' }) {
+  async evictNode(nodeId, { broadcast = false, reason = "" }) {
     const subscriber = this.remoteNodes.get(nodeId);
 
-    if (! subscriber) {
+    if (!subscriber) {
       return;
     }
 
-    global.kuzzle.log.warn(`[CLUSTER] Node "${nodeId}" evicted. Reason: ${reason}`);
+    global.kuzzle.log.warn(
+      `[CLUSTER] Node "${nodeId}" evicted. Reason: ${reason}`
+    );
     this.trackActivity(
       nodeId,
       subscriber.remoteNodeIP,
       nodeActivityEnum.EVICTED,
-      reason);
+      reason
+    );
 
     await this.idCardHandler.removeNode(nodeId);
     this.remoteNodes.delete(nodeId);
@@ -320,7 +338,11 @@ class ClusterNode {
 
     if (this.countActiveNodes() < this.config.minimumNodes) {
       global.kuzzle.state = kuzzleStateEnum.NOT_ENOUGH_NODES;
-      global.kuzzle.log.warn(`[CLUSTER] Not enough nodes active (expected: ${this.config.minimumNodes}, active: ${this.countActiveNodes()}). Deactivating node until new ones are added.`);
+      global.kuzzle.log.warn(
+        `[CLUSTER] Not enough nodes active (expected: ${
+          this.config.minimumNodes
+        }, active: ${this.countActiveNodes()}). Deactivating node until new ones are added.`
+      );
     }
 
     this.enforceClusterConsistency();
@@ -333,7 +355,7 @@ class ClusterNode {
    * /!\ Do not wait for this method: it's meant to run as a background check.
    * It'll never throw, and it'll never generate unhandled rejections.
    */
-  async enforceClusterConsistency () {
+  async enforceClusterConsistency() {
     // Delay the check to 1 heartbeat round, to allow all nodes to update
     // their ID cards
     await Bluebird.delay(this.heartbeatDelay);
@@ -350,7 +372,7 @@ class ClusterNode {
 
         if (topology.length !== idCards.length) {
           topology = topology.sort();
-          const found = splits.some(split => {
+          const found = splits.some((split) => {
             if (split.length !== topology.length) {
               return false;
             }
@@ -358,7 +380,7 @@ class ClusterNode {
             return split.every((id, index) => id === topology[index]);
           });
 
-          if (! found) {
+          if (!found) {
             splits.push(topology);
           }
         }
@@ -382,21 +404,20 @@ class ClusterNode {
       // shut down.
 
       // First remove every non existing node from topologies
-      splits = splits.map(
-        topology => topology.filter(
-          nodeId => idCards.find(card => card.id === nodeId)
-        ));
+      splits = splits.map((topology) =>
+        topology.filter((nodeId) => idCards.find((card) => card.id === nodeId))
+      );
 
       splits = splits.sort((a, b) => a.length - b.length);
-      const eligibleSplits = splits
-        .filter(split => split.length === splits[0].length);
+      const eligibleSplits = splits.filter(
+        (split) => split.length === splits[0].length
+      );
 
       let candidates;
 
       if (eligibleSplits.length === 1) {
         candidates = eligibleSplits[0];
-      }
-      else {
+      } else {
         // Beware: search isolated nodes in ALL the splits, not only the
         // smallest ones
         let isolatedNodes = _.xor(...splits);
@@ -414,35 +435,37 @@ class ClusterNode {
         let youngestNode;
 
         for (let i = 0; i < isolatedNodes.length; i++) {
-          const idCard = idCards.find(card => card.id === isolatedNodes[i]);
-          if (! youngestNode || idCard.birthdate > youngestNode.birthdate) {
+          const idCard = idCards.find((card) => card.id === isolatedNodes[i]);
+          if (!youngestNode || idCard.birthdate > youngestNode.birthdate) {
             youngestNode = idCard;
           }
         }
 
         if (isIsolated) {
-          for (let i = 0; ! candidates && i < eligibleSplits.length; i++) {
+          for (let i = 0; !candidates && i < eligibleSplits.length; i++) {
             if (eligibleSplits[i].includes(youngestNode.id)) {
               candidates = _.intersection(eligibleSplits[i], isolatedNodes);
             }
           }
-        }
-        else {
+        } else {
           candidates = [youngestNode.id];
         }
       }
 
       if (candidates.includes(this.nodeId)) {
-        global.kuzzle.log.error('[CLUSTER] Network split detected. This node is outside the cluster: shutting down.');
+        global.kuzzle.log.error(
+          "[CLUSTER] Network split detected. This node is outside the cluster: shutting down."
+        );
         this.shutdownNode();
         return;
       }
 
       // Rerun the cluster consistency check
       await this.enforceClusterConsistency();
-    }
-    catch (err) {
-      global.kuzzle.log.error('[CLUSTER] Unexpected exception caught during a cluster consistency check. Shutting down...');
+    } catch (err) {
+      global.kuzzle.log.error(
+        "[CLUSTER] Unexpected exception caught during a cluster consistency check. Shutting down..."
+      );
       global.kuzzle.log.error(err.stack);
       this.shutdownNode();
     }
@@ -455,15 +478,15 @@ class ClusterNode {
    *
    * @return {void}
    */
-  async handshake () {
-    const handshakeTimeout = setTimeout(
-      () => {
-        global.kuzzle.log.error(`[CLUSTER] Failed to join the cluster: timed out (joinTimeout: ${this.config.joinTimeout}ms)`);
-        this.shutdownNode();
-      },
-      this.config.joinTimeout);
+  async handshake() {
+    const handshakeTimeout = setTimeout(() => {
+      global.kuzzle.log.error(
+        `[CLUSTER] Failed to join the cluster: timed out (joinTimeout: ${this.config.joinTimeout}ms)`
+      );
+      this.shutdownNode();
+    }, this.config.joinTimeout);
 
-    const mutex = new Mutex('clusterHandshake', {
+    const mutex = new Mutex("clusterHandshake", {
       timeout: this.config.joinTimeout,
     });
 
@@ -474,21 +497,21 @@ class ClusterNode {
       // to prevent race conditions (other nodes attempting to connect to this
       // node while it's still initializing)
       await this.idCardHandler.createIdCard();
-      debug('[CLUSTER] ID Card created');
+      debug("[CLUSTER] ID Card created");
 
       this.nodeId = this.idCardHandler.nodeId;
 
       await this.startHeartbeat();
-      debug('[CLUSTER] Start heartbeat');
+      debug("[CLUSTER] Start heartbeat");
 
       let retried = false;
       let fullState = null;
       let nodes;
 
-      debug('[CLUSTER] Start retrieving full state..');
+      debug("[CLUSTER] Start retrieving full state..");
       do {
         nodes = await this.idCardHandler.getRemoteIdCards();
-        debug('[CLUSTER] %s remote nodes discovered', nodes.length);
+        debug("[CLUSTER] %s remote nodes discovered", nodes.length);
 
         // No other nodes detected = no handshake required
         if (nodes.length === 0) {
@@ -497,10 +520,12 @@ class ClusterNode {
         }
 
         // Verify that no other node share the same IP address as this one
-        const duplicate = nodes.filter(node => node.ip === this.ip);
+        const duplicate = nodes.filter((node) => node.ip === this.ip);
 
         if (duplicate.length > 0) {
-          global.kuzzle.log.error(`[CLUSTER] Another node share the same IP address as this one (${this.ip}): ${duplicate[0].id}. Shutting down.`);
+          global.kuzzle.log.error(
+            `[CLUSTER] Another node share the same IP address as this one (${this.ip}): ${duplicate[0].id}. Shutting down.`
+          );
           this.shutdownNode();
           return;
         }
@@ -511,7 +536,7 @@ class ClusterNode {
           this.remoteNodes.set(id, subscriber);
           return subscriber.init();
         });
-        debug('[CLUSTER] Successfully subscribed to nodes');
+        debug("[CLUSTER] Successfully subscribed to nodes");
 
         fullState = await this.command.getFullState(nodes);
 
@@ -522,7 +547,9 @@ class ClusterNode {
         // down.
         if (fullState === null) {
           if (retried) {
-            global.kuzzle.log.error('[CLUSTER] Could not connect to discovered cluster nodes (network split detected). Shutting down.');
+            global.kuzzle.log.error(
+              "[CLUSTER] Could not connect to discovered cluster nodes (network split detected). Shutting down."
+            );
             this.shutdownNode();
             return;
           }
@@ -536,57 +563,58 @@ class ClusterNode {
           // Waits for a redis heartbeat round
           retried = true;
           const retryDelay = this.heartbeatDelay * 1.5;
-          global.kuzzle.log.warn(`[CLUSTER] Unable to connect to discovered cluster nodes. Retrying in ${retryDelay}ms...`);
+          global.kuzzle.log.warn(
+            `[CLUSTER] Unable to connect to discovered cluster nodes. Retrying in ${retryDelay}ms...`
+          );
           await Bluebird.delay(retryDelay);
         }
-      }
-      while (fullState === null);
-      debug('[CLUSTER] Fullstate retrieved, loading into node..');
+      } while (fullState === null);
+      debug("[CLUSTER] Fullstate retrieved, loading into node..");
 
       await this.fullState.loadFullState(fullState);
-      this.activity = fullState.activity
-        ? fullState.activity
-        : this.activity;
+      this.activity = fullState.activity ? fullState.activity : this.activity;
 
-      debug('[CLUSTER] Fullstate loaded.');
+      debug("[CLUSTER] Fullstate loaded.");
 
       const handshakeResponses = await this.command.broadcastHandshake(nodes);
 
-      debug('[CLUSTER] Successful handshakes with other nodes.');
+      debug("[CLUSTER] Successful handshakes with other nodes.");
 
       // Update subscribers: start synchronizing, or unsubscribes from nodes who
       // didn't respond
-      for (const [nodeId, handshakeData] of Object.entries(handshakeResponses)) {
+      for (const [nodeId, handshakeData] of Object.entries(
+        handshakeResponses
+      )) {
         const subscriber = this.remoteNodes.get(nodeId);
         if (handshakeData === null) {
           subscriber.dispose();
           this.remoteNodes.delete(nodeId);
-        }
-        else {
+        } else {
           await this.idCardHandler.addNode(nodeId);
           const nodesStates = fullState.nodesState || [];
-          const nodeStatus = nodesStates.find(node => node.id === nodeId);
-          subscriber.sync(nodeStatus
-            ? nodeStatus.lastMessageId
-            : handshakeData.lastMessageId);
-          global.kuzzle.log.info(`[CLUSTER] Successfully completed the handshake with node ${nodeId}`);
+          const nodeStatus = nodesStates.find((node) => node.id === nodeId);
+          subscriber.sync(
+            nodeStatus ? nodeStatus.lastMessageId : handshakeData.lastMessageId
+          );
+          global.kuzzle.log.info(
+            `[CLUSTER] Successfully completed the handshake with node ${nodeId}`
+          );
         }
       }
 
-      global.kuzzle.log.info('[CLUSTER] Successfully joined the cluster.');
+      global.kuzzle.log.info("[CLUSTER] Successfully joined the cluster.");
       this.trackActivity(this.nodeId, this.ip, nodeActivityEnum.ADDED);
-    }
-    finally {
+    } finally {
       clearTimeout(handshakeTimeout);
       await mutex.unlock();
     }
   }
 
-  countActiveNodes () {
+  countActiveNodes() {
     return this.remoteNodes.size + 1;
   }
 
-  startHeartbeat () {
+  startHeartbeat() {
     this.heartbeatTimer = setInterval(() => {
       this.publisher.sendHeartbeat(this.syncAddress);
     }, this.heartbeatDelay);
@@ -600,14 +628,14 @@ class ClusterNode {
    * @param {nodeActivityEnum} event
    * @param {string} [reason]
    */
-  trackActivity (id, ip, event, reason) {
+  trackActivity(id, ip, event, reason) {
     if (this.activity.length > this.activityMaxLength) {
       this.activity.shift();
     }
 
     this.activity.push({
       address: ip,
-      date: (new Date()).toISOString(),
+      date: new Date().toISOString(),
       event,
       id,
       reason,
@@ -618,13 +646,13 @@ class ClusterNode {
    * Returns the full status of the cluster
    * @return {Object}
    */
-  async getStatus () {
+  async getStatus() {
     const status = {
       activeNodes: 0,
       activity: this.activity.map(({ address, date, event, id, reason }) => ({
         address,
         date,
-        event: event === nodeActivityEnum.ADDED ? 'joined' : 'evicted',
+        event: event === nodeActivityEnum.ADDED ? "joined" : "evicted",
         id,
         reason,
       })),
@@ -649,7 +677,7 @@ class ClusterNode {
   /**
    * Registers ask events
    */
-  registerAskEvents () {
+  registerAskEvents() {
     /**
      * Removes a room from the full state, and only for this node.
      * Removes the room from Koncorde if, and only if, no other node uses it.
@@ -657,9 +685,9 @@ class ClusterNode {
      * @param  {string} roomId
      * @return {void}
      */
-    global.kuzzle.onAsk(
-      'cluster:realtime:room:remove',
-      roomId => this.removeRealtimeRoom(roomId));
+    global.kuzzle.onAsk("cluster:realtime:room:remove", (roomId) =>
+      this.removeRealtimeRoom(roomId)
+    );
 
     /**
      * Returns the total number of subscribers on all nodes for the provided
@@ -668,18 +696,18 @@ class ClusterNode {
      * @param {string} roomId
      * @returns {Number}
      */
-    global.kuzzle.onAsk(
-      'cluster:realtime:room:count',
-      roomId => this.countRealtimeSubscribers(roomId));
+    global.kuzzle.onAsk("cluster:realtime:room:count", (roomId) =>
+      this.countRealtimeSubscribers(roomId)
+    );
 
     /**
      * Returns the list of existing rooms in the cluster
      *
      * @returns {Object}
      */
-    global.kuzzle.onAsk(
-      'cluster:realtime:room:list',
-      () => this.fullState.listRealtimeRooms());
+    global.kuzzle.onAsk("cluster:realtime:room:list", () =>
+      this.fullState.listRealtimeRooms()
+    );
 
     /**
      * Returns the requested room. Used to create a room on the fly on this node
@@ -688,9 +716,9 @@ class ClusterNode {
      * @param {string} roomId
      * @returns {NormalizedFilter}
      */
-    global.kuzzle.onAsk(
-      'cluster:realtime:filters:get',
-      roomId => this.fullState.getNormalizedFilters(roomId));
+    global.kuzzle.onAsk("cluster:realtime:filters:get", (roomId) =>
+      this.fullState.getNormalizedFilters(roomId)
+    );
 
     /**
      * Broadcasts an event to other nodes
@@ -698,9 +726,9 @@ class ClusterNode {
      * @param {string} event name
      * @param {Object} payload - event payload
      */
-    global.kuzzle.onAsk(
-      'cluster:event:broadcast',
-      (event, payload) => this.broadcast(event, payload));
+    global.kuzzle.onAsk("cluster:event:broadcast", (event, payload) =>
+      this.broadcast(event, payload)
+    );
 
     /**
      * Listens to a cluster-wide event
@@ -708,9 +736,9 @@ class ClusterNode {
      * @param {string} event name
      * @param {Function} fn - event listener
      */
-    global.kuzzle.onAsk(
-      'cluster:event:on',
-      (event, fn) => this.eventEmitter.on(event, fn));
+    global.kuzzle.onAsk("cluster:event:on", (event, fn) =>
+      this.eventEmitter.on(event, fn)
+    );
 
     /**
      * Listens to a cluster-wide event once.
@@ -718,9 +746,9 @@ class ClusterNode {
      * @param {string} event name
      * @param {Function} fn - event listener
      */
-    global.kuzzle.onAsk(
-      'cluster:event:once',
-      (event, fn) => this.eventEmitter.once(event, fn));
+    global.kuzzle.onAsk("cluster:event:once", (event, fn) =>
+      this.eventEmitter.once(event, fn)
+    );
 
     /**
      * Removes a listener from an event
@@ -728,23 +756,23 @@ class ClusterNode {
      * @param {string} event name
      * @param {Function} fn - event listener
      */
-    global.kuzzle.onAsk(
-      'cluster:event:off',
-      (event, fn) => this.eventEmitter.removeListener(event, fn));
+    global.kuzzle.onAsk("cluster:event:off", (event, fn) =>
+      this.eventEmitter.removeListener(event, fn)
+    );
 
     /**
      * Removes all listeners from an event
      *
      * @param {string} event name
      */
-    global.kuzzle.onAsk(
-      'cluster:event:removeAllListeners',
-      event => this.eventEmitter.removeAllListeners(event));
+    global.kuzzle.onAsk("cluster:event:removeAllListeners", (event) =>
+      this.eventEmitter.removeAllListeners(event)
+    );
 
     /**
      * Returns the full status of the cluster
      */
-    global.kuzzle.onAsk('cluster:status:get', () => this.getStatus());
+    global.kuzzle.onAsk("cluster:status:get", () => this.getStatus());
   }
 
   /**
@@ -752,121 +780,118 @@ class ClusterNode {
    *
    * @return {void}
    */
-  registerEvents () {
-    global.kuzzle.on(
-      'admin:afterRefreshIndexCache',
-      () => this.onIndexCacheRefreshed());
+  registerEvents() {
+    global.kuzzle.on("admin:afterRefreshIndexCache", () =>
+      this.onIndexCacheRefreshed()
+    );
 
-    global.kuzzle.onCall(
-      'core:realtime:room:create:after',
-      payload => this.onNewRealtimeRoom(payload));
+    global.kuzzle.onCall("core:realtime:room:create:after", (payload) =>
+      this.onNewRealtimeRoom(payload)
+    );
 
-    global.kuzzle.onCall(
-      'core:realtime:subscribe:after',
-      roomId => this.onNewSubscription(roomId));
+    global.kuzzle.onCall("core:realtime:subscribe:after", (roomId) =>
+      this.onNewSubscription(roomId)
+    );
 
-    global.kuzzle.onCall(
-      'core:realtime:unsubscribe:after',
-      roomId => this.onUnsubscription(roomId));
+    global.kuzzle.onCall("core:realtime:unsubscribe:after", (roomId) =>
+      this.onUnsubscription(roomId)
+    );
 
-    global.kuzzle.on(
-      'core:notify:document',
-      ({ notification, rooms }) => {
-        this.onDocumentNotification(rooms, notification);
-      });
+    global.kuzzle.on("core:notify:document", ({ notification, rooms }) => {
+      this.onDocumentNotification(rooms, notification);
+    });
 
-    global.kuzzle.on(
-      'core:notify:user',
-      ({ notification, room }) => this.onUserNotification(room, notification));
+    global.kuzzle.on("core:notify:user", ({ notification, room }) =>
+      this.onUserNotification(room, notification)
+    );
 
     global.kuzzle.on(
-      'core:auth:strategyAdded',
+      "core:auth:strategyAdded",
       ({ name, pluginName, strategy }) => {
         this.onAuthStrategyAdded(name, pluginName, strategy);
-      });
+      }
+    );
 
-    global.kuzzle.on(
-      'core:auth:strategyRemoved',
-      ({ name, pluginName }) => this.onAuthStrategyRemoved(name, pluginName));
+    global.kuzzle.on("core:auth:strategyRemoved", ({ name, pluginName }) =>
+      this.onAuthStrategyRemoved(name, pluginName)
+    );
 
-    global.kuzzle.on(
-      'admin:afterDump',
-      suffix => this.onDumpRequest(suffix));
+    global.kuzzle.on("admin:afterDump", (suffix) => this.onDumpRequest(suffix));
 
-    global.kuzzle.on(
-      'admin:afterResetSecurity',
-      () => this.onSecurityReset());
+    global.kuzzle.on("admin:afterResetSecurity", () => this.onSecurityReset());
 
-    global.kuzzle.on(
-      'admin:afterShutdown',
-      () => this.onShutdown());
+    global.kuzzle.on("admin:afterShutdown", () => this.onShutdown());
 
-    global.kuzzle.on(
-      'collection:afterDeleteSpecifications',
-      () => this.onValidatorsChanged());
+    global.kuzzle.on("collection:afterDeleteSpecifications", () =>
+      this.onValidatorsChanged()
+    );
 
-    global.kuzzle.on(
-      'collection:afterUpdateSpecifications',
-      () => this.onValidatorsChanged());
+    global.kuzzle.on("collection:afterUpdateSpecifications", () =>
+      this.onValidatorsChanged()
+    );
 
     // Profile change events
-    global.kuzzle.on(
-      'core:security:profile:create',
-      ({ args: [ profileId ] }) => this.onProfileChanged(profileId));
+    global.kuzzle.on("core:security:profile:create", ({ args: [profileId] }) =>
+      this.onProfileChanged(profileId)
+    );
 
     global.kuzzle.on(
-      'core:security:profile:createOrReplace',
-      ({ args: [ profileId ] }) => this.onProfileChanged(profileId));
+      "core:security:profile:createOrReplace",
+      ({ args: [profileId] }) => this.onProfileChanged(profileId)
+    );
 
-    global.kuzzle.on(
-      'core:security:profile:update',
-      ({ args: [ profileId ] }) => this.onProfileChanged(profileId));
+    global.kuzzle.on("core:security:profile:update", ({ args: [profileId] }) =>
+      this.onProfileChanged(profileId)
+    );
 
-    global.kuzzle.on(
-      'core:security:profile:delete',
-      ({ args: [ profileId ] }) => this.onProfileChanged(profileId));
+    global.kuzzle.on("core:security:profile:delete", ({ args: [profileId] }) =>
+      this.onProfileChanged(profileId)
+    );
 
     // Role change events
-    global.kuzzle.on(
-      'core:security:role:create',
-      ({ args: [ roleId ] }) => this.onRoleChanged(roleId));
+    global.kuzzle.on("core:security:role:create", ({ args: [roleId] }) =>
+      this.onRoleChanged(roleId)
+    );
 
     global.kuzzle.on(
-      'core:security:role:createOrReplace',
-      ({ args: [ roleId ] }) => this.onRoleChanged(roleId));
+      "core:security:role:createOrReplace",
+      ({ args: [roleId] }) => this.onRoleChanged(roleId)
+    );
 
-    global.kuzzle.on(
-      'core:security:role:update',
-      ({ args: [ roleId ] }) => this.onRoleChanged(roleId));
+    global.kuzzle.on("core:security:role:update", ({ args: [roleId] }) =>
+      this.onRoleChanged(roleId)
+    );
 
-    global.kuzzle.on(
-      'core:security:role:delete',
-      ({ args: [ roleId ] }) => this.onRoleChanged(roleId));
+    global.kuzzle.on("core:security:role:delete", ({ args: [roleId] }) =>
+      this.onRoleChanged(roleId)
+    );
 
     // Index cache change events
-    global.kuzzle.on(
-      'core:storage:index:create:after',
-      ({ index, scope }) => this.onIndexAdded(scope, index));
+    global.kuzzle.on("core:storage:index:create:after", ({ index, scope }) =>
+      this.onIndexAdded(scope, index)
+    );
 
-    global.kuzzle.on(
-      'core:storage:index:delete:after',
-      ({ index, scope }) => this.onIndexesRemoved(scope, [ index ]));
+    global.kuzzle.on("core:storage:index:delete:after", ({ index, scope }) =>
+      this.onIndexesRemoved(scope, [index])
+    );
 
-    global.kuzzle.on(
-      'core:storage:index:mDelete:after',
-      ({ indexes, scope }) => this.onIndexesRemoved(scope, indexes));
+    global.kuzzle.on("core:storage:index:mDelete:after", ({ indexes, scope }) =>
+      this.onIndexesRemoved(scope, indexes)
+    );
 
     global.kuzzle.on(
-      'core:storage:collection:create:after',
+      "core:storage:collection:create:after",
       ({ collection, index, scope }) => {
         this.onCollectionAdded(scope, index, collection);
-      });
+      }
+    );
 
     global.kuzzle.on(
-      'core:storage:collection:delete:after',
+      "core:storage:collection:delete:after",
       ({ collection, index, scope }) => {
         this.onCollectionRemoved(scope, index, collection);
-      });
+      }
+    );
   }
 
   /**
@@ -875,14 +900,15 @@ class ClusterNode {
    * @param  {NormalizedFilter} payload
    * @return {void}
    */
-  onNewRealtimeRoom (payload) {
+  onNewRealtimeRoom(payload) {
     const roomMessageId = this.publisher.sendNewRealtimeRoom(payload);
 
     debug(
-      '[%s] Broadcasting new realtime room %s (message: %d)',
+      "[%s] Broadcasting new realtime room %s (message: %d)",
       this.nodeId,
       payload.id,
-      roomMessageId);
+      roomMessageId
+    );
 
     const icpair = fromKoncordeIndex(payload.index);
 
@@ -895,7 +921,8 @@ class ClusterNode {
         messageId: roomMessageId,
         nodeId: this.nodeId,
         subscribers: 0,
-      });
+      }
+    );
   }
 
   /**
@@ -904,14 +931,15 @@ class ClusterNode {
    * @param  {string} roomId
    * @return {void}
    */
-  onNewSubscription (roomId) {
+  onNewSubscription(roomId) {
     const subMessageId = this.publisher.sendSubscription(roomId);
 
     debug(
-      '[%s] Broadcasting new realtime subscription on room %s (message: %d)',
+      "[%s] Broadcasting new realtime subscription on room %s (message: %d)",
       this.nodeId,
       roomId,
-      subMessageId);
+      subMessageId
+    );
 
     this.fullState.addRealtimeSubscription(roomId, this.nodeId, subMessageId);
   }
@@ -922,15 +950,16 @@ class ClusterNode {
    * @param  {string} roomId
    * @return {void}
    */
-  removeRealtimeRoom (roomId) {
+  removeRealtimeRoom(roomId) {
     const messageId = this.publisher.sendRemoveRealtimeRoom(roomId);
-    
+
     debug(
-      '[%s] Broadcasted the removal of room %s (message: %d)',
+      "[%s] Broadcasted the removal of room %s (message: %d)",
       this.nodeId,
       roomId,
-      messageId);
-      
+      messageId
+    );
+
     this.fullState.removeRealtimeRoom(roomId, this.nodeId);
   }
 
@@ -940,14 +969,15 @@ class ClusterNode {
    * @param {string} event name
    * @param {Object} payload - event payload
    */
-  broadcast (event, payload) {
+  broadcast(event, payload) {
     const messageId = this.publisher.sendClusterWideEvent(event, payload);
 
     debug(
       '[%s] Emitted cluster-wide event "%s" (message: %d)',
       this.nodeId,
       event,
-      messageId);
+      messageId
+    );
   }
 
   /**
@@ -956,14 +986,15 @@ class ClusterNode {
    * @param  {string} roomId
    * @return {void}
    */
-  onUnsubscription (roomId) {
+  onUnsubscription(roomId) {
     const messageId = this.publisher.sendUnsubscription(roomId);
 
     debug(
-      '[%s] Broadcasting realtime unsubscription on room %s (message: %d)',
+      "[%s] Broadcasting realtime unsubscription on room %s (message: %d)",
       this.nodeId,
       roomId,
-      messageId);
+      messageId
+    );
 
     this.fullState.removeRealtimeSubscription(roomId, this.nodeId, messageId);
   }
@@ -975,7 +1006,7 @@ class ClusterNode {
    * @param  {DocumentNotification} notification
    * @return {void}
    */
-  onDocumentNotification (rooms, notification) {
+  onDocumentNotification(rooms, notification) {
     this.publisher.sendDocumentNotification(rooms, notification);
   }
 
@@ -986,7 +1017,7 @@ class ClusterNode {
    * @param  {UserNotification} notification
    * @return {void}
    */
-  onUserNotification (room, notification) {
+  onUserNotification(room, notification) {
     this.publisher.sendUserNotification(room, notification);
   }
 
@@ -998,11 +1029,12 @@ class ClusterNode {
    * @param  {Object} strategyObject
    * @return {void}
    */
-  onAuthStrategyAdded (strategyName, pluginName, strategyObject) {
+  onAuthStrategyAdded(strategyName, pluginName, strategyObject) {
     this.publisher.sendNewAuthStrategy(
       strategyName,
       pluginName,
-      strategyObject);
+      strategyObject
+    );
 
     this.fullState.addAuthStrategy({
       pluginName,
@@ -1018,7 +1050,7 @@ class ClusterNode {
    * @param  {string} pluginName
    * @return {void}
    */
-  onAuthStrategyRemoved (strategyName, pluginName) {
+  onAuthStrategyRemoved(strategyName, pluginName) {
     this.publisher.sendRemoveAuthStrategy(strategyName, pluginName);
 
     this.fullState.removeAuthStrategy(strategyName);
@@ -1030,7 +1062,7 @@ class ClusterNode {
    * @param  {string} suffix
    * @return {void}
    */
-  onDumpRequest (suffix) {
+  onDumpRequest(suffix) {
     this.publisher.sendDumpRequest(suffix);
   }
 
@@ -1039,8 +1071,8 @@ class ClusterNode {
    *
    * @return {void}
    */
-  onSecurityReset () {
-    this.publisher.send('ResetSecurity', {});
+  onSecurityReset() {
+    this.publisher.send("ResetSecurity", {});
   }
 
   /**
@@ -1048,8 +1080,8 @@ class ClusterNode {
    *
    * @return {void}
    */
-  onValidatorsChanged () {
-    this.publisher.send('RefreshValidators', {});
+  onValidatorsChanged() {
+    this.publisher.send("RefreshValidators", {});
   }
 
   /**
@@ -1058,8 +1090,8 @@ class ClusterNode {
    * @param  {string} profileId
    * @return {void}
    */
-  onProfileChanged (profileId) {
-    this.publisher.send('InvalidateProfile', { profileId });
+  onProfileChanged(profileId) {
+    this.publisher.send("InvalidateProfile", { profileId });
   }
 
   /**
@@ -1068,8 +1100,8 @@ class ClusterNode {
    * @param {string} roleId
    * @return {void}
    */
-  onRoleChanged (roleId) {
-    this.publisher.send('InvalidateRole', { roleId });
+  onRoleChanged(roleId) {
+    this.publisher.send("InvalidateRole", { roleId });
   }
 
   /**
@@ -1079,7 +1111,7 @@ class ClusterNode {
    * @param  {string} index
    * @return {void}
    */
-  onIndexAdded (scope, index) {
+  onIndexAdded(scope, index) {
     this.publisher.sendAddIndex(scope, index);
   }
 
@@ -1091,7 +1123,7 @@ class ClusterNode {
    * @param  {string} collection
    * @return {void}
    */
-  onCollectionAdded (scope, index, collection) {
+  onCollectionAdded(scope, index, collection) {
     this.publisher.sendAddCollection(scope, index, collection);
   }
 
@@ -1102,7 +1134,7 @@ class ClusterNode {
    * @param  {Array.<string>} indexes
    * @return {void}
    */
-  onIndexesRemoved (scope, indexes) {
+  onIndexesRemoved(scope, indexes) {
     this.publisher.sendRemoveIndexes(scope, indexes);
   }
 
@@ -1114,7 +1146,7 @@ class ClusterNode {
    * @param  {string} collection
    * @return {void}
    */
-  onCollectionRemoved (scope, index, collection) {
+  onCollectionRemoved(scope, index, collection) {
     this.publisher.sendRemoveCollection(scope, index, collection);
   }
 
@@ -1123,15 +1155,15 @@ class ClusterNode {
    *
    * @return {void}
    */
-  onShutdown () {
-    this.publisher.send('Shutdown', {});
+  onShutdown() {
+    this.publisher.send("Shutdown", {});
   }
 
   /**
    * Triggered when the index cache has been manually refreshed
    */
-  onIndexCacheRefreshed () {
-    this.publisher.send('RefreshIndexCache', {});
+  onIndexCacheRefreshed() {
+    this.publisher.send("RefreshIndexCache", {});
   }
 
   /**
@@ -1140,12 +1172,12 @@ class ClusterNode {
    *
    * @param {string} roomId
    * @return {void}
-  */
-  async countRealtimeSubscribers (roomId) {
+   */
+  async countRealtimeSubscribers(roomId) {
     return this.fullState.countRealtimeSubscriptions(roomId);
   }
 
-  shutdownNode () {
+  shutdownNode() {
     global.kuzzle.log.error(JSON.stringify(this.fullState.serialize()));
     global.kuzzle.shutdown();
   }