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

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

@@ -42,6 +42,11 @@ export declare class ClientConnectionManager extends EventEmitter {
      * @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
@@ -55,6 +60,13 @@ export declare class ClientConnectionManager extends EventEmitter {
     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

@@ -123,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;
@@ -135,9 +135,9 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         }).catch(function (error) {
             if (retryCount < _this.maxConnectionRetries) {
                 _this.logger.warn('ClientConnectionManager', "Connection attempt " + (retryCount + 1) + " failed for " + address.toString() + ", retrying in " + _this.connectionRetryDelay + "ms");
-                return new Promise(function (resolve) {
+                return new Promise(function (resolve, reject) {
                     setTimeout(function () {
-                        _this.retryConnection(address, asOwner, retryCount + 1).then(resolve).catch(resolve);
+                        _this.retryConnection(address, asOwner, retryCount + 1).then(resolve).catch(reject);
                     }, _this.connectionRetryDelay);
                 });
             }
@@ -181,6 +181,40 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         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
@@ -197,6 +231,13 @@ var ClientConnectionManager = /** @class */ (function (_super) {
     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}.
@@ -232,6 +273,13 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         this.pendingConnections[addressIndex] = connectionResolver;
         this.retryConnection(address, asOwner)
             .then(function (clientConnection) {
+            // Safety check: ensure we got a proper ClientConnection
+            if (!clientConnection || typeof clientConnection.getAddress !== 'function') {
+                var error = new Error("Invalid connection object returned: " + typeof clientConnection);
+                _this.logger.error('ClientConnectionManager', error.message);
+                connectionResolver.reject(error);
+                return;
+            }
             _this.establishedConnections[clientConnection.getAddress().toString()] = clientConnection;
             _this.onConnectionOpened(clientConnection);
             connectionResolver.resolve(clientConnection);

package/lib/invocation/ClusterService.js

@@ -230,6 +230,8 @@ var ClusterService = /** @class */ (function () {
         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
@@ -423,13 +425,26 @@ var ClusterService = /** @class */ (function () {
             var removedMemberList = this.members.splice(memberIndex, 1);
             assert(removedMemberList.length === 1);
         }
-        // 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);
+        // 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 {
-            this.logger.debug('ClusterService', "Member removed during failover: " + member.address.toString() + ", keeping connection for evaluation");
+            // 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);
@@ -549,6 +564,14 @@ var ClusterService = /** @class */ (function () {
             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);
@@ -557,7 +580,7 @@ var ClusterService = /** @class */ (function () {
             .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.isAlive()) {
+            if (!_this.ownerConnection || !_this.ownerConnection.isHealthy()) {
                 _this.logger.info('ClusterService', "Evaluating ownership change for " + addressStr);
                 _this.evaluateOwnershipChange(address, connection);
             }

package/package.json

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