kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/cluster/index.d.ts

@@ -1,2 +1,8 @@
-declare const _exports: typeof import("./node");
-export = _exports;
+import ClusterNode from "./node";
+/**
+ * `lib/cluster` is the node itself: this barrel keeps the CommonJS shape the
+ * package has always exported (`module.exports = ClusterNode`), which is why it
+ * is an `export =` and not a default export — `bin/` and plugins `require()`
+ * this path directly.
+ */
+export = ClusterNode;

package/dist/lib/cluster/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,6 +19,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-module.exports = require("./node");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_1 = __importDefault(require("./node"));
+module.exports = node_1.default;
 //# sourceMappingURL=index.js.map

package/dist/lib/cluster/node.d.ts

@@ -1,41 +1,66 @@
-export = ClusterNode;
+import EventEmitter from "eventemitter3";
+import type { NormalizedFilter } from "koncorde";
+import type DocumentNotification from "../core/realtime/notification/document";
+import type UserNotification from "../core/realtime/notification/user";
+import type { storeScopeEnum } from "../core/storage/storeScopeEnum";
+import type { AuthStrategy } from "./protobuf/syncMessages";
+import Long from "long";
+import type { JSONObject } from "../types/JSONObject";
+import type { IKuzzleConfiguration } from "../types/config/KuzzleConfiguration";
+import ClusterCommand from "./command";
+import { ClusterIdCardHandler } from "./idCardHandler";
+import type { Activity } from "./protobuf/commandMessages";
+import ClusterPublisher from "./publisher";
+import ClusterState from "./state";
+import ClusterSubscriber from "./subscriber";
+/** One entry of the cluster activity ring buffer. */
+type NodeActivity = Activity;
+/** What `cluster:status:get` answers with. */
+type ClusterStatus = {
+    activeNodes: number;
+    activity: Array<{
+        address: string;
+        date: string;
+        event: string;
+        id: string;
+        reason?: string;
+    }>;
+    nodes: Array<{
+        address: string;
+        birthdate: string;
+        id: string;
+    }>;
+};
 declare class ClusterNode {
-    config: {
-        enabled: boolean;
-        activityDepth: number;
-        heartbeat: number;
-        interface: any;
-        ipv6: boolean;
-        ip: string;
-        joinTimeout: number;
-        minimumNodes: number;
-        ports: {
-            command: number;
-            sync: number;
-        };
-        syncTimeout: number;
-    };
-    logger: import("../kuzzle/Logger").Logger;
-    heartbeatDelay: number;
-    ip: string;
-    nodeId: string;
-    heartbeatTimer: NodeJS.Timeout;
-    idCardHandler: ClusterIdCardHandler;
-    publisher: ClusterPublisher;
-    fullState: any;
-    command: ClusterCommand;
-    eventEmitter: any;
-    /**
-     * Links remote node IDs with their subscriber counterpart
-     * @type {Map.<string, ClusterSubscriber>}
-     */
-    remoteNodes: Map<string, ClusterSubscriber>;
+    readonly config: IKuzzleConfiguration["cluster"];
+    private readonly logger;
+    readonly heartbeatDelay: number;
+    readonly ip: string;
+    private _nodeId;
+    /**
+     * The id of the ID card this node reserved during `handshake()`.
+     *
+     * Null until the handshake gets that far, and read as a `string` at
+     * seventeen sites here plus `subscriber.ts` and `command.ts` — all of which
+     * run after it. The accessor says once where that can fail.
+     */
+    get nodeId(): string;
+    set nodeId(id: string);
+    private heartbeatTimer;
+    readonly idCardHandler: ClusterIdCardHandler;
+    readonly publisher: ClusterPublisher;
+    readonly fullState: ClusterState;
+    readonly command: ClusterCommand;
+    readonly eventEmitter: EventEmitter;
+    /** Links remote node IDs with their subscriber counterpart */
+    readonly remoteNodes: Map<string, ClusterSubscriber>;
+    private readonly activityMaxLength;
     /**
      * Cluster nodes activity, used to keep track of nodes being added or
      * removed, to give more insights to cluster statuses
      */
-    activityMaxLength: number;
-    activity: any[];
+    activity: NodeActivity[];
+    constructor();
     get syncAddress(): string;
     init(): Promise<string>;
     /**
@@ -48,7 +73,7 @@ declare class ClusterNode {
      *
      * @param {bool} evictionPrevented
      */
-    preventEviction(evictionPrevented: bool): void;
+    preventEviction(evictionPrevented: boolean): void;
     /**
      * Adds a new remote node, and subscribes to it.
      * @param {string} id            - remote node ID
@@ -56,7 +81,7 @@ declare class ClusterNode {
      * @param {number} lastMessageId - remote node last message ID
      * @return {boolean} false if the node was already known, true otherwise
      */
-    addNode(id: string, ip: string, lastMessageId: number): boolean;
+    addNode(id: string, ip: string, lastMessageId: Long): Promise<boolean>;
     /**
      * Evicts this node from the cluster.
      *
@@ -64,7 +89,7 @@ declare class ClusterNode {
      * @param  {Error} [error]
      * @return {void}
      */
-    evictSelf(reason: string, error?: Error): void;
+    evictSelf(reason: string, error?: Error | null): Promise<void>;
     /**
      * Evicts a remote from the list
      * @param {string}  nodeId - remote node ID
@@ -72,7 +97,7 @@ declare class ClusterNode {
      * @param {boolean} [options.broadcast] - broadcast the eviction to the cluster
      * @param {string}  [options.reason] - reason of eviction
      */
-    evictNode(nodeId: string, { broadcast, reason }?: {
+    evictNode(nodeId: string, { broadcast, reason, }: {
         broadcast?: boolean;
         reason?: string;
     }): Promise<void>;
@@ -84,6 +109,44 @@ declare class ClusterNode {
      * It'll never throw, and it'll never generate unhandled rejections.
      */
     enforceClusterConsistency(): Promise<void>;
+    /**
+     * Builds the distinct topologies the cluster's ID cards disagree on. A
+     * topology shorter than the number of known cards is a split: that card sees
+     * fewer nodes than exist.
+     *
+     * Extracted from `enforceClusterConsistency()` unchanged — a pure function of
+     * the cards it is given, which is what makes moving it safe.
+     */
+    private detectSplits;
+    /**
+     * Decides which nodes must shut themselves down, given the detected splits.
+     *
+     * Extracted from `enforceClusterConsistency()` unchanged. Every node runs
+     * this on its own and must reach the same list, so it is a pure function of
+     * `splits` and `idCards` — no clock, no randomness, no state.
+     */
+    private electShutdownCandidates;
+    /**
+     * Breaks a tie between equally small splits: prefer the one holding the
+     * youngest *isolated* node (present in that split and no other), and fall
+     * back to the youngest node overall.
+     *
+     * Extracted from `electShutdownCandidates()` unchanged, and pure like it —
+     * every node must reach the same answer from the same inputs.
+     */
+    private electFromTiedSplits;
+    /**
+     * Handles a full-state round that no node answered: gives up if this was
+     * already the second attempt, otherwise drops every subscriber and waits a
+     * redis heartbeat round so the discovery can be redone against ID cards that
+     * may since have expired.
+     *
+     * Extracted from `handshake()` unchanged.
+     *
+     * @returns false when the caller must stop — the cluster is split and this
+     *          node is shutting down
+     */
+    private retryFullState;
     /**
      * 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
@@ -91,7 +154,25 @@ declare class ClusterNode {
      *
      * @return {void}
      */
-    handshake(): void;
+    handshake(): Promise<void>;
+    /**
+     * Subscribes to every discovered node and starts buffering their sync
+     * messages.
+     *
+     * Extracted from `handshake()` unchanged, including its awaits: the wait
+     * below is what makes the `getFullState` that follows it safe, so the
+     * ordering is the point of the method, not an implementation detail.
+     */
+    private subscribeToNodes;
+    /**
+     * Starts synchronizing with each peer that answered the handshake, and drops
+     * the ones that did not.
+     *
+     * Extracted from `handshake()` unchanged. `sync()` is awaited here for the
+     * reason written inside: a gap found during its replay evicts this node, and
+     * the success line must not be printed before that is known.
+     */
+    private syncWithPeers;
     countActiveNodes(): number;
     startHeartbeat(): void;
     /**
@@ -102,12 +183,12 @@ declare class ClusterNode {
      * @param {nodeActivityEnum} event
      * @param {string} [reason]
      */
-    trackActivity(id: string, ip: string, event: any, reason?: string): void;
+    trackActivity(id: string, ip: string, event: number, reason?: string): void;
     /**
      * Returns the full status of the cluster
      * @return {Object}
      */
-    getStatus(): any;
+    getStatus(): Promise<ClusterStatus>;
     /**
      * Registers ask events
      */
@@ -145,7 +226,7 @@ declare class ClusterNode {
      * @param {string} event name
      * @param {Object} payload - event payload
      */
-    broadcast(event: string, payload: any): void;
+    broadcast(event: string, payload: JSONObject): void;
     /**
      * Triggered when a user unsubscribes from a room
      *
@@ -160,7 +241,7 @@ declare class ClusterNode {
      * @param  {DocumentNotification} notification
      * @return {void}
      */
-    onDocumentNotification(rooms: Array<string>, notification: DocumentNotification): void;
+    onDocumentNotification(rooms: string[], notification: DocumentNotification): void;
     /**
      * Triggered when a user notification must be propagated
      *
@@ -177,7 +258,7 @@ declare class ClusterNode {
      * @param  {Object} strategyObject
      * @return {void}
      */
-    onAuthStrategyAdded(strategyName: string, pluginName: string, strategyObject: any): void;
+    onAuthStrategyAdded(strategyName: string, pluginName: string, strategyObject: AuthStrategy): void;
     /**
      * Triggered when an authentication strategy has been dynamically removed
      *
@@ -243,7 +324,7 @@ declare class ClusterNode {
      * @param  {Array.<string>} indexes
      * @return {void}
      */
-    onIndexesRemoved(scope: storeScopeEnum, indexes: Array<string>): void;
+    onIndexesRemoved(scope: storeScopeEnum, indexes: string[]): void;
     /**
      * Triggered when a collection has been removed from the index cache
      *
@@ -270,9 +351,6 @@ declare class ClusterNode {
      * @param {string} roomId
      * @return {void}
      */
-    countRealtimeSubscribers(roomId: string): void;
+    countRealtimeSubscribers(roomId: string): Promise<number>;
 }
-import { ClusterIdCardHandler } from "./idCardHandler";
-import ClusterPublisher = require("./publisher");
-import ClusterCommand = require("./command");
-import ClusterSubscriber = require("./subscriber");
+export = ClusterNode;