@celerispay/hazelcast-client 3.12.5-8 → 3.12.7-2

package/lib/invocation/HazelcastFailoverManager.js

@@ -0,0 +1,285 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * 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
+ *
+ * http://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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Node state in the cluster
+ */
+var NodeState;
+(function (NodeState) {
+    NodeState["UNKNOWN"] = "unknown";
+    NodeState["CONNECTING"] = "connecting";
+    NodeState["CONNECTED"] = "connected";
+    NodeState["OWNER"] = "owner";
+    NodeState["CHILD"] = "child";
+    NodeState["DISCONNECTED"] = "disconnected";
+    NodeState["FAILED"] = "failed";
+})(NodeState = exports.NodeState || (exports.NodeState = {}));
+/**
+ * Implements the Java client's failover behavior
+ * This ensures seamless node transitions and proper ownership handling
+ */
+var HazelcastFailoverManager = /** @class */ (function () {
+    function HazelcastFailoverManager(client, logger) {
+        this.nodes = new Map();
+        this.failoverInProgress = false;
+        this.failoverTimeout = 30000; // 30 seconds
+        this.currentOwner = null;
+        this.client = client;
+        this.logger = logger;
+    }
+    /**
+     * Registers a node in the cluster
+     * @param address The node address
+     * @param connection The connection to the node
+     * @param isOwner Whether this node is the owner
+     */
+    HazelcastFailoverManager.prototype.registerNode = function (address, connection, isOwner) {
+        if (isOwner === void 0) { isOwner = false; }
+        var addressStr = address.toString();
+        var nodeInfo = {
+            address: address,
+            state: isOwner ? NodeState.OWNER : NodeState.CHILD,
+            connection: connection,
+            lastSeen: Date.now(),
+            failureCount: 0,
+            isOwner: isOwner
+        };
+        this.nodes.set(addressStr, nodeInfo);
+        if (isOwner) {
+            this.currentOwner = address;
+            this.logger.info('HazelcastFailoverManager', "Registered owner node: " + addressStr);
+        }
+        else {
+            this.logger.info('HazelcastFailoverManager', "Registered child node: " + addressStr);
+        }
+    };
+    /**
+     * Handles node disconnection gracefully
+     * @param address The disconnected node address
+     */
+    HazelcastFailoverManager.prototype.handleNodeDisconnection = function (address) {
+        var addressStr = address.toString();
+        var nodeInfo = this.nodes.get(addressStr);
+        if (!nodeInfo) {
+            return;
+        }
+        this.logger.warn('HazelcastFailoverManager', "Node " + addressStr + " disconnected, state: " + nodeInfo.state);
+        if (nodeInfo.isOwner) {
+            // Owner node disconnected - initiate failover
+            this.handleOwnerDisconnection(address);
+        }
+        else {
+            // Child node disconnected - just mark as disconnected
+            this.handleChildDisconnection(address);
+        }
+    };
+    /**
+     * Handles owner node disconnection
+     * @param address The disconnected owner node address
+     */
+    HazelcastFailoverManager.prototype.handleOwnerDisconnection = function (address) {
+        var addressStr = address.toString();
+        this.logger.warn('HazelcastFailoverManager', "Owner node " + addressStr + " disconnected, initiating failover");
+        // Mark current owner as failed
+        var nodeInfo = this.nodes.get(addressStr);
+        if (nodeInfo) {
+            nodeInfo.state = NodeState.FAILED;
+            nodeInfo.connection = null;
+        }
+        this.currentOwner = null;
+        // Find the best candidate for new owner
+        var newOwner = this.selectNewOwner();
+        if (newOwner) {
+            this.promoteToOwner(newOwner);
+        }
+        else {
+            this.logger.error('HazelcastFailoverManager', 'No suitable node found for ownership, cluster may be down');
+        }
+    };
+    /**
+     * Handles child node disconnection
+     * @param address The disconnected child node address
+     */
+    HazelcastFailoverManager.prototype.handleChildDisconnection = function (address) {
+        var addressStr = address.toString();
+        this.logger.info('HazelcastFailoverManager', "Child node " + addressStr + " disconnected");
+        // Mark as disconnected but keep in nodes map
+        var nodeInfo = this.nodes.get(addressStr);
+        if (nodeInfo) {
+            nodeInfo.state = NodeState.DISCONNECTED;
+            nodeInfo.connection = null;
+        }
+        // No failover needed for child nodes
+    };
+    /**
+     * Selects the best candidate for new owner
+     * @returns The address of the best candidate, or null if none available
+     */
+    HazelcastFailoverManager.prototype.selectNewOwner = function () {
+        var candidates = [];
+        this.nodes.forEach(function (nodeInfo) {
+            if (nodeInfo.state === NodeState.CONNECTED &&
+                nodeInfo.connection &&
+                nodeInfo.connection.isAlive() &&
+                !nodeInfo.isOwner) {
+                candidates.push(nodeInfo);
+            }
+        });
+        if (candidates.length === 0) {
+            return null;
+        }
+        // Select the node with the lowest failure count and most recent connection
+        candidates.sort(function (a, b) {
+            if (a.failureCount !== b.failureCount) {
+                return a.failureCount - b.failureCount;
+            }
+            return b.lastSeen - a.lastSeen;
+        });
+        return candidates[0].address;
+    };
+    /**
+     * Promotes a node to owner
+     * @param address The address of the node to promote
+     */
+    HazelcastFailoverManager.prototype.promoteToOwner = function (address) {
+        var addressStr = address.toString();
+        var nodeInfo = this.nodes.get(addressStr);
+        if (!nodeInfo) {
+            this.logger.error('HazelcastFailoverManager', "Cannot promote " + addressStr + " to owner - node not found");
+            return;
+        }
+        this.logger.info('HazelcastFailoverManager', "Promoting " + addressStr + " to owner");
+        // Update node state
+        nodeInfo.state = NodeState.OWNER;
+        nodeInfo.isOwner = true;
+        // Update current owner
+        this.currentOwner = address;
+        // Notify client of ownership change
+        this.client.getClusterService().handleOwnershipChange(address, nodeInfo.connection);
+        this.logger.info('HazelcastFailoverManager', "Ownership transferred to " + addressStr);
+    };
+    /**
+     * Handles node reconnection
+     * @param address The reconnected node address
+     * @param connection The new connection
+     */
+    HazelcastFailoverManager.prototype.handleNodeReconnection = function (address, connection) {
+        var addressStr = address.toString();
+        var nodeInfo = this.nodes.get(addressStr);
+        if (!nodeInfo) {
+            // New node joining the cluster
+            this.registerNode(address, connection, false);
+            return;
+        }
+        this.logger.info('HazelcastFailoverManager', "Node " + addressStr + " reconnected, previous state: " + nodeInfo.state);
+        // Update connection and state
+        nodeInfo.connection = connection;
+        nodeInfo.lastSeen = Date.now();
+        if (nodeInfo.state === NodeState.FAILED) {
+            // Failed node recovered - treat as child
+            nodeInfo.state = NodeState.CHILD;
+            nodeInfo.isOwner = false;
+            this.logger.info('HazelcastFailoverManager', "Failed node " + addressStr + " recovered and rejoined as child");
+        }
+        else if (nodeInfo.state === NodeState.DISCONNECTED) {
+            // Disconnected node reconnected
+            nodeInfo.state = nodeInfo.isOwner ? NodeState.OWNER : NodeState.CHILD;
+            this.logger.info('HazelcastFailoverManager', "Disconnected node " + addressStr + " reconnected");
+        }
+        // Stop any ongoing failover/reconnection logic
+        this.stopFailoverLogic();
+    };
+    /**
+     * Stops all failover and reconnection logic
+     */
+    HazelcastFailoverManager.prototype.stopFailoverLogic = function () {
+        this.logger.info('HazelcastFailoverManager', 'Stopping all failover and reconnection logic - cluster stable');
+        // Reset failure counts for all nodes
+        this.nodes.forEach(function (nodeInfo) {
+            nodeInfo.failureCount = 0;
+        });
+    };
+    /**
+     * Gets the current owner address
+     * @returns The current owner address or null if no owner
+     */
+    HazelcastFailoverManager.prototype.getCurrentOwner = function () {
+        return this.currentOwner;
+    };
+    /**
+     * Gets all connected nodes
+     * @returns Array of connected node addresses
+     */
+    HazelcastFailoverManager.prototype.getConnectedNodes = function () {
+        var connected = [];
+        this.nodes.forEach(function (nodeInfo) {
+            if (nodeInfo.state === NodeState.CONNECTED ||
+                nodeInfo.state === NodeState.OWNER) {
+                connected.push(nodeInfo.address);
+            }
+        });
+        return connected;
+    };
+    /**
+     * Gets the cluster state summary
+     * @returns Summary of cluster state
+     */
+    HazelcastFailoverManager.prototype.getClusterStateSummary = function () {
+        var summary = {
+            totalNodes: this.nodes.size,
+            currentOwner: this.currentOwner ? this.currentOwner.toString() : 'none',
+            connectedNodes: this.getConnectedNodes().map(function (addr) { return addr.toString(); }),
+            nodeStates: {}
+        };
+        this.nodes.forEach(function (nodeInfo, addressStr) {
+            summary.nodeStates[addressStr] = {
+                state: nodeInfo.state,
+                isOwner: nodeInfo.isOwner,
+                failureCount: nodeInfo.failureCount,
+                lastSeen: new Date(nodeInfo.lastSeen).toISOString()
+            };
+        });
+        return summary;
+    };
+    /**
+     * Cleans up failed nodes that haven't recovered
+     * @param maxFailureAge Maximum age for failed nodes (default: 5 minutes)
+     */
+    HazelcastFailoverManager.prototype.cleanupFailedNodes = function (maxFailureAge) {
+        var _this = this;
+        if (maxFailureAge === void 0) { maxFailureAge = 300000; }
+        var now = Date.now();
+        var toRemove = [];
+        this.nodes.forEach(function (nodeInfo, addressStr) {
+            if (nodeInfo.state === NodeState.FAILED) {
+                var timeSinceFailure = now - nodeInfo.lastSeen;
+                if (timeSinceFailure > maxFailureAge) {
+                    toRemove.push(addressStr);
+                }
+            }
+        });
+        if (toRemove.length > 0) {
+            this.logger.info('HazelcastFailoverManager', "Cleaning up " + toRemove.length + " failed nodes");
+            toRemove.forEach(function (addressStr) {
+                _this.nodes.delete(addressStr);
+                _this.logger.debug('HazelcastFailoverManager', "Removed failed node: " + addressStr);
+            });
+        }
+    };
+    return HazelcastFailoverManager;
+}());
+exports.HazelcastFailoverManager = HazelcastFailoverManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celerispay/hazelcast-client",
-  "version": "3.12.5-8",
+  "version": "3.12.7-2",
   "description": "Hazelcast - open source In-Memory Data Grid - client for NodeJS with critical connection failover fixes",
   "main": "./lib/index.js",
   "scripts": {
@@ -38,18 +38,19 @@
   },
   "homepage": "https://github.com/celerispay/hazelcast-nodejs-client#readme",
   "dependencies": {
-    "bluebird": "3.5.1",
-    "long": "3.2.0",
-    "winston": "2.3.1"
+    "bluebird": "^3.7.2",
+    "long": "^4.0.0",
+    "safe-buffer": "^5.2.1"
   },
   "devDependencies": {
+    "@types/bluebird": "^3.5.21",
+    "@types/long": "^3.0.32",
     "@types/node": "8.0.0",
     "mocha": "3.2.0",
     "sinon": "4.0.0",
     "tslint": "5.7.0",
     "typedoc": "^0.16.11",
-    "typescript": "2.8.4",
-    "winston": "2.3.1"
+    "typescript": "2.8.4"
   },
   "typings": "./lib/index"
 }