@celerispay/hazelcast-client 3.12.5 → 3.12.7-2

package/lib/invocation/ClientConnection.js

@@ -217,7 +217,44 @@ 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 - be more resilient to temporary disconnections
+        this.socket.on('end', function () {
+            _this.logger.debug('ClientConnection', "Socket ended by remote for " + _this.address.toString());
+            // Don't immediately mark as closed - this could be a temporary network hiccup
+            // Only mark as closed if we're certain it's a real disconnection
+            // The health check will handle this more gracefully
+        });
+        // Handle socket errors - be more resilient
+        this.socket.on('error', function (error) {
+            _this.logger.warn('ClientConnection', "Socket error for " + _this.address.toString() + ":", error);
+            // Only mark as closed for specific error types that indicate real disconnection
+            if (error.code === 'ECONNRESET' || error.code === 'EPIPE') {
+                _this.logger.warn('ClientConnection', "Critical socket error for " + _this.address.toString() + ", marking as closed");
+                _this.closedTime = Date.now();
+            }
+            // For other errors, don't immediately close - let health check handle it
+        });
+        // Handle socket timeout - be more resilient
+        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
+            // Let the health check handle this more gracefully
+        });
+    };
     /**
      * Returns the address of local port that is associated with this connection.
      * @returns
@@ -251,11 +288,68 @@ var ClientConnection = /** @class */ (function () {
      * Closes this connection.
      */
     ClientConnection.prototype.close = function () {
+        var addressStr = this.address.toString();
+        // Log who is initiating the disconnection
+        this.logger.info('ClientConnection', "\uD83D\uDD0C CLIENT INITIATED DISCONNECTION from " + addressStr);
+        // Log the call stack to understand why this is being called
+        this.logger.info('ClientConnection', "\uD83D\uDD0D Close Connection Call Stack for " + addressStr + ":");
+        var stack = new Error().stack;
+        if (stack) {
+            this.logger.info('ClientConnection', "   - Called from: " + stack.split('\n').slice(1, 4).join(' | '));
+        }
+        // Log connection state at closure
+        this.logger.info('ClientConnection', "\uD83D\uDCCA Connection State at Closure for " + addressStr + ":");
+        this.logger.info('ClientConnection', "   - Is Alive: " + this.isAlive());
+        this.logger.info('ClientConnection', "   - Is Healthy: " + this.isHealthy());
+        this.logger.info('ClientConnection', "   - Is Heartbeating: " + this.isHeartbeating());
+        this.logger.info('ClientConnection', "   - Is Owner: " + this.isAuthenticatedAsOwner());
+        this.logger.info('ClientConnection', "   - Last Read: " + (this.lastReadTimeMillis > 0 ? Math.round((Date.now() - this.lastReadTimeMillis) / 1000) + 's ago' : 'never'));
+        this.logger.info('ClientConnection', "   - Last Write: " + (this.lastWriteTimeMillis > 0 ? Math.round((Date.now() - this.lastWriteTimeMillis) / 1000) + 's ago' : 'never'));
+        this.logger.info('ClientConnection', "   - Connection Age: " + Math.round((Date.now() - this.startTime) / 1000) + "s");
         this.socket.end();
         this.closedTime = Date.now();
+        this.logger.info('ClientConnection', "\u2705 Disconnection completed for " + addressStr);
     };
+    /**
+     * 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;
+        }
+        // More resilient data freshness check - only fail if REALLY stale
+        var now = Date.now();
+        var lastReadThreshold = 120000; // Increased from 30s to 2 minutes for production resilience
+        if (this.lastReadTimeMillis > 0 && (now - this.lastReadTimeMillis) > lastReadThreshold) {
+            // Only mark as dead if we haven't received data for 2 minutes
+            // This prevents false drops due to temporary network hiccups
+            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 () {
+        var addressStr = this.address.toString();
+        if (!this.isAlive()) {
+            return false;
+        }
+        if (!this.isHeartbeating()) {
+            return false;
+        }
+        return true;
     };
     ClientConnection.prototype.isHeartbeating = function () {
         return this.heartbeating;

package/lib/invocation/ClientConnectionManager.d.ts

@@ -23,8 +23,12 @@ export declare class ClientConnectionManager extends EventEmitter {
     private failedConnections;
     private readonly maxConnectionRetries;
     private readonly connectionRetryDelay;
+    private connectionCleanupTask;
+    private readonly connectionCleanupInterval;
     constructor(client: HazelcastClient, addressTranslator: AddressTranslator, addressProviders: AddressProvider[]);
     private startConnectionHealthCheck();
+    private startConnectionCleanupTask();
+    private cleanupStaleConnections();
     private checkConnectionHealth();
     private isConnectionHealthy(connection);
     private retryConnection(address, asOwner, retryCount?);
@@ -32,6 +36,87 @@ 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>;
+    };
+    private credentialPreservationService;
+    private memberAddedEvents;
+    /**
+     * Updates preserved credentials with server-provided data
+     * @param address The address to update credentials for
+     * @param newUuid The new UUID from server member event
+     */
+    updatePreservedCredentials(address: Address, newUuid: string): void;
+    /**
+     * Records that a member added event was received from server
+     * @param address The address that had a server member added event
+     */
+    recordMemberAddedEvent(address: Address): void;
+    /**
+     * Checks if we received a server member added event for an address
+     * @param address The address to check
+     * @returns True if server member added event was received
+     */
+    hasMemberAddedEvent(address: Address): boolean;
+    /**
+     * Clears member added events for an address (useful during failover)
+     * @param address The address to clear events for
+     */
+    clearMemberAddedEvents(address: Address): void;
+    /**
+     * Updates ALL credentials with server-provided owner UUID
+     * @param newOwnerUuid The new owner UUID from server cluster state
+     */
+    updateAllCredentialsWithNewOwnerUuid(newOwnerUuid: string): void;
+    /**
+     * Gets the current owner UUID from server-stored credentials
+     * @returns The current owner UUID or null if not found
+     */
+    getCurrentOwnerUuid(): string | null;
+    /**
+     * Validates that all stored credentials are consistent with server data
+     * @returns True if all credentials are consistent, false otherwise
+     */
+    validateCredentialConsistency(): boolean;
+    /**
+     * Requests current cluster state from server when reconnecting
+     * This ensures we have the most up-to-date member information
+     * @returns Server cluster state
+     */
+    requestServerClusterState(): any;
+    /**
+     * Gets the current owner connection for server requests
+     * @returns The owner connection or null if not available
+     */
+    private getOwnerConnection();
     /**
      * 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}.
@@ -45,6 +130,20 @@ export declare class ClientConnectionManager extends EventEmitter {
      * @param address
      */
     destroyConnection(address: Address): void;
+    /**
+     * Cleans up all connections to a specific address during failover
+     * @param address The address to cleanup
+     */
+    cleanupConnectionsForFailover(address: Address): void;
+    /**
+     * Clears all stored credentials - used for single-node cluster reset
+     */
+    clearAllCredentials(): void;
+    /**
+     * Handles authentication errors by clearing failed connections and allowing retry
+     * @param address The address that had authentication issues
+     */
+    handleAuthenticationError(address: Address): void;
     shutdown(): void;
     private triggerConnect(address, asOwner);
     private connectTLSSocket(address, configOpts);