kuzzle 2.19.2 → 2.19.3

package/lib/cluster/subscriber.js

@@ -19,17 +19,17 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { Subscriber } = require('zeromq');
-const protobuf = require('protobufjs');
-const Long = require('long');
+const { Subscriber } = require("zeromq");
+const protobuf = require("protobufjs");
+const Long = require("long");
 
-const debug = require('../util/debug')('kuzzle:cluster:sync');
-const DocumentNotification = require('../core/realtime/notification/document');
-const UserNotification = require('../core/realtime/notification/user');
-const { has } = require('../util/safeObject');
-const { fromKoncordeIndex } = require('../util/koncordeCompat');
+const debug = require("../util/debug")("kuzzle:cluster:sync");
+const DocumentNotification = require("../core/realtime/notification/document");
+const UserNotification = require("../core/realtime/notification/user");
+const { has } = require("../util/safeObject");
+const { fromKoncordeIndex } = require("../util/koncordeCompat");
 
 /* eslint-disable sort-keys */
 const stateEnum = Object.freeze({
@@ -48,7 +48,7 @@ class ClusterSubscriber {
    * @param {string} remoteNodeId - Remote node unique ID
    * @param {string} remoteNodeIP - address of the distant node
    */
-  constructor (localNode, remoteNodeId, remoteNodeIP) {
+  constructor(localNode, remoteNodeId, remoteNodeIP) {
     // not to be confused with remote nodes
     this.localNode = localNode;
 
@@ -106,14 +106,15 @@ class ClusterSubscriber {
    * Initializes this class, establishes a connection to the remote node and
    * starts listening to it.
    */
-  async init () {
+  async init() {
     this.protoroot = await protobuf.load(`${__dirname}/protobuf/sync.proto`);
     this.socket = new Subscriber();
     this.socket.connect(this.remoteNodeAddress);
     this.socket.subscribe();
     this.heartbeatTimer = setInterval(
       () => this.checkHeartbeat(),
-      this.heartbeatDelay);
+      this.heartbeatDelay
+    );
 
     this.listen();
   }
@@ -123,15 +124,14 @@ class ClusterSubscriber {
    * Do NOT wait this method: it's an infinite loop, it's not meant to ever
    * return (unless the remote node has been evicted)
    */
-  async listen () {
+  async listen() {
     while (this.state !== stateEnum.EVICTED) {
       let topic;
       let data;
 
       try {
         [topic, data] = await this.socket.receive();
-      }
-      catch (e) {
+      } catch (e) {
         if (this.state !== stateEnum.EVICTED) {
           await this.evictNode({
             broadcast: true,
@@ -150,8 +150,7 @@ class ClusterSubscriber {
 
       if (this.state !== stateEnum.BUFFERING) {
         await this.processData(topic.toString(), data);
-      }
-      else {
+      } else {
         this.buffer.push([topic.toString(), data]);
       }
     }
@@ -164,7 +163,7 @@ class ClusterSubscriber {
    * @param  {Long} lastMessageId
    * @return {void}
    */
-  async sync (lastMessageId) {
+  async sync(lastMessageId) {
     this.lastMessageId = lastMessageId;
 
     // copy the buffer for processing: new sync messages might be buffered
@@ -194,7 +193,7 @@ class ClusterSubscriber {
    * @param  {Buffer} data
    * @return {void}
    */
-  async processData (topic, data) {
+  async processData(topic, data) {
     if (this.state === stateEnum.EVICTED) {
       return;
     }
@@ -211,20 +210,22 @@ class ClusterSubscriber {
 
     const message = decoder.toObject(decoder.decode(data));
 
-    if (! await this.validateMessage(message)) {
+    if (!(await this.validateMessage(message))) {
       return;
     }
 
     try {
-      // If we are receiving messages from a node, 
+      // If we are receiving messages from a node,
       // it means the node is alive so it should counts as an heartbeat
       this.handleHeartbeat();
       await this.handlers[topic].call(this, message);
-    }
-    catch (e) {
+    } catch (e) {
       this.localNode.evictSelf(
-        `Unable to process sync message (topic: ${topic}, message: ${JSON.stringify(message)}`,
-        e);
+        `Unable to process sync message (topic: ${topic}, message: ${JSON.stringify(
+          message
+        )}`,
+        e
+      );
     }
   }
 
@@ -233,7 +234,7 @@ class ClusterSubscriber {
    *
    * @return {void}
    */
-  handleHeartbeat () {
+  handleHeartbeat() {
     this.lastHeartbeat = Date.now();
   }
 
@@ -243,9 +244,11 @@ class ClusterSubscriber {
    * @param  {Object} message - decoded NodeEvicted protobuf message
    * @return {void}
    */
-  async handleNodeEviction (message) {
+  async handleNodeEviction(message) {
     if (message.nodeId === this.localNode.nodeId) {
-      global.kuzzle.log.error(`[CLUSTER] Node evicted by ${message.evictor}. Reason: ${message.reason}`);
+      global.kuzzle.log.error(
+        `[CLUSTER] Node evicted by ${message.evictor}. Reason: ${message.reason}`
+      );
       global.kuzzle.shutdown();
       return;
     }
@@ -262,10 +265,10 @@ class ClusterSubscriber {
    * @param  {Object} message - decoded NodeShutdown protobuf message
    * @return {void}
    */
-  async handleNodeShutdown (message) {
+  async handleNodeShutdown(message) {
     await this.localNode.evictNode(message.nodeId, {
       broadcast: false,
-      reason: 'Node is shutting down',
+      reason: "Node is shutting down",
     });
   }
 
@@ -275,17 +278,18 @@ class ClusterSubscriber {
    * @param  {Object} message - decoded NewRealtimeRoom protobuf message
    * @return {void}
    */
-  handleNewRealtimeRoom (message) {
+  handleNewRealtimeRoom(message) {
     const { id, index, filter, messageId } = message;
     const icpair = fromKoncordeIndex(index);
 
     debug(
-      'New realtime room created by node %s (message: %d, room: %s, index: %s, collection: %s)',
+      "New realtime room created by node %s (message: %d, room: %s, index: %s, collection: %s)",
       this.remoteNodeId,
       messageId,
       id,
       icpair.index,
-      icpair.collection);
+      icpair.collection
+    );
 
     this.localNode.fullState.addRealtimeRoom(
       id,
@@ -296,7 +300,8 @@ class ClusterSubscriber {
         messageId,
         nodeId: this.remoteNodeId,
         subscribers: 0,
-      });
+      }
+    );
   }
 
   /**
@@ -305,16 +310,19 @@ class ClusterSubscriber {
    * @param  {Object} message - decoded Subscription protobuf message
    * @return {void}
    */
-  handleSubscription (message) {
-    debug('New realtime subscription received from node %s (message: %d, room: %s)',
+  handleSubscription(message) {
+    debug(
+      "New realtime subscription received from node %s (message: %d, room: %s)",
       this.remoteNodeId,
       message.messageId,
-      message.roomId);
+      message.roomId
+    );
 
     this.localNode.fullState.addRealtimeSubscription(
       message.roomId,
       this.remoteNodeId,
-      message.messageId);
+      message.messageId
+    );
   }
 
   /**
@@ -323,13 +331,18 @@ class ClusterSubscriber {
    * @param  {Object} message - decoded RemoveRealtimeRoom protobuf message
    * @return {void}
    */
-  handleRealtimeRoomRemoval (message) {
-    debug('Realtime room removal received from node %s (message: %d, room: %s)',
+  handleRealtimeRoomRemoval(message) {
+    debug(
+      "Realtime room removal received from node %s (message: %d, room: %s)",
       this.remoteNodeId,
       message.messageId,
-      message.roomId);
+      message.roomId
+    );
 
-    this.localNode.fullState.removeRealtimeRoom(message.roomId, this.remoteNodeId);
+    this.localNode.fullState.removeRealtimeRoom(
+      message.roomId,
+      this.remoteNodeId
+    );
   }
 
   /**
@@ -338,16 +351,19 @@ class ClusterSubscriber {
    * @param  {Object} message - decoded Unscription protobuf message
    * @return {void}
    */
-  handleUnsubscription (message) {
-    debug('Realtime unsubscription received from node %s (message: %d, room: %s)',
+  handleUnsubscription(message) {
+    debug(
+      "Realtime unsubscription received from node %s (message: %d, room: %s)",
       this.remoteNodeId,
       message.messageId,
-      message.roomId);
+      message.roomId
+    );
 
     this.localNode.fullState.removeRealtimeSubscription(
       message.roomId,
       this.remoteNodeId,
-      message.messageId);
+      message.messageId
+    );
   }
 
   /**
@@ -356,7 +372,7 @@ class ClusterSubscriber {
    * @param {Object} message - decoded ClusterWideEvent protobuf message
    * @return {void}
    */
-  handleClusterWideEvent (message) {
+  handleClusterWideEvent(message) {
     const payload = JSON.parse(message.payload);
 
     this.localNode.eventEmitter.emit(message.event, payload);
@@ -368,7 +384,7 @@ class ClusterSubscriber {
    * @param {Object} message - decoded DocumentNotification protobuf message
    * @return {void}
    */
-  async handleDocumentNotification (message) {
+  async handleDocumentNotification(message) {
     const notification = new DocumentNotification({
       action: message.action,
       collection: message.collection,
@@ -385,9 +401,10 @@ class ClusterSubscriber {
     });
 
     return global.kuzzle.ask(
-      'core:realtime:document:dispatch',
+      "core:realtime:document:dispatch",
       message.rooms,
-      notification);
+      notification
+    );
   }
 
   /**
@@ -396,7 +413,7 @@ class ClusterSubscriber {
    * @param {Object} message - decoded UserNotification protobuf message
    * @return {void}
    */
-  async handleUserNotification (message) {
+  async handleUserNotification(message) {
     const notification = new UserNotification({
       action: message.action,
       collection: message.collection,
@@ -412,9 +429,10 @@ class ClusterSubscriber {
     });
 
     return global.kuzzle.ask(
-      'core:realtime:user:sendMessage',
+      "core:realtime:user:sendMessage",
       message.room,
-      notification);
+      notification
+    );
   }
 
   /**
@@ -423,21 +441,23 @@ class ClusterSubscriber {
    * @param  {Object} message - decoded NewAuthStrategy protobuf message
    * @return {void}
    */
-  handleNewAuthStrategy (message) {
+  handleNewAuthStrategy(message) {
     const { pluginName, strategy, strategyName } = message;
 
     debug(
-      'New authentication strategy added by node %s (plugin: %s, strategy: %s)',
+      "New authentication strategy added by node %s (plugin: %s, strategy: %s)",
       this.remoteNodeId,
       pluginName,
-      strategyName);
+      strategyName
+    );
 
     this.localNode.fullState.addAuthStrategy(message);
 
     global.kuzzle.pluginsManager.registerStrategy(
       pluginName,
       strategyName,
-      strategy);
+      strategy
+    );
   }
 
   /**
@@ -446,14 +466,15 @@ class ClusterSubscriber {
    * @param  {Object} message - decoded RemoveAuthStrategy protobuf message
    * @return {void}
    */
-  handleAuthStrategyRemoval (message) {
+  handleAuthStrategyRemoval(message) {
     const { pluginName, strategyName } = message;
 
     debug(
-      'Authentication strategy removed by node %s (plugin: %s, strategy: %s)',
+      "Authentication strategy removed by node %s (plugin: %s, strategy: %s)",
       this.remoteNodeId,
       pluginName,
-      strategyName);
+      strategyName
+    );
 
     global.kuzzle.pluginsManager.unregisterStrategy(pluginName, strategyName);
     this.localNode.fullState.removeAuthStrategy(strategyName);
@@ -464,10 +485,10 @@ class ClusterSubscriber {
    *
    * @return {void}
    */
-  async handleResetSecurity () {
-    debug('Security reset received from node %s', this.remoteNodeId);
-    await global.kuzzle.ask('core:security:profile:invalidate');
-    await global.kuzzle.ask('core:security:role:invalidate');
+  async handleResetSecurity() {
+    debug("Security reset received from node %s", this.remoteNodeId);
+    await global.kuzzle.ask("core:security:profile:invalidate");
+    await global.kuzzle.ask("core:security:role:invalidate");
   }
 
   /**
@@ -476,8 +497,8 @@ class ClusterSubscriber {
    * @param {Object} message - decoded DumpRequest protobuf message
    * @return {void}
    */
-  handleDumpRequest (message) {
-    debug('Dump generation request received from node %s', this.remoteNodeId);
+  handleDumpRequest(message) {
+    debug("Dump generation request received from node %s", this.remoteNodeId);
     global.kuzzle.dump(message.suffix);
   }
 
@@ -485,9 +506,14 @@ class ClusterSubscriber {
    * Handles cluster-wide shutdown
    * @return {void}
    */
-  handleShutdown () {
-    debug('Cluster-wide shutdown request received from node %s', this.remoteNodeId);
-    global.kuzzle.log.error(`[CLUSTER] Cluster wide shutdown from ${this.remoteNodeId}`);
+  handleShutdown() {
+    debug(
+      "Cluster-wide shutdown request received from node %s",
+      this.remoteNodeId
+    );
+    global.kuzzle.log.error(
+      `[CLUSTER] Cluster wide shutdown from ${this.remoteNodeId}`
+    );
     global.kuzzle.shutdown();
   }
 
@@ -496,17 +522,25 @@ class ClusterSubscriber {
    *
    * @return {void}
    */
-  async handleRefreshValidators () {
-    debug('Validators changed notification received from node %s', this.remoteNodeId);
+  async handleRefreshValidators() {
+    debug(
+      "Validators changed notification received from node %s",
+      this.remoteNodeId
+    );
     await global.kuzzle.validation.curateSpecification();
   }
 
   /**
    * Handles manual refresh of the index cache
    */
-  async handleRefreshIndexCache () {
-    debug('Index cache manually refresh received from node %s', this.remoteNodeId);
-    await global.kuzzle.ask('core:storage:public:cache:refresh', { from: 'cluster' });
+  async handleRefreshIndexCache() {
+    debug(
+      "Index cache manually refresh received from node %s",
+      this.remoteNodeId
+    );
+    await global.kuzzle.ask("core:storage:public:cache:refresh", {
+      from: "cluster",
+    });
   }
 
   /**
@@ -515,13 +549,17 @@ class ClusterSubscriber {
    * @param {Object} message - decoded DumpRequest protobuf message
    * @return {void}
    */
-  async handleProfileInvalidation (message) {
+  async handleProfileInvalidation(message) {
     debug(
-      'Profile invalidation request received from node %s (profile: %s)',
+      "Profile invalidation request received from node %s (profile: %s)",
       this.remoteNodeId,
-      message.profileId);
+      message.profileId
+    );
 
-    await global.kuzzle.ask('core:security:profile:invalidate', message.profileId);
+    await global.kuzzle.ask(
+      "core:security:profile:invalidate",
+      message.profileId
+    );
   }
 
   /**
@@ -530,13 +568,14 @@ class ClusterSubscriber {
    * @param {Object} message - decoded DumpRequest protobuf message
    * @return {void}
    */
-  async handleRoleInvalidation (message) {
+  async handleRoleInvalidation(message) {
     debug(
-      'Role invalidation request received from node %s (role: %s)',
+      "Role invalidation request received from node %s (role: %s)",
       this.remoteNodeId,
-      message.roleId);
+      message.roleId
+    );
 
-    await global.kuzzle.ask('core:security:role:invalidate', message.roleId);
+    await global.kuzzle.ask("core:security:role:invalidate", message.roleId);
   }
 
   /**
@@ -545,14 +584,15 @@ class ClusterSubscriber {
    * @param {Object} message - decoded IndexCacheAdd protobuf message
    * @return {void}
    */
-  async handleIndexAddition (message) {
+  async handleIndexAddition(message) {
     const { index, scope } = message;
 
     debug(
-      'New index added by node %s (scope: %s, index: %s)',
+      "New index added by node %s (scope: %s, index: %s)",
       this.remoteNodeId,
       scope,
-      index);
+      index
+    );
 
     await global.kuzzle.ask(`core:storage:${scope}:cache:addIndex`, index);
   }
@@ -563,18 +603,20 @@ class ClusterSubscriber {
    * @param {Object} message - decoded IndexCacheAdd protobuf message
    * @return {void}
    */
-  async handleIndexesRemoval (message) {
+  async handleIndexesRemoval(message) {
     const { indexes, scope } = message;
 
     debug(
-      'Indexes removed by node %s (scope: %s, indexes: %s)',
+      "Indexes removed by node %s (scope: %s, indexes: %s)",
       this.remoteNodeId,
       scope,
-      indexes);
+      indexes
+    );
 
     await global.kuzzle.ask(
       `core:storage:${scope}:cache:removeIndexes`,
-      indexes);
+      indexes
+    );
   }
 
   /**
@@ -583,20 +625,22 @@ class ClusterSubscriber {
    * @param {Object} message - decoded IndexCacheAdd protobuf message
    * @return {void}
    */
-  async handleCollectionAddition (message) {
+  async handleCollectionAddition(message) {
     const { collection, index, scope } = message;
 
     debug(
-      'New collection added by node %s (scope: %s, index: %s, collection: %s)',
+      "New collection added by node %s (scope: %s, index: %s, collection: %s)",
       this.remoteNodeId,
       scope,
       index,
-      collection);
+      collection
+    );
 
     await global.kuzzle.ask(
       `core:storage:${scope}:cache:addCollection`,
       index,
-      collection);
+      collection
+    );
   }
 
   /**
@@ -605,47 +649,46 @@ class ClusterSubscriber {
    * @param {Object} message - decoded IndexCacheAdd protobuf message
    * @return {void}
    */
-  async handleCollectionRemoval (message) {
+  async handleCollectionRemoval(message) {
     const { collection, index, scope } = message;
 
     debug(
-      'Indexes removed by node %s (scope: %s, index: %s, collection: %s)',
+      "Indexes removed by node %s (scope: %s, index: %s, collection: %s)",
       this.remoteNodeId,
       scope,
       index,
-      collection);
+      collection
+    );
 
     await global.kuzzle.ask(
       `core:storage:${scope}:cache:removeCollection`,
       index,
-      collection);
+      collection
+    );
   }
 
-
   /**
    * Checks that we did receive a heartbeat from the remote node
    * If a heartbeat is missing, we allow 1 heartbeat round for the remote node
    * to recover, otherwise we evict it from the cluster.
    */
-  async checkHeartbeat () {
+  async checkHeartbeat() {
     if (this.state === stateEnum.EVICTED) {
       return;
     }
 
     const now = Date.now();
 
-    if ((now - this.lastHeartbeat) > this.heartbeatDelay) {
+    if (now - this.lastHeartbeat > this.heartbeatDelay) {
       if (this.state === stateEnum.MISSING_HEARTBEAT) {
         await this.evictNode({
           broadcast: true,
-          reason: 'heartbeat timeout',
+          reason: "heartbeat timeout",
         });
-      }
-      else {
+      } else {
         this.state = stateEnum.MISSING_HEARTBEAT;
       }
-    }
-    else {
+    } else {
       this.state = stateEnum.SANE;
     }
   }
@@ -653,7 +696,7 @@ class ClusterSubscriber {
   /**
    * Disconnects from the remote node, and frees all allocated resources.
    */
-  dispose () {
+  dispose() {
     if (this.state === stateEnum.EVICTED) {
       return;
     }
@@ -669,9 +712,11 @@ class ClusterSubscriber {
    * @param  {Object} message - decoded protobuf message
    * @return {boolean} false: the message must be discarded, true otherwise
    */
-  async validateMessage (message) {
-    if (! has(message, 'messageId')) {
-      global.kuzzle.log.warn(`Invalid message received from node ${this.remoteNodeId}. Evicting it.`);
+  async validateMessage(message) {
+    if (!has(message, "messageId")) {
+      global.kuzzle.log.warn(
+        `Invalid message received from node ${this.remoteNodeId}. Evicting it.`
+      );
 
       await this.evictNode({
         broadcast: true,
@@ -681,8 +726,9 @@ class ClusterSubscriber {
       return false;
     }
 
-    if ( this.state === stateEnum.BUFFERING
-      && this.lastMessageId.greaterThanOrEqual(message.messageId)
+    if (
+      this.state === stateEnum.BUFFERING &&
+      this.lastMessageId.greaterThanOrEqual(message.messageId)
     ) {
       return false;
     }
@@ -690,14 +736,18 @@ class ClusterSubscriber {
     this.lastMessageId = this.lastMessageId.add(1);
 
     if (this.lastMessageId.notEquals(message.messageId)) {
-      await this.localNode.evictSelf(`Node out-of-sync: ${message.messageId - this.lastMessageId - 1} messages lost from node ${this.remoteNodeId}`);
+      await this.localNode.evictSelf(
+        `Node out-of-sync: ${
+          message.messageId - this.lastMessageId - 1
+        } messages lost from node ${this.remoteNodeId}`
+      );
       return false;
     }
 
     return true;
   }
 
-  async evictNode ({ broadcast, reason }) {
+  async evictNode({ broadcast, reason }) {
     this.state = stateEnum.EVICTED;
 
     await this.localNode.evictNode(this.remoteNodeId, { broadcast, reason });