kuzzle 2.49.1 → 2.50.0-beta.3

package/dist/lib/cluster/node.js

@@ -0,0 +1,876 @@
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * 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");
+/**
+ * Test an IP address and determine if it's in the public or private range.
+ *
+ * @param  {String}  ip
+ * @return {Boolean}
+ */
+function isPrivateIP(ip) {
+    if (net.isIPv6(ip)) {
+        const prefix = ip.split(":")[0];
+        return ((prefix.startsWith("fd") && prefix.length === 4) || prefix === "fe80");
+    }
+    // IPv4
+    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));
+}
+/**
+ * Some IPv4 addresses are reserved for internal uses only, and cannot be
+ * reached from other machines. We need to detect and filter them
+ * @param  {String}  ip
+ * @return {Boolean}
+ */
+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));
+    // 127.x.x: loopback addresses are already flagged as "internal" by
+    // os.networkInterfaces.
+    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));
+}
+/**
+ * Return the first IP address matching the provided configuration
+ * @param  {Object} [options]
+ * @param  {String} [options.family] IP family (IPv4 or IPv6)
+ * @param  {String} [options.interface] Network interface/IP/MAC to use
+ * @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";
+    let interfaces = [];
+    for (const [key, value] of Object.entries(os.networkInterfaces())) {
+        for (const _interface of value) {
+            interfaces.push({
+                interface: key,
+                ..._interface,
+            });
+        }
+    }
+    debug("Found interfaces %o", interfaces);
+    interfaces = interfaces.filter((n) => {
+        return (!n.internal &&
+            !isInternalIP(n.address) &&
+            n.family === family &&
+            (!ip || mustBePrivate === isPrivateIP(n.address)));
+    });
+    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) {
+        return interfaces[0].address;
+    }
+    for (const i of interfaces) {
+        if ([i.interface, i.address, i.mac].includes(netInterface)) {
+            return i.address;
+        }
+    }
+    return null;
+}
+/**
+ * @typedef {nodeActivityEnum}
+ */
+const nodeActivityEnum = Object.freeze({
+    ADDED: 1,
+    EVICTED: 2,
+});
+// Handles the node logic: discovery, eviction, heartbeat, ...
+// Dependencies: core:cache module must be started
+class ClusterNode {
+    constructor() {
+        this.config = global.kuzzle.config.cluster;
+        this.logger = global.kuzzle.log.child("cluster:node");
+        this.heartbeatDelay = this.config.heartbeat;
+        const family = this.config.ipv6 ? "IPv6" : "IPv4";
+        this.ip = getIP({
+            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;
+        this.idCardHandler = new ClusterIdCardHandler(this);
+        this.publisher = new ClusterPublisher(this);
+        this.fullState = new ClusterState();
+        this.command = new ClusterCommand(this);
+        this.eventEmitter = new EventEmitter();
+        /**
+         * Links remote node IDs with their subscriber counterpart
+         * @type {Map.<string, ClusterSubscriber>}
+         */
+        this.remoteNodes = new Map();
+        /**
+         * Cluster nodes activity, used to keep track of nodes being added or
+         * removed, to give more insights to cluster statuses
+         */
+        this.activityMaxLength = this.config.activityDepth;
+        this.activity = [];
+    }
+    get syncAddress() {
+        return `tcp://${this.ip}:${this.config.ports.sync}`;
+    }
+    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
+        await this.publisher.init();
+        // This also needs to be started before the handshake, as this class handles
+        // direct requests to other nodes (needed to request for the full state
+        // and to introduce oneself to other nodes)
+        await this.command.init();
+        global.kuzzle.onPipe("kuzzle:shutdown", () => this.shutdown());
+        await this.handshake();
+        this.registerEvents();
+        this.registerAskEvents();
+        if (this.countActiveNodes() < this.config.minimumNodes) {
+            this.logger.info("[CLUSTER] Not enough nodes active. Waiting for other nodes to join the cluster...");
+            while (this.countActiveNodes() < this.config.minimumNodes) {
+                await Bluebird.delay(100);
+            }
+        }
+        return this.nodeId;
+    }
+    /**
+     * Shutdown event: clears all timers, sends a termination status to other
+     * nodes, and removes entries from the cache
+     */
+    async shutdown() {
+        clearInterval(this.heartbeatTimer);
+        await this.idCardHandler.dispose();
+        for (const subscriber of this.remoteNodes.values()) {
+            subscriber.dispose();
+        }
+        this.publisher.sendNodeShutdown(this.nodeId);
+        await this.publisher.dispose();
+        this.command.dispose();
+    }
+    /**
+     * Notify other nodes to not evict this node
+     *
+     * @param {bool} evictionPrevented
+     */
+    preventEviction(evictionPrevented) {
+        this.publisher.sendNodePreventEviction(evictionPrevented);
+        // This node is subscribed to the other node and might not receive their heartbeat while debugging
+        // so this node should not have the responsability of evicting others when his own eviction is prevented
+        // when debugging.
+        // Otherwise when recovering from a debug session, all the other nodes will be evicted.
+        for (const subscriber of this.remoteNodes.values()) {
+            subscriber.handleNodePreventEviction({
+                evictionPrevented,
+            });
+        }
+    }
+    /**
+     * Adds a new remote node, and subscribes to it.
+     * @param {string} id            - remote node ID
+     * @param {string} ip            - remote node IP address
+     * @param {number} lastMessageId - remote node last message ID
+     * @return {boolean} false if the node was already known, true otherwise
+     */
+    async addNode(id, ip, lastMessageId) {
+        if (this.remoteNodes.has(id)) {
+            return false;
+        }
+        const subscriber = new ClusterSubscriber(this, id, ip);
+        this.remoteNodes.set(id, subscriber);
+        await subscriber.init();
+        await subscriber.sync(lastMessageId);
+        await this.idCardHandler.addNode(id);
+        this.logger.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) {
+            global.kuzzle.state = kuzzleStateEnum.RUNNING;
+            this.logger.warn(`[CLUSTER] Minimum number of nodes reached (${this.countActiveNodes()}). This node is now accepting requests again.`);
+        }
+        return true;
+    }
+    /**
+     * Evicts this node from the cluster.
+     *
+     * @param  {String} reason
+     * @param  {Error} [error]
+     * @return {void}
+     */
+    async evictSelf(reason, error = null) {
+        this.logger.error(`[CLUSTER] ${reason}`);
+        if (error) {
+            this.logger.error(error.stack);
+        }
+        this.publisher.sendNodeEvicted(this.nodeId, this.nodeId, reason);
+    }
+    /**
+     * Evicts a remote from the list
+     * @param {string}  nodeId - remote node ID
+     * @param {Object}  [options]
+     * @param {boolean} [options.broadcast] - broadcast the eviction to the cluster
+     * @param {string}  [options.reason] - reason of eviction
+     */
+    async evictNode(nodeId, { broadcast = false, reason = "" }) {
+        const subscriber = this.remoteNodes.get(nodeId);
+        if (!subscriber) {
+            this.logger.warn(`[CLUSTER] Node "${nodeId}" with no subscriber evicted. Reason: ${reason}`);
+            return;
+        }
+        this.logger.warn(`[CLUSTER] Node "${nodeId}" evicted. Reason: ${reason}`);
+        this.trackActivity(nodeId, subscriber.remoteNodeIP, nodeActivityEnum.EVICTED, reason);
+        await this.idCardHandler.removeNode(nodeId);
+        this.remoteNodes.delete(nodeId);
+        this.fullState.removeNode(nodeId);
+        subscriber.dispose();
+        if (broadcast) {
+            this.publisher.sendNodeEvicted(this.nodeId, nodeId, reason);
+        }
+        if (this.countActiveNodes() < this.config.minimumNodes) {
+            global.kuzzle.state = kuzzleStateEnum.NOT_ENOUGH_NODES;
+            this.logger.warn(`[CLUSTER] Not enough nodes active (expected: ${this.config.minimumNodes}, active: ${this.countActiveNodes()}). Deactivating node until new ones are added.`);
+        }
+    }
+    /**
+     * Verifies the consistency of the cluster by comparing our own known
+     * topology with the one kept in other nodes ID cards
+     *
+     * /!\ 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() {
+        // Delay the check to 1 heartbeat round, to allow all nodes to update
+        // their ID cards
+        await Bluebird.delay(this.heartbeatDelay);
+        try {
+            const idCards = await this.idCardHandler.getRemoteIdCards();
+            idCards.push(this.idCardHandler.idCard);
+            let splits = [];
+            for (const idCard of idCards) {
+                let topology = Array.from(idCard.topology);
+                topology.push(idCard.id);
+                if (topology.length !== idCards.length) {
+                    topology = topology.sort();
+                    const found = splits.some((split) => {
+                        if (split.length !== topology.length) {
+                            return false;
+                        }
+                        return split.every((id, index) => id === topology[index]);
+                    });
+                    if (!found) {
+                        splits.push(topology);
+                    }
+                }
+            }
+            // No split detected, the cluster is consistent
+            if (splits.length === 0) {
+                return;
+            }
+            // There is at least 1 cluster split detected.
+            //
+            // First we elect the smallest split possible.
+            // If multiple splits are eligibles, we choose amongst them the split
+            // containing the youngest isolated node (isolated = the node is in this
+            // split alone, and in no other splits). If no split is eligible using
+            // this method, we fall back to the smallest split containing the youngest
+            // node (isolated or not).
+            //
+            // The goal of this process is to force at least 1 node to kill itself,
+            // with all nodes concluding on their own on the same list of nodes to
+            // 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.sort((a, b) => a.length - b.length);
+            const eligibleSplits = splits.filter((split) => split.length === splits[0].length);
+            let candidates;
+            if (eligibleSplits.length === 1) {
+                candidates = eligibleSplits[0];
+            }
+            else {
+                // Beware: search isolated nodes in ALL the splits, not only the
+                // smallest ones
+                let isolatedNodes = _.xor(...splits);
+                const eligibleNodes = _.uniq(_.flatten(eligibleSplits));
+                isolatedNodes = _.intersection(isolatedNodes, eligibleNodes);
+                const isIsolated = isolatedNodes.length > 0;
+                // safety measure: this should never happen
+                if (isolatedNodes.length === 0) {
+                    isolatedNodes = eligibleNodes;
+                }
+                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) {
+                        youngestNode = idCard;
+                    }
+                }
+                if (isIsolated) {
+                    for (let i = 0; !candidates && i < eligibleSplits.length; i++) {
+                        if (eligibleSplits[i].includes(youngestNode.id)) {
+                            candidates = _.intersection(eligibleSplits[i], isolatedNodes);
+                        }
+                    }
+                }
+                else {
+                    candidates = [youngestNode.id];
+                }
+            }
+            if (candidates.includes(this.nodeId)) {
+                this.logger.error("[CLUSTER] Network split detected. This node is outside the cluster: shutting down.");
+                global.kuzzle.shutdown();
+                return;
+            }
+        }
+        catch (err) {
+            this.logger.error("[CLUSTER] Unexpected exception caught during a cluster consistency check. Shutting down...");
+            this.logger.error(err.stack);
+            global.kuzzle.shutdown();
+        }
+    }
+    /**
+     * Discovers other active nodes from the cluster and, if other nodes exist,
+     * starts a handshake procedure to sync this node and to make it able to
+     * handle new client requests
+     *
+     * @return {void}
+     */
+    async handshake() {
+        const handshakeTimeout = setTimeout(() => {
+            this.logger.error(`[CLUSTER] Failed to join the cluster: timed out (joinTimeout: ${this.config.joinTimeout}ms)`);
+            global.kuzzle.shutdown();
+        }, this.config.joinTimeout);
+        const mutex = new Mutex("clusterHandshake", {
+            timeout: this.config.joinTimeout,
+        });
+        try {
+            await mutex.lock();
+            // Create the ID Key AFTER the handshake mutex is actually locked,
+            // 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");
+            this.nodeId = this.idCardHandler.nodeId;
+            await this.startHeartbeat();
+            debug("[CLUSTER] Start heartbeat");
+            let retried = false;
+            let fullState = null;
+            let nodes;
+            debug("[CLUSTER] Start retrieving full state..");
+            do {
+                nodes = await this.idCardHandler.getRemoteIdCards();
+                debug("[CLUSTER] %s remote nodes discovered", nodes.length);
+                // No other nodes detected = no handshake required
+                if (nodes.length === 0) {
+                    this.trackActivity(this.nodeId, this.ip, nodeActivityEnum.ADDED);
+                    return;
+                }
+                // Verify that no other node share the same IP address as this one
+                const duplicate = nodes.filter((node) => node.ip === this.ip);
+                if (duplicate.length > 0) {
+                    this.logger.error(`[CLUSTER] Another node share the same IP address as this one (${this.ip}): ${duplicate[0].id}. Shutting down.`);
+                    global.kuzzle.shutdown();
+                    return;
+                }
+                // Subscribe to remote nodes and start buffering sync messages
+                await Bluebird.map(nodes, ({ id, ip }) => {
+                    const subscriber = new ClusterSubscriber(this, id, ip);
+                    this.remoteNodes.set(id, subscriber);
+                    return subscriber.init();
+                });
+                debug("[CLUSTER] Successfully subscribed to nodes");
+                fullState = await this.command.getFullState(nodes);
+                // Uh oh... no node was able to give us the full state.
+                // We must retry later, to check if the redis keys have expired. If they
+                // are still there and we still aren't able to fetch a full state, this
+                // means we're probably facing a network split, and we must then shut
+                // down.
+                if (fullState === null) {
+                    if (retried) {
+                        this.logger.error("[CLUSTER] Could not connect to discovered cluster nodes (network split detected). Shutting down.");
+                        global.kuzzle.shutdown();
+                        return;
+                    }
+                    // Disposes all subscribers
+                    for (const subscriber of this.remoteNodes.values()) {
+                        subscriber.dispose();
+                    }
+                    this.remoteNodes.clear();
+                    // Waits for a redis heartbeat round
+                    retried = true;
+                    const retryDelay = this.heartbeatDelay * 1.5;
+                    this.logger.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..");
+            await this.fullState.loadFullState(fullState);
+            this.activity = fullState.activity ? fullState.activity : this.activity;
+            debug("[CLUSTER] Fullstate loaded.");
+            const handshakeResponses = await this.command.broadcastHandshake(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)) {
+                const subscriber = this.remoteNodes.get(nodeId);
+                if (handshakeData === null) {
+                    subscriber.dispose();
+                    this.remoteNodes.delete(nodeId);
+                }
+                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);
+                    this.logger.info(`[CLUSTER] Successfully completed the handshake with node ${nodeId}`);
+                }
+            }
+            this.logger.info("[CLUSTER] Successfully joined the cluster.");
+            this.trackActivity(this.nodeId, this.ip, nodeActivityEnum.ADDED);
+        }
+        finally {
+            clearTimeout(handshakeTimeout);
+            await mutex.unlock();
+        }
+    }
+    countActiveNodes() {
+        return this.remoteNodes.size + 1;
+    }
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            this.publisher.sendHeartbeat(this.syncAddress);
+        }, this.heartbeatDelay);
+    }
+    /**
+     * Cluster activity tracking
+     *
+     * @param {string} id
+     * @param {string} ip
+     * @param {nodeActivityEnum} event
+     * @param {string} [reason]
+     */
+    trackActivity(id, ip, event, reason) {
+        if (this.activity.length > this.activityMaxLength) {
+            this.activity.shift();
+        }
+        this.activity.push({
+            address: ip,
+            date: new Date().toISOString(),
+            event,
+            id,
+            reason,
+        });
+    }
+    /**
+     * Returns the full status of the cluster
+     * @return {Object}
+     */
+    async getStatus() {
+        const status = {
+            activeNodes: 0,
+            activity: this.activity.map(({ address, date, event, id, reason }) => ({
+                address,
+                date,
+                event: event === nodeActivityEnum.ADDED ? "joined" : "evicted",
+                id,
+                reason,
+            })),
+            nodes: [],
+        };
+        const idCards = await this.idCardHandler.getRemoteIdCards();
+        idCards.push(this.idCardHandler.idCard);
+        for (const idCard of idCards) {
+            status.nodes.push({
+                address: idCard.ip,
+                birthdate: new Date(idCard.birthdate).toISOString(),
+                id: idCard.id,
+            });
+        }
+        status.activeNodes = status.nodes.length;
+        return status;
+    }
+    /**
+     * Registers ask events
+     */
+    registerAskEvents() {
+        global.kuzzle.onAsk("cluster:node:preventEviction", (state) => {
+            this.preventEviction(state);
+        });
+        /**
+         * 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.
+         *
+         * @param  {string} roomId
+         * @return {void}
+         */
+        global.kuzzle.onAsk("cluster:realtime:room:remove", (roomId) => this.removeRealtimeRoom(roomId));
+        /**
+         * Returns the total number of subscribers on all nodes for the provided
+         * room
+         *
+         * @param {string} roomId
+         * @returns {Number}
+         */
+        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());
+        /**
+         * Returns the requested room. Used to create a room on the fly on this node
+         * if it exists only on remote nodes (e.g. for the realtime:join API action)
+         *
+         * @param {string} roomId
+         * @returns {NormalizedFilter}
+         */
+        global.kuzzle.onAsk("cluster:realtime:filters:get", (roomId) => this.fullState.getNormalizedFilters(roomId));
+        /**
+         * Broadcasts an event to other nodes
+         *
+         * @param {string} event name
+         * @param {Object} payload - event payload
+         */
+        global.kuzzle.onAsk("cluster:event:broadcast", (event, payload) => this.broadcast(event, payload));
+        /**
+         * Listens to a cluster-wide event
+         *
+         * @param {string} event name
+         * @param {Function} fn - event listener
+         */
+        global.kuzzle.onAsk("cluster:event:on", (event, fn) => this.eventEmitter.on(event, fn));
+        /**
+         * Listens to a cluster-wide event once.
+         *
+         * @param {string} event name
+         * @param {Function} fn - event listener
+         */
+        global.kuzzle.onAsk("cluster:event:once", (event, fn) => this.eventEmitter.once(event, fn));
+        /**
+         * Removes a listener from an event
+         *
+         * @param {string} event name
+         * @param {Function} fn - event listener
+         */
+        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));
+        /**
+         * Returns the full status of the cluster
+         */
+        global.kuzzle.onAsk("cluster:status:get", () => this.getStatus());
+    }
+    /**
+     * Starts listening to events to trigger sync messages on state changes.
+     *
+     * @return {void}
+     */
+    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:subscribe:after", (roomId) => this.onNewSubscription(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:user", ({ notification, room }) => this.onUserNotification(room, notification));
+        global.kuzzle.on("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("admin:afterDump", (request) => {
+            const suffix = request.getString("suffix", "manual-api-action");
+            return this.onDumpRequest(suffix);
+        });
+        global.kuzzle.on("admin:afterResetSecurity", () => this.onSecurityReset());
+        global.kuzzle.on("admin:afterShutdown", () => this.onShutdown());
+        global.kuzzle.on("collection:afterDeleteSpecifications", () => 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:createOrReplace", ({ 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));
+        // Role change events
+        global.kuzzle.on("core:security:role:create", ({ args: [roleId] }) => this.onRoleChanged(roleId));
+        global.kuzzle.on("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: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: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:collection:create:after", ({ collection, index, scope }) => {
+            this.onCollectionAdded(scope, index, collection);
+        });
+        global.kuzzle.on("core:storage:collection:delete:after", ({ collection, index, scope }) => {
+            this.onCollectionRemoved(scope, index, collection);
+        });
+    }
+    /**
+     * Triggered whenever a realtime room is created on this node
+     *
+     * @param  {NormalizedFilter} payload
+     * @return {void}
+     */
+    onNewRealtimeRoom(payload) {
+        const roomMessageId = this.publisher.sendNewRealtimeRoom(payload);
+        debug("[%s] Broadcasting new realtime room %s (message: %d)", this.nodeId, payload.id, roomMessageId);
+        const icpair = fromKoncordeIndex(payload.index);
+        this.fullState.addRealtimeRoom(payload.id, icpair.index, icpair.collection, payload.filter, {
+            messageId: roomMessageId,
+            nodeId: this.nodeId,
+            subscribers: 0,
+        });
+    }
+    /**
+     * Triggered on a new realtime subscription
+     *
+     * @param  {string} roomId
+     * @return {void}
+     */
+    onNewSubscription(roomId) {
+        const subMessageId = this.publisher.sendSubscription(roomId);
+        debug("[%s] Broadcasting new realtime subscription on room %s (message: %d)", this.nodeId, roomId, subMessageId);
+        this.fullState.addRealtimeSubscription(roomId, this.nodeId, subMessageId);
+    }
+    /**
+     * Triggered when a realtime room is removed from this node.
+     *
+     * @param  {string} roomId
+     * @return {void}
+     */
+    removeRealtimeRoom(roomId) {
+        const messageId = this.publisher.sendRemoveRealtimeRoom(roomId);
+        debug("[%s] Broadcasted the removal of room %s (message: %d)", this.nodeId, roomId, messageId);
+        this.fullState.removeRealtimeRoom(roomId, this.nodeId);
+    }
+    /**
+     * Broadcasts an event to other nodes
+     *
+     * @param {string} event name
+     * @param {Object} payload - 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);
+    }
+    /**
+     * Triggered when a user unsubscribes from a room
+     *
+     * @param  {string} roomId
+     * @return {void}
+     */
+    onUnsubscription(roomId) {
+        const messageId = this.publisher.sendUnsubscription(roomId);
+        debug("[%s] Broadcasting realtime unsubscription on room %s (message: %d)", this.nodeId, roomId, messageId);
+        this.fullState.removeRealtimeSubscription(roomId, this.nodeId, messageId);
+    }
+    /**
+     * Triggered when a document notification must be propagated
+     *
+     * @param  {Array.<string>} rooms - list of rooms to notify
+     * @param  {DocumentNotification} notification
+     * @return {void}
+     */
+    onDocumentNotification(rooms, notification) {
+        this.publisher.sendDocumentNotification(rooms, notification);
+    }
+    /**
+     * Triggered when a user notification must be propagated
+     *
+     * @param  {string} room
+     * @param  {UserNotification} notification
+     * @return {void}
+     */
+    onUserNotification(room, notification) {
+        this.publisher.sendUserNotification(room, notification);
+    }
+    /**
+     * Triggered when a new authentication strategy has been dynamically added
+     *
+     * @param  {string} strategyName
+     * @param  {string} pluginName
+     * @param  {Object} strategyObject
+     * @return {void}
+     */
+    onAuthStrategyAdded(strategyName, pluginName, strategyObject) {
+        this.publisher.sendNewAuthStrategy(strategyName, pluginName, strategyObject);
+        this.fullState.addAuthStrategy({
+            pluginName,
+            strategy: strategyObject,
+            strategyName,
+        });
+    }
+    /**
+     * Triggered when an authentication strategy has been dynamically removed
+     *
+     * @param  {string} strategyName
+     * @param  {string} pluginName
+     * @return {void}
+     */
+    onAuthStrategyRemoved(strategyName, pluginName) {
+        this.publisher.sendRemoveAuthStrategy(strategyName, pluginName);
+        this.fullState.removeAuthStrategy(strategyName);
+    }
+    /**
+     * Triggered when a dump has been requested
+     *
+     * @param  {string} suffix
+     * @return {void}
+     */
+    onDumpRequest(suffix) {
+        this.publisher.sendDumpRequest(suffix);
+    }
+    /**
+     * Triggered when security rights have been reset
+     *
+     * @return {void}
+     */
+    onSecurityReset() {
+        this.publisher.send("ResetSecurity", {});
+    }
+    /**
+     * Triggered when a document validator has changed
+     *
+     * @return {void}
+     */
+    onValidatorsChanged() {
+        this.publisher.send("RefreshValidators", {});
+    }
+    /**
+     * Triggered when a profile has changed
+     *
+     * @param  {string} profileId
+     * @return {void}
+     */
+    onProfileChanged(profileId) {
+        this.publisher.send("InvalidateProfile", { profileId });
+    }
+    /**
+     * Triggered when a role has changed
+     *
+     * @param {string} roleId
+     * @return {void}
+     */
+    onRoleChanged(roleId) {
+        this.publisher.send("InvalidateRole", { roleId });
+    }
+    /**
+     * Triggered when an index has been added to the index cache
+     *
+     * @param  {storeScopeEnum} scope
+     * @param  {string} index
+     * @return {void}
+     */
+    onIndexAdded(scope, index) {
+        this.publisher.sendAddIndex(scope, index);
+    }
+    /**
+     * Triggered when a collection has been added to the index cache
+     *
+     * @param  {storeScopeEnum} scope
+     * @param  {string} index
+     * @param  {string} collection
+     * @return {void}
+     */
+    onCollectionAdded(scope, index, collection) {
+        this.publisher.sendAddCollection(scope, index, collection);
+    }
+    /**
+     * Triggered when index have been removed from the index cache
+     *
+     * @param  {storeScopeEnum} scope
+     * @param  {Array.<string>} indexes
+     * @return {void}
+     */
+    onIndexesRemoved(scope, indexes) {
+        this.publisher.sendRemoveIndexes(scope, indexes);
+    }
+    /**
+     * Triggered when a collection has been removed from the index cache
+     *
+     * @param  {storeScopeEnum} scope
+     * @param  {string} index
+     * @param  {string} collection
+     * @return {void}
+     */
+    onCollectionRemoved(scope, index, collection) {
+        this.publisher.sendRemoveCollection(scope, index, collection);
+    }
+    /**
+     * Triggered when a cluster-wide shutdown has been initiated
+     *
+     * @return {void}
+     */
+    onShutdown() {
+        this.publisher.send("Shutdown", {});
+    }
+    /**
+     * Triggered when the index cache has been manually refreshed
+     */
+    onIndexCacheRefreshed() {
+        this.publisher.send("RefreshIndexCache", {});
+    }
+    /**
+     * Returns the total number of subscribers on the cluster for the provided
+     * room
+     *
+     * @param {string} roomId
+     * @return {void}
+     */
+    async countRealtimeSubscribers(roomId) {
+        return this.fullState.countRealtimeSubscriptions(roomId);
+    }
+}
+module.exports = ClusterNode;
+//# sourceMappingURL=node.js.map