@celerispay/hazelcast-client 3.12.7-2 → 3.12.7-4

package/lib/invocation/ClusterService.d.ts

@@ -115,6 +115,13 @@ export declare class ClusterService {
     private tryConnectingToAddresses(index, remainingAttemptLimit, attemptPeriod, cause?);
     private handleMember(member, eventType);
     private handleMemberList(members);
+    /**
+     * Proactively opens connections to all non-owner cluster members.
+     * Required for smart routing: the client needs a live connection to every
+     * node so it can route operations to the correct partition owner.
+     * Failures are silently ignored — the periodic reconnection task will retry.
+     */
+    private connectToNonOwnerMembers(members);
     private detectMembershipEvents(prevMembers);
     private fireMembershipEvent(membershipEvent);
     private handleMemberAttributeChange(uuid, key, operationType, value);

package/lib/invocation/ClusterService.js

@@ -280,6 +280,13 @@ var ClusterService = /** @class */ (function () {
         this.client.getConnectionManager().forceCleanupDeadConnections();
         // Clear partition information
         this.client.getPartitionService().clearPartitionTable();
+        // IMPORTANT: Unblock all down addresses before attempting reconnection.
+        // The address was just marked as down by onConnectionClosed/onHeartbeatStopped,
+        // but connectToCluster() skips blocked addresses — so without clearing the block
+        // it will immediately fail with "Unable to connect to any address".
+        // clearAllCredentials() already clears failedConnections inside ConnectionManager.
+        this.logger.info('ClusterService', '🔓 SINGLE-NODE RESET: Unblocking all addresses for fresh reconnection...');
+        this.downAddresses.clear();
         // Direct reconnection without waiting for member events
         this.logger.info('ClusterService', '🔄 SINGLE-NODE RESET: Attempting direct reconnection...');
         this.connectToCluster()
@@ -467,12 +474,46 @@ var ClusterService = /** @class */ (function () {
         this.logger.info('ClusterService', 'Members received.', this.members);
         // Log current state after member list update
         this.logCurrentState();
+        // In smart routing mode, proactively open connections to all non-owner members
+        // so that partition-aware routing can work across all nodes.
+        if (this.client.getConfig().networkConfig.smartRouting) {
+            this.connectToNonOwnerMembers(members);
+        }
         var events = this.detectMembershipEvents(prevMembers);
         for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
             var event = events_1[_i];
             this.fireMembershipEvent(event);
         }
     };
+    /**
+     * Proactively opens connections to all non-owner cluster members.
+     * Required for smart routing: the client needs a live connection to every
+     * node so it can route operations to the correct partition owner.
+     * Failures are silently ignored — the periodic reconnection task will retry.
+     */
+    ClusterService.prototype.connectToNonOwnerMembers = function (members) {
+        var _this = this;
+        var ownerAddress = this.ownerConnection ? this.ownerConnection.getAddress().toString() : null;
+        members.forEach(function (member) {
+            var memberAddressStr = member.address.toString();
+            // Skip the owner — already connected
+            if (memberAddressStr === ownerAddress) {
+                return;
+            }
+            // Skip if already connected
+            if (_this.client.getConnectionManager().hasConnection(member.address)) {
+                return;
+            }
+            _this.logger.info('ClusterService', "\uD83D\uDD17 SMART-ROUTING: Opening connection to non-owner member " + memberAddressStr);
+            _this.client.getConnectionManager().getOrConnect(member.address, false)
+                .then(function () {
+                _this.logger.info('ClusterService', "\u2705 SMART-ROUTING: Connected to member " + memberAddressStr);
+            })
+                .catch(function (err) {
+                _this.logger.warn('ClusterService', "\u26A0\uFE0F SMART-ROUTING: Could not connect to member " + memberAddressStr + ": " + err.message);
+            });
+        });
+    };
     ClusterService.prototype.detectMembershipEvents = function (prevMembers) {
         var events = [];
         var eventMembers = Array.from(this.members);
@@ -572,6 +613,7 @@ var ClusterService = /** @class */ (function () {
      * @param member The member that was added
      */
     ClusterService.prototype.handleMemberAdded = function (member) {
+        var _this = this;
         this.logger.info('ClusterService', "\u2705 SERVER CONFIRMED: Member[ uuid: " + member.uuid + ", address: " + member.address.toString() + "] added to cluster");
         // SERVER-FIRST: Store server data as credentials
         // The server is the authority - we store what it tells us
@@ -607,6 +649,22 @@ var ClusterService = /** @class */ (function () {
         // Refresh partition table (KEEPING REFRESH METHOD UNTOUCHED as requested)
         this.client.getPartitionService().refresh();
         this.logger.info('ClusterService', "\u2705 SERVER-FIRST: Member " + member.uuid + " at " + member.address.toString() + " credentials stored from server data");
+        // In smart routing mode, proactively open a connection to this member
+        // so it is immediately available for partition-aware routing.
+        if (this.client.getConfig().networkConfig.smartRouting) {
+            var ownerAddress = this.ownerConnection ? this.ownerConnection.getAddress().toString() : null;
+            var memberAddressStr_1 = member.address.toString();
+            if (memberAddressStr_1 !== ownerAddress && !this.client.getConnectionManager().hasConnection(member.address)) {
+                this.logger.info('ClusterService', "\uD83D\uDD17 SMART-ROUTING: Opening connection to newly joined member " + memberAddressStr_1);
+                this.client.getConnectionManager().getOrConnect(member.address, false)
+                    .then(function () {
+                    _this.logger.info('ClusterService', "\u2705 SMART-ROUTING: Connected to newly joined member " + memberAddressStr_1);
+                })
+                    .catch(function (err) {
+                    _this.logger.warn('ClusterService', "\u26A0\uFE0F SMART-ROUTING: Could not connect to newly joined member " + memberAddressStr_1 + ": " + err.message);
+                });
+            }
+        }
     };
     /**
      * Finds the current owner from the cluster state
@@ -755,21 +813,35 @@ var ClusterService = /** @class */ (function () {
         }
         // Remove from down addresses to allow connection attempt
         this.downAddresses.delete(addressStr);
-        this.logger.debug('ClusterService', "Attempting reconnection to " + addressStr);
-        // Attempt to establish connection (not as owner, just as regular member connection)
-        this.client.getConnectionManager().getOrConnect(address, false)
+        // Determine whether to connect as owner.
+        // If we have no owner connection (e.g. after a single-node restart), we must
+        // authenticate as owner so the server assigns fresh UUIDs. Connecting as a
+        // non-owner with null UUIDs will always be rejected by the server.
+        var needsOwner = !this.ownerConnection || !this.ownerConnection.isHealthy();
+        var connectAsOwner = needsOwner;
+        this.logger.info('ClusterService', "Attempting reconnection to " + addressStr + " (asOwner=" + connectAsOwner + ", needsOwner=" + needsOwner + ")");
+        this.client.getConnectionManager().getOrConnect(address, connectAsOwner)
             .then(function (connection) {
             _this.logger.info('ClusterService', "Successfully reconnected to " + addressStr);
-            // Only evaluate ownership change if we don't have an owner or current owner is unhealthy
-            if (!_this.ownerConnection || !_this.ownerConnection.isHealthy()) {
-                _this.logger.info('ClusterService', "Evaluating ownership change for " + addressStr);
-                _this.evaluateOwnershipChange(address, connection);
+            if (connectAsOwner) {
+                // We authenticated as owner — make it official and re-register membership listener
+                connection.setAuthenticatedAsOwner(true);
+                _this.ownerConnection = connection;
+                _this.logger.info('ClusterService', "Promoted " + addressStr + " to owner after reconnection");
+                // Re-register membership listener so member events resume
+                return _this.initMembershipListener().then(function () {
+                    _this.logger.info('ClusterService', "Membership listener re-registered after reconnection to " + addressStr);
+                    _this.client.getPartitionService().refresh();
+                }).catch(function (err) {
+                    _this.logger.warn('ClusterService', "Failed to re-register membership listener after reconnection: " + err.message);
+                    _this.client.getPartitionService().refresh();
+                });
             }
             else {
+                // Non-owner: evaluate if ownership should change (multi-node case)
                 _this.logger.debug('ClusterService', "Keeping " + addressStr + " as member connection, current owner is healthy");
+                _this.client.getPartitionService().refresh();
             }
-            // Trigger partition service refresh to update routing information
-            _this.client.getPartitionService().refresh();
         }).catch(function (error) {
             _this.logger.warn('ClusterService', "Reconnection attempt to " + addressStr + " failed:", error);
             // Mark the address as down again, but with a shorter block duration for reconnection attempts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celerispay/hazelcast-client",
-  "version": "3.12.7-2",
+  "version": "3.12.7-4",
   "description": "Hazelcast - open source In-Memory Data Grid - client for NodeJS with critical connection failover fixes",
   "main": "./lib/index.js",
   "scripts": {