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

package/lib/invocation/ClientConnection.d.ts

@@ -46,7 +46,12 @@ export declare class ClientConnection {
     private readonly socket;
     private readonly writer;
     private readonly reader;
+    private readonly logger;
     constructor(client: HazelcastClient, address: Address, socket: net.Socket);
+    /**
+     * Sets up socket event handlers for proper connection state tracking
+     */
+    private setupSocketEventHandlers();
     /**
      * Returns the address of local port that is associated with this connection.
      * @returns
@@ -65,7 +70,16 @@ export declare class ClientConnection {
      * Closes this connection.
      */
     close(): void;
+    /**
+     * Checks if the connection is alive and healthy
+     * @returns true if connection is alive, false otherwise
+     */
     isAlive(): boolean;
+    /**
+     * Performs a more thorough health check of the connection
+     * @returns true if connection is healthy, false otherwise
+     */
+    isHealthy(): boolean;
     isHeartbeating(): boolean;
     setHeartbeating(heartbeating: boolean): void;
     isAuthenticatedAsOwner(): boolean;

package/lib/invocation/ClientConnection.js

@@ -217,7 +217,36 @@ var ClientConnection = /** @class */ (function () {
             _this.lastWriteTimeMillis = Date.now();
         });
         this.reader = new FrameReader();
+        this.logger = client.getLoggingService().getLogger();
+        // Add socket event handlers for proper connection state tracking
+        this.setupSocketEventHandlers();
     }
+    /**
+     * Sets up socket event handlers for proper connection state tracking
+     */
+    ClientConnection.prototype.setupSocketEventHandlers = function () {
+        var _this = this;
+        // Handle socket close events
+        this.socket.on('close', function () {
+            _this.closedTime = Date.now();
+            _this.logger.debug('ClientConnection', "Socket closed for " + _this.address.toString());
+        });
+        // Handle socket end events
+        this.socket.on('end', function () {
+            _this.closedTime = Date.now();
+            _this.logger.debug('ClientConnection', "Socket ended by remote for " + _this.address.toString());
+        });
+        // Handle socket errors
+        this.socket.on('error', function (error) {
+            _this.logger.warn('ClientConnection', "Socket error for " + _this.address.toString() + ":", error);
+            // Don't set closedTime here as the socket might still be usable
+        });
+        // Handle socket timeout
+        this.socket.on('timeout', function () {
+            _this.logger.warn('ClientConnection', "Socket timeout for " + _this.address.toString());
+            // Don't set closedTime here as the socket might still be usable
+        });
+    };
     /**
      * Returns the address of local port that is associated with this connection.
      * @returns
@@ -254,8 +283,43 @@ var ClientConnection = /** @class */ (function () {
         this.socket.end();
         this.closedTime = Date.now();
     };
+    /**
+     * Checks if the connection is alive and healthy
+     * @returns true if connection is alive, false otherwise
+     */
     ClientConnection.prototype.isAlive = function () {
-        return this.closedTime === 0;
+        // Check if we've explicitly closed the connection
+        if (this.closedTime !== 0) {
+            return false;
+        }
+        // Check if the underlying socket is still connected
+        if (!this.socket || this.socket.destroyed) {
+            return false;
+        }
+        // Check if the socket is writable (indicates it's still connected)
+        if (!this.socket.writable) {
+            return false;
+        }
+        // Check if we've received data recently (within last 30 seconds)
+        var now = Date.now();
+        var lastReadThreshold = 30000; // 30 seconds
+        if (this.lastReadTimeMillis > 0 && (now - this.lastReadTimeMillis) > lastReadThreshold) {
+            // If we haven't received data for a while, the connection might be stale
+            return false;
+        }
+        return true;
+    };
+    /**
+     * Performs a more thorough health check of the connection
+     * @returns true if connection is healthy, false otherwise
+     */
+    ClientConnection.prototype.isHealthy = function () {
+        if (!this.isAlive()) {
+            return false;
+        }
+        // Additional health checks can be added here
+        // For now, just check if we're still heartbeating
+        return this.isHeartbeating();
     };
     ClientConnection.prototype.isHeartbeating = function () {
         return this.heartbeating;

package/lib/invocation/ClientConnectionManager.d.ts

@@ -36,6 +36,37 @@ 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;
+    /**
+     * Forces cleanup of all dead connections
+     * This is useful during failover to prevent connection leakage
+     */
+    forceCleanupDeadConnections(): void;
+    /**
+     * 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;
+    };
+    /**
+     * Gets all pending connections
+     * @returns Object containing all pending connections
+     */
+    getPendingConnections(): {
+        [address: string]: Promise.Resolver<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
@@ -112,8 +123,8 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         }
     };
     ClientConnectionManager.prototype.isConnectionHealthy = function (connection) {
-        // Only check if connection is alive - isAuthenticated() method doesn't exist
-        return connection.isAlive();
+        // Use the improved health check method
+        return connection.isHealthy();
     };
     ClientConnectionManager.prototype.retryConnection = function (address, asOwner, retryCount) {
         var _this = this;
@@ -160,6 +171,73 @@ 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();
+    };
+    /**
+     * Forces cleanup of all dead connections
+     * This is useful during failover to prevent connection leakage
+     */
+    ClientConnectionManager.prototype.forceCleanupDeadConnections = function () {
+        var _this = this;
+        this.logger.info('ClientConnectionManager', 'Forcing cleanup of all dead connections');
+        var addressesToRemove = [];
+        // Check all established connections
+        Object.keys(this.establishedConnections).forEach(function (addressStr) {
+            var connection = _this.establishedConnections[addressStr];
+            if (connection && !connection.isHealthy()) {
+                _this.logger.warn('ClientConnectionManager', "Found dead connection to " + addressStr + ", marking for cleanup");
+                addressesToRemove.push(addressStr);
+            }
+        });
+        // Remove dead connections
+        addressesToRemove.forEach(function (addressStr) {
+            var connection = _this.establishedConnections[addressStr];
+            if (connection) {
+                _this.destroyConnection(connection.getAddress());
+            }
+        });
+        // Also clean up any pending connections that might be stuck
+        Object.keys(this.pendingConnections).forEach(function (addressStr) {
+            var pendingConnection = _this.pendingConnections[addressStr];
+            if (pendingConnection) {
+                _this.logger.warn('ClientConnectionManager', "Cleaning up stuck pending connection to " + addressStr);
+                pendingConnection.reject(new Error('Connection cleanup forced'));
+                delete _this.pendingConnections[addressStr];
+            }
+        });
+        this.logger.info('ClientConnectionManager', "Cleanup completed. Removed " + addressesToRemove.length + " dead connections");
+    };
+    /**
+     * 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;
+    };
+    /**
+     * Gets all pending connections
+     * @returns Object containing all pending connections
+     */
+    ClientConnectionManager.prototype.getPendingConnections = function () {
+        return this.pendingConnections;
+    };
     /**
      * 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,21 @@ var ClusterService = /** @class */ (function () {
         this.failoverInProgress = true;
         this.lastFailoverAttempt = now;
         this.logger.info('ClusterService', 'Starting failover process...');
+        // Log state before failover
+        this.logCurrentState();
+        // Force cleanup of all dead connections to prevent leakage
+        this.client.getConnectionManager().forceCleanupDeadConnections();
         // 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 +356,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 +425,55 @@ var ClusterService = /** @class */ (function () {
             var removedMemberList = this.members.splice(memberIndex, 1);
             assert(removedMemberList.length === 1);
         }
-        this.client.getConnectionManager().destroyConnection(member.address);
+        // Check if we have a healthy connection to this member
+        var connectionManager = this.client.getConnectionManager();
+        var existingConnection = connectionManager.getConnection(member.address);
+        if (existingConnection && existingConnection.isHealthy()) {
+            // If the connection is healthy, don't destroy it immediately
+            // This prevents unnecessary disconnections during temporary network issues
+            this.logger.info('ClusterService', "Member removed but connection is healthy: " + member.address.toString() + ", preserving connection");
+            // Only destroy if we're not in failover mode
+            if (!this.failoverInProgress) {
+                this.logger.debug('ClusterService', "Destroying healthy connection to removed member: " + member.address.toString());
+                connectionManager.destroyConnection(member.address);
+            }
+            else {
+                this.logger.debug('ClusterService', "Preserving healthy connection during failover: " + member.address.toString());
+            }
+        }
+        else {
+            // If connection is unhealthy, destroy it
+            this.logger.info('ClusterService', "Member removed with unhealthy connection: " + member.address.toString() + ", destroying connection");
+            connectionManager.destroyConnection(member.address);
+        }
         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 +481,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 +517,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 +548,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 +558,20 @@ 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;
+        }
+        // Check if we're already trying to connect to this address
+        var connectionManager = this.client.getConnectionManager();
+        var establishedConnections = connectionManager.getEstablishedConnections();
+        var pendingConnections = Object.keys(connectionManager.getPendingConnections || {}).length;
+        if (pendingConnections > 0) {
+            this.logger.debug('ClusterService', "Already have pending connections, skipping reconnection to " + addressStr);
+            return;
+        }
         // Remove from down addresses to allow connection attempt
         this.downAddresses.delete(addressStr);
         this.logger.debug('ClusterService', "Attempting reconnection to " + addressStr);
@@ -489,8 +579,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.isHealthy()) {
+                _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 +614,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-3",
   "description": "Hazelcast - open source In-Memory Data Grid - client for NodeJS with critical connection failover fixes",
   "main": "./lib/index.js",
   "scripts": {