@celerispay/hazelcast-client 3.12.5-1 → 3.12.5-2

package/lib/invocation/ClientConnectionManager.d.ts

@@ -36,6 +36,25 @@ export declare class ClientConnectionManager extends EventEmitter {
     getActiveConnections(): {
         [address: string]: ClientConnection;
     };
+    /**
+     * Checks if we already have a connection to the given address
+     * @param address The address to check
+     * @returns true if connection exists and is healthy, false otherwise
+     */
+    hasConnection(address: Address): boolean;
+    /**
+     * Gets an existing connection to a specific address if it exists
+     * @param address The address to check for existing connection
+     * @returns The existing connection or undefined if none exists
+     */
+    getConnection(address: Address): ClientConnection | undefined;
+    /**
+     * Gets all established connections
+     * @returns Object containing all established connections
+     */
+    getEstablishedConnections(): {
+        [address: string]: ClientConnection;
+    };
     /**
      * Returns the {@link ClientConnection} with given {@link Address}. If there is no such connection established,
      * it first connects to the address and then return the {@link ClientConnection}.

package/lib/invocation/ClientConnectionManager.js

@@ -98,6 +98,17 @@ var ClientConnectionManager = /** @class */ (function (_super) {
                 _this.destroyConnection(connection.getAddress());
             }
         });
+        // Log current connection state
+        var activeConnections = Object.keys(this.establishedConnections).length;
+        var pendingConnections = Object.keys(this.pendingConnections).length;
+        var failedConnections = this.failedConnections.size;
+        this.logger.debug('ClientConnectionManager', "Connection State - Active: " + activeConnections + ", Pending: " + pendingConnections + ", Failed: " + failedConnections);
+        if (activeConnections > 0) {
+            Object.keys(this.establishedConnections).forEach(function (addressStr) {
+                var connection = _this.establishedConnections[addressStr];
+                _this.logger.debug('ClientConnectionManager', "Connection to " + addressStr + ": Alive=" + connection.isAlive() + ", Owner=" + connection.isAuthenticatedAsOwner());
+            });
+        }
     };
     ClientConnectionManager.prototype.checkConnectionHealth = function () {
         // Use Object.keys() instead of Object.values() for compatibility
@@ -160,6 +171,32 @@ var ClientConnectionManager = /** @class */ (function (_super) {
     ClientConnectionManager.prototype.getActiveConnections = function () {
         return this.establishedConnections;
     };
+    /**
+     * Checks if we already have a connection to the given address
+     * @param address The address to check
+     * @returns true if connection exists and is healthy, false otherwise
+     */
+    ClientConnectionManager.prototype.hasConnection = function (address) {
+        var addressStr = address.toString();
+        var connection = this.establishedConnections[addressStr];
+        return connection && connection.isAlive();
+    };
+    /**
+     * Gets an existing connection to a specific address if it exists
+     * @param address The address to check for existing connection
+     * @returns The existing connection or undefined if none exists
+     */
+    ClientConnectionManager.prototype.getConnection = function (address) {
+        var addressStr = address.toString();
+        return this.establishedConnections[addressStr];
+    };
+    /**
+     * Gets all established connections
+     * @returns Object containing all established connections
+     */
+    ClientConnectionManager.prototype.getEstablishedConnections = function () {
+        return this.establishedConnections;
+    };
     /**
      * Returns the {@link ClientConnection} with given {@link Address}. If there is no such connection established,
      * it first connects to the address and then return the {@link ClientConnection}.

package/lib/invocation/ClusterService.d.ts

@@ -98,7 +98,15 @@ export declare class ClusterService {
     private handleMemberAttributeChange(uuid, key, operationType, value);
     private memberAdded(member);
     private memberRemoved(member);
+    /**
+     * Logs the current state for debugging purposes
+     */
+    private logCurrentState();
     private startReconnectionTask();
+    /**
+     * Starts a periodic task to log the current state for debugging
+     */
+    private startStateLoggingTask();
     private attemptReconnectionToFailedNodes();
     /**
      * Attempts to establish a connection to a specific address

package/lib/invocation/ClusterService.js

@@ -57,6 +57,7 @@ var ClusterService = /** @class */ (function () {
         this.logger = this.client.getLoggingService().getLogger();
         this.members = [];
         this.startReconnectionTask();
+        this.startStateLoggingTask();
     }
     /**
      * Starts cluster service.
@@ -227,15 +228,19 @@ var ClusterService = /** @class */ (function () {
         this.failoverInProgress = true;
         this.lastFailoverAttempt = now;
         this.logger.info('ClusterService', 'Starting failover process...');
+        // Log state before failover
+        this.logCurrentState();
         // Clear any stale partition information
         this.client.getPartitionService().clearPartitionTable();
         // Attempt to reconnect to cluster
         this.connectToCluster()
             .then(function () {
             _this.logger.info('ClusterService', 'Failover completed successfully');
+            _this.logCurrentState(); // Log state after successful failover
         })
             .catch(function (error) {
             _this.logger.error('ClusterService', 'Failover failed', error);
+            _this.logCurrentState(); // Log state after failed failover
             // If failover fails, shutdown the client to prevent further issues
             _this.client.shutdown();
         })
@@ -349,6 +354,8 @@ var ClusterService = /** @class */ (function () {
         this.members = members;
         this.client.getPartitionService().refresh();
         this.logger.info('ClusterService', 'Members received.', this.members);
+        // Log current state after member list update
+        this.logCurrentState();
         var events = this.detectMembershipEvents(prevMembers);
         for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
             var event = events_1[_i];
@@ -416,10 +423,42 @@ var ClusterService = /** @class */ (function () {
             var removedMemberList = this.members.splice(memberIndex, 1);
             assert(removedMemberList.length === 1);
         }
-        this.client.getConnectionManager().destroyConnection(member.address);
+        // Don't automatically destroy connections during failover
+        if (!this.failoverInProgress) {
+            this.logger.info('ClusterService', "Member removed: " + member.address.toString() + ", destroying connection");
+            this.client.getConnectionManager().destroyConnection(member.address);
+        }
+        else {
+            this.logger.debug('ClusterService', "Member removed during failover: " + member.address.toString() + ", keeping connection for evaluation");
+        }
         var membershipEvent = new MembershipEvent_1.MembershipEvent(member, MemberEvent.REMOVED, this.members);
         this.fireMembershipEvent(membershipEvent);
     };
+    /**
+     * Logs the current state for debugging purposes
+     */
+    ClusterService.prototype.logCurrentState = function () {
+        var _this = this;
+        var activeConnections = Object.keys(this.client.getConnectionManager().getEstablishedConnections()).length;
+        var memberCount = this.members.length;
+        var downAddressesCount = this.downAddresses.size;
+        var hasOwner = !!this.ownerConnection;
+        this.logger.info('ClusterService', "Current State - Members: " + memberCount + ", Active Connections: " + activeConnections + ", Down Addresses: " + downAddressesCount + ", Has Owner: " + hasOwner);
+        if (this.ownerConnection) {
+            this.logger.info('ClusterService', "Owner Connection: " + this.ownerConnection.getAddress().toString() + ", Alive: " + this.ownerConnection.isAlive());
+        }
+        // Log all active connections
+        var connections = this.client.getConnectionManager().getEstablishedConnections();
+        Object.keys(connections).forEach(function (addressStr) {
+            var connection = connections[addressStr];
+            _this.logger.debug('ClusterService', "Connection to " + addressStr + ": Alive=" + connection.isAlive() + ", Owner=" + connection.isAuthenticatedAsOwner());
+        });
+        // Log down addresses
+        if (downAddressesCount > 0) {
+            var downAddresses = Array.from(this.downAddresses.keys());
+            this.logger.debug('ClusterService', "Down Addresses: " + downAddresses.join(', '));
+        }
+    };
     ClusterService.prototype.startReconnectionTask = function () {
         var _this = this;
         // Periodically attempt to reconnect to previously failed addresses
@@ -427,15 +466,29 @@ var ClusterService = /** @class */ (function () {
             _this.attemptReconnectionToFailedNodes();
         }, this.reconnectionInterval);
     };
+    /**
+     * Starts a periodic task to log the current state for debugging
+     */
+    ClusterService.prototype.startStateLoggingTask = function () {
+        var _this = this;
+        // Log state every 30 seconds for debugging
+        setInterval(function () {
+            if (_this.client.getLifecycleService().isRunning()) {
+                _this.logCurrentState();
+            }
+        }, 30000);
+    };
     ClusterService.prototype.attemptReconnectionToFailedNodes = function () {
         var _this = this;
-        if (this.failoverInProgress || !this.ownerConnection) {
+        // Allow reconnection even during failover, but be more careful
+        if (this.failoverInProgress) {
+            this.logger.debug('ClusterService', 'Skipping reconnection attempt during failover');
             return;
         }
         var now = Date.now();
         var addressesToReconnect = [];
         var totalDownAddresses = this.downAddresses.size;
-        // If we have no down addresses, we can increase the reconnection interval
+        // If we have no down addresses, we can skip
         if (totalDownAddresses === 0) {
             return;
         }
@@ -449,6 +502,12 @@ var ClusterService = /** @class */ (function () {
                     var port = parseInt(portStr, 10);
                     if (host && !isNaN(port)) {
                         var address = new Address(host, port);
+                        // Check if we already have a connection to this address
+                        if (_this.client.getConnectionManager().hasConnection(address)) {
+                            _this.logger.debug('ClusterService', "Already have active connection to " + addressStr + ", removing from down addresses");
+                            _this.downAddresses.delete(addressStr);
+                            return;
+                        }
                         addressesToReconnect.push(address);
                     }
                 }
@@ -474,6 +533,8 @@ var ClusterService = /** @class */ (function () {
             });
             this.logger.debug('ClusterService', "Still waiting for " + totalDownAddresses + " addresses to unblock: " + remainingBlocked.join(', '));
         }
+        // Log current state after reconnection attempts
+        this.logCurrentState();
     };
     /**
      * Attempts to establish a connection to a specific address
@@ -482,6 +543,12 @@ var ClusterService = /** @class */ (function () {
     ClusterService.prototype.attemptReconnectionToAddress = function (address) {
         var _this = this;
         var addressStr = address.toString();
+        // Check if we already have a connection to this address
+        if (this.client.getConnectionManager().hasConnection(address)) {
+            this.logger.debug('ClusterService', "Already have active connection to " + addressStr + ", skipping reconnection");
+            this.downAddresses.delete(addressStr);
+            return;
+        }
         // Remove from down addresses to allow connection attempt
         this.downAddresses.delete(addressStr);
         this.logger.debug('ClusterService', "Attempting reconnection to " + addressStr);
@@ -489,8 +556,14 @@ var ClusterService = /** @class */ (function () {
         this.client.getConnectionManager().getOrConnect(address, false)
             .then(function (connection) {
             _this.logger.info('ClusterService', "Successfully reconnected to " + addressStr);
-            // Check if this reconnected node should become the new owner
-            _this.evaluateOwnershipChange(address, connection);
+            // Only evaluate ownership change if we don't have an owner or current owner is unhealthy
+            if (!_this.ownerConnection || !_this.ownerConnection.isAlive()) {
+                _this.logger.info('ClusterService', "Evaluating ownership change for " + addressStr);
+                _this.evaluateOwnershipChange(address, connection);
+            }
+            else {
+                _this.logger.debug('ClusterService', "Keeping " + addressStr + " as member connection, current owner is healthy");
+            }
             // Trigger partition service refresh to update routing information
             _this.client.getPartitionService().refresh();
         }).catch(function (error) {
@@ -518,12 +591,8 @@ var ClusterService = /** @class */ (function () {
             this.promoteToOwner(connection, address);
             return;
         }
-        // Check if this reconnected node was previously our owner (by checking if it's in our known addresses)
-        var wasPreviousOwner = this.knownAddresses.some(function (knownAddr) { return knownAddr.equals(address); });
-        if (wasPreviousOwner) {
-            this.logger.debug('ClusterService', "Reconnected node " + address.toString() + " was previously known, monitoring for ownership opportunity");
-            // Don't switch ownership immediately, but keep the connection for potential future use
-        }
+        // Don't switch ownership if current owner is healthy
+        this.logger.debug('ClusterService', "Current owner is healthy, keeping " + address.toString() + " as member connection");
     };
     /**
      * Promotes a connection to owner status

package/package.json

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