@celerispay/hazelcast-client 3.12.5 → 3.12.7-3

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/lib/invocation/InvocationService.js

@@ -289,6 +289,10 @@ var InvocationService = /** @class */ (function () {
                     throw new Error("Still no partition owner for partition " + partitionId + " after refresh");
                 }
                 return _this.invokeOnAddress(invocation, newOwnerAddress);
+            }).catch(function (error) {
+                _this.logger.error('InvocationService', "Failed to refresh partition table for partition " + partitionId + ":", error);
+                // If partition refresh fails, reject the invocation instead of hanging
+                throw new Error("Cannot find partition owner for partition " + partitionId + ": " + error.message);
             });
         }
         return this.client.getConnectionManager().getOrConnect(ownerAddress).then(function (connection) {
@@ -301,6 +305,10 @@ var InvocationService = /** @class */ (function () {
                 return _this.client.getPartitionService().refresh().then(function () {
                     // Retry the invocation with updated partition information
                     return _this.doInvoke(invocation);
+                }).catch(function (refreshError) {
+                    _this.logger.error('InvocationService', "Failed to refresh partition table after partition owner failure:", refreshError);
+                    // If refresh fails, reject the invocation instead of hanging
+                    throw new Error("Partition owner " + ownerAddress.toString() + " unavailable and partition refresh failed: " + refreshError.message);
                 });
             }
             throw new HazelcastError_1.IOError(ownerAddress.toString() + '(partition owner) is not available.', e);

package/lib/nearcache/StaleReadDetectorImpl.js

@@ -21,14 +21,41 @@ var StaleReadDetectorImpl = /** @class */ (function () {
         this.partitionService = partitionService;
     }
     StaleReadDetectorImpl.prototype.isStaleRead = function (key, record) {
-        var metadata = this.getMetadataContainer(this.getPartitionId(record.key));
-        return !record.hasSameUuid(metadata.getUuid()) || record.getInvalidationSequence().lessThan(metadata.getStaleSequence());
+        try {
+            var metadata = this.getMetadataContainer(this.getPartitionId(record.key));
+            // Add null checks to prevent errors during failover
+            if (!metadata || !metadata.getUuid()) {
+                // If metadata is not available, consider the read as potentially stale
+                // This can happen during failover when partition information is being updated
+                return true;
+            }
+            return !record.hasSameUuid(metadata.getUuid()) || record.getInvalidationSequence().lessThan(metadata.getStaleSequence());
+        }
+        catch (error) {
+            // During failover, partition service might not be fully initialized
+            // Consider the read as stale to be safe
+            return true;
+        }
     };
     StaleReadDetectorImpl.prototype.getMetadataContainer = function (partitionId) {
-        return this.repairingHandler.getMetadataContainer(partitionId);
+        try {
+            return this.repairingHandler.getMetadataContainer(partitionId);
+        }
+        catch (error) {
+            // Return null if metadata container is not available
+            // This can happen during failover scenarios
+            return null;
+        }
     };
     StaleReadDetectorImpl.prototype.getPartitionId = function (key) {
-        return this.partitionService.getPartitionId(key);
+        try {
+            return this.partitionService.getPartitionId(key);
+        }
+        catch (error) {
+            // Return -1 if partition service is not available
+            // This can happen during failover scenarios
+            return -1;
+        }
     };
     return StaleReadDetectorImpl;
 }());

package/lib/proxy/ProxyManager.js

@@ -130,20 +130,32 @@ var ProxyManager = /** @class */ (function () {
     };
     ProxyManager.prototype.findNextAddress = function () {
         var members = this.client.getClusterService().getMembers();
+        // If no members available, return null but log the issue
+        if (!members || members.length === 0) {
+            this.logger.warn('ProxyManager', 'No cluster members available for proxy creation');
+            return null;
+        }
         var liteMember = null;
+        var dataMember = null;
         for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
             var member = members_1[_i];
             if (member != null && member.isLiteMember === false) {
-                return member.address;
+                dataMember = member;
+                break; // Prefer data members
             }
             else if (member != null && member.isLiteMember) {
                 liteMember = member;
             }
         }
-        if (liteMember != null) {
+        // Return data member if available, otherwise lite member, otherwise null
+        if (dataMember != null) {
+            return dataMember.address;
+        }
+        else if (liteMember != null) {
             return liteMember.address;
         }
         else {
+            this.logger.warn('ProxyManager', 'No valid members found for proxy creation');
             return null;
         }
     };
@@ -151,6 +163,12 @@ var ProxyManager = /** @class */ (function () {
         var _this = this;
         if (Date.now() <= deadline) {
             var address = this.findNextAddress();
+            if (!address) {
+                var error = new Error('No cluster members available for proxy creation: ' + proxyObject.getName());
+                this.logger.error('ProxyManager', error.message);
+                promise.reject(error);
+                return;
+            }
             var request = ClientCreateProxyCodec_1.ClientCreateProxyCodec.encodeRequest(proxyObject.getName(), proxyObject.getServiceName(), address);
             var invocation = new InvocationService_1.Invocation(this.client, request);
             invocation.address = address;
@@ -160,10 +178,13 @@ var ProxyManager = /** @class */ (function () {
                 if (_this.isRetryable(error)) {
                     _this.logger.warn('ProxyManager', 'Create proxy request for ' + proxyObject.getName() +
                         ' failed. Retrying in ' + _this.invocationRetryPauseMillis + 'ms. ' + error);
-                    setTimeout(_this.initializeProxy.bind(_this, proxyObject, promise, deadline), _this.invocationRetryPauseMillis);
+                    setTimeout(function () {
+                        _this.initializeProxy(proxyObject, promise, deadline);
+                    }, _this.invocationRetryPauseMillis);
                 }
                 else {
-                    _this.logger.warn('ProxyManager', 'Create proxy request for ' + proxyObject.getName() + ' failed ' + error);
+                    _this.logger.error('ProxyManager', 'Create proxy request for ' + proxyObject.getName() + ' failed ' + error);
+                    promise.reject(error);
                 }
             });
         }

package/package.json

@@ -1,37 +1,13 @@
 {
   "name": "@celerispay/hazelcast-client",
-  "version": "3.12.5",
+  "version": "3.12.7-3",
   "description": "Hazelcast - open source In-Memory Data Grid - client for NodeJS with critical connection failover fixes",
-  "main": "lib/index.js",
-  "dependencies": {
-    "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": "6.0.87",
-    "chai": "4.1.2",
-    "chai-as-promised": "7.1.1",
-    "hazelcast-remote-controller": "^1.0.0",
-    "istanbul": "0.4.5",
-    "jsonschema": "1.2.4",
-    "mocha": "3.5.3",
-    "mocha-junit-reporter": "1.18.0",
-    "mousse": "0.3.1",
-    "remap-istanbul": "0.9.6",
-    "rimraf": "2.6.2",
-    "sinon": "4.0.0",
-    "tslint": "5.7.0",
-    "typedoc": "^0.16.11",
-    "typescript": "2.8.4",
-    "winston": "2.3.1"
-  },
+  "main": "./lib/index.js",
   "scripts": {
-    "clean": "rimraf lib typings *.jar *.log",
     "compile": "tsc",
     "pretest": "node download-remote-controller.js",
+    "build": "npm run compile",
+    "prepublishOnly": "npm run compile",
     "test": "mocha --recursive --reporter-options mochaFile=report.xml --reporter mocha-junit-reporter",
     "precoverage": "node download-remote-controller.js",
     "coverage": "rimraf coverage && istanbul cover --root lib/ --include-all-sources node_modules/mocha/bin/_mocha -- --recursive --reporter-options mochaFile=report.xml --reporter mocha-junit-reporter",
@@ -55,10 +31,26 @@
     "failover",
     "connection-fix"
   ],
+  "author": "Hazelcast Inc.",
   "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/celerispay/hazelcast-nodejs-client/issues"
   },
   "homepage": "https://github.com/celerispay/hazelcast-nodejs-client#readme",
+  "dependencies": {
+    "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"
+  },
   "typings": "./lib/index"
 }