@celerispay/hazelcast-client 3.12.5 → 3.12.7-3

package/lib/invocation/ClientConnectionManager.js

@@ -35,6 +35,7 @@ var net = require("net");
 var tls = require("tls");
 var Util_1 = require("../Util");
 var BasicSSLOptionsFactory_1 = require("../connection/BasicSSLOptionsFactory");
+var CredentialPreservationService_1 = require("./CredentialPreservationService");
 var EMIT_CONNECTION_CLOSED = 'connectionClosed';
 var EMIT_CONNECTION_OPENED = 'connectionOpened';
 /**
@@ -49,11 +50,17 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         _this.failedConnections = new Set();
         _this.maxConnectionRetries = 3;
         _this.connectionRetryDelay = 1000;
+        _this.connectionCleanupTask = null;
+        _this.connectionCleanupInterval = 15000; // 15 seconds between cleanup checks
+        _this.memberAddedEvents = new Set();
         _this.client = client;
         _this.logger = _this.client.getLoggingService().getLogger();
         _this.addressTranslator = addressTranslator;
         _this.addressProviders = addressProviders;
+        // Initialize credential preservation service for server data storage
+        _this.credentialPreservationService = new CredentialPreservationService_1.CredentialPreservationService(_this.logger);
         _this.startConnectionHealthCheck();
+        _this.startConnectionCleanupTask();
         return _this;
     }
     ClientConnectionManager.prototype.startConnectionHealthCheck = function () {
@@ -63,6 +70,50 @@ var ClientConnectionManager = /** @class */ (function (_super) {
             _this.checkConnectionHealth();
         }, 5000);
     };
+    ClientConnectionManager.prototype.startConnectionCleanupTask = function () {
+        var _this = this;
+        // Periodically clean up stale connections and failed connection tracking
+        this.connectionCleanupTask = setInterval(function () {
+            _this.cleanupStaleConnections();
+        }, this.connectionCleanupInterval);
+    };
+    ClientConnectionManager.prototype.cleanupStaleConnections = function () {
+        var _this = this;
+        var now = Date.now();
+        var staleThreshold = 60000; // 1 minute threshold for stale connections
+        // Clean up failed connections that are older than threshold
+        var addressesToRemove = [];
+        this.failedConnections.forEach(function (address) {
+            // For now, we'll use a simple cleanup strategy
+            // In a more sophisticated implementation, we could track timestamps
+            addressesToRemove.push(address);
+        });
+        if (addressesToRemove.length > 0) {
+            this.logger.debug('ClientConnectionManager', "Cleaning up " + addressesToRemove.length + " stale failed connections");
+            addressesToRemove.forEach(function (address) {
+                _this.failedConnections.delete(address);
+            });
+        }
+        // Clean up any connections that are not responding
+        Object.keys(this.establishedConnections).forEach(function (addressStr) {
+            var connection = _this.establishedConnections[addressStr];
+            if (connection && !connection.isAlive()) {
+                _this.logger.warn('ClientConnectionManager', "Cleaning up stale connection to " + addressStr);
+                _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
         var connectionKeys = Object.keys(this.establishedConnections);
@@ -76,8 +127,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;
@@ -86,11 +137,21 @@ var ClientConnectionManager = /** @class */ (function (_super) {
             _this.failedConnections.delete(address.toString());
             return connection;
         }).catch(function (error) {
+            // Check if it's an authentication error
+            var isAuthError = error.message && (error.message.includes('Invalid Credentials') ||
+                error.message.includes('authentication') ||
+                error.message.includes('credentials'));
+            if (isAuthError) {
+                _this.logger.error('ClientConnectionManager', "Authentication failed for " + address.toString() + ", not retrying: " + error.message);
+                // Handle authentication errors specially
+                _this.handleAuthenticationError(address);
+                throw 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);
                 });
             }
@@ -124,6 +185,196 @@ 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;
+    };
+    /**
+     * Updates preserved credentials with server-provided data
+     * @param address The address to update credentials for
+     * @param newUuid The new UUID from server member event
+     */
+    ClientConnectionManager.prototype.updatePreservedCredentials = function (address, newUuid) {
+        var addressStr = address.toString();
+        this.logger.info('ClientConnectionManager', "\uD83D\uDD04 SERVER-FIRST: Updating credentials for " + addressStr + " with server UUID: " + newUuid);
+        // Get the current owner UUID from cluster service
+        var clusterService = this.client.getClusterService();
+        var currentOwnerUuid = clusterService.ownerUuid;
+        // Get group config from client
+        var groupConfig = this.client.getConfig().groupConfig;
+        // Store the server-provided UUID as the authoritative credential
+        // Use preserveCredentials to create new credentials if they don't exist
+        this.credentialPreservationService.preserveCredentials(address, newUuid, currentOwnerUuid || newUuid, // Use current owner UUID or fallback to member UUID
+        groupConfig.name, // Group name from config
+        groupConfig.password || '', // Group password from config
+        false // Not owner connection
+        );
+        // Mark that we received a member added event for this address
+        this.memberAddedEvents.add(addressStr);
+        this.logger.info('ClientConnectionManager', "\uD83D\uDCBE SERVER-FIRST: Stored server credential for " + addressStr + ": uuid=" + newUuid + ", ownerUuid=" + (currentOwnerUuid || newUuid));
+    };
+    /**
+     * Records that a member added event was received from server
+     * @param address The address that had a server member added event
+     */
+    ClientConnectionManager.prototype.recordMemberAddedEvent = function (address) {
+        var addressStr = address.toString();
+        this.memberAddedEvents.add(addressStr);
+        this.logger.debug('ClientConnectionManager', "\uD83D\uDCDD SERVER-FIRST: Recorded server member added event for " + addressStr);
+    };
+    /**
+     * 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
+     */
+    ClientConnectionManager.prototype.hasMemberAddedEvent = function (address) {
+        var addressStr = address.toString();
+        return this.memberAddedEvents.has(addressStr);
+    };
+    /**
+     * Clears member added events for an address (useful during failover)
+     * @param address The address to clear events for
+     */
+    ClientConnectionManager.prototype.clearMemberAddedEvents = function (address) {
+        var addressStr = address.toString();
+        this.memberAddedEvents.delete(addressStr);
+        this.logger.debug('ClientConnectionManager', "\uD83D\uDDD1\uFE0F SERVER-FIRST: Cleared member events for " + addressStr);
+    };
+    /**
+     * Updates ALL credentials with server-provided owner UUID
+     * @param newOwnerUuid The new owner UUID from server cluster state
+     */
+    ClientConnectionManager.prototype.updateAllCredentialsWithNewOwnerUuid = function (newOwnerUuid) {
+        this.logger.info('ClientConnectionManager', "\uD83D\uDD04 SERVER-FIRST: Updating ALL credentials with server owner UUID: " + newOwnerUuid);
+        // Update all preserved credentials with server data
+        this.credentialPreservationService.updateAllOwnerUuids(newOwnerUuid);
+        // Validate consistency
+        var isConsistent = this.credentialPreservationService.validateOwnerUuidConsistency();
+        if (isConsistent) {
+            this.logger.info('ClientConnectionManager', "\u2705 SERVER-FIRST: All credentials now consistent with server owner UUID: " + newOwnerUuid);
+        }
+        else {
+            this.logger.warn('ClientConnectionManager', "\u26A0\uFE0F SERVER-FIRST: Credential consistency validation failed after server update");
+        }
+    };
+    /**
+     * Gets the current owner UUID from server-stored credentials
+     * @returns The current owner UUID or null if not found
+     */
+    ClientConnectionManager.prototype.getCurrentOwnerUuid = function () {
+        return this.credentialPreservationService.getCurrentOwnerUuid();
+    };
+    /**
+     * Validates that all stored credentials are consistent with server data
+     * @returns True if all credentials are consistent, false otherwise
+     */
+    ClientConnectionManager.prototype.validateCredentialConsistency = function () {
+        return this.credentialPreservationService.validateOwnerUuidConsistency();
+    };
+    /**
+     * Requests current cluster state from server when reconnecting
+     * This ensures we have the most up-to-date member information
+     * @returns Server cluster state
+     */
+    ClientConnectionManager.prototype.requestServerClusterState = function () {
+        this.logger.info('ClientConnectionManager', "\uD83D\uDD0D SERVER-FIRST: Requesting current cluster state from server...");
+        try {
+            // Get the current owner connection
+            var ownerConnection = this.getOwnerConnection();
+            if (!ownerConnection || !ownerConnection.isAlive()) {
+                this.logger.warn('ClientConnectionManager', "\u26A0\uFE0F SERVER-FIRST: No active owner connection available for cluster state request");
+                return null;
+            }
+            // Request cluster state from the server
+            // This will give us the authoritative member list
+            this.logger.info('ClientConnectionManager', "\uD83D\uDCE4 SERVER-FIRST: Sending cluster state request to server...");
+            // For now, we'll use the existing cluster service to get member info
+            // In a full implementation, we'd send a specific protocol message
+            var clusterService = this.client.getClusterService();
+            var members = clusterService.getMembers();
+            this.logger.info('ClientConnectionManager', "\uD83D\uDCE5 SERVER-FIRST: Received cluster state from server: " + members.length + " members");
+            return {
+                members: members,
+                timestamp: Date.now(),
+                source: 'server'
+            };
+        }
+        catch (error) {
+            this.logger.error('ClientConnectionManager', "\u274C SERVER-FIRST: Failed to request cluster state from server: " + error.message);
+            return null;
+        }
+    };
+    /**
+     * Gets the current owner connection for server requests
+     * @returns The owner connection or null if not available
+     */
+    ClientConnectionManager.prototype.getOwnerConnection = function () {
+        var clusterService = this.client.getClusterService();
+        return clusterService.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}.
@@ -159,6 +410,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);
@@ -184,20 +442,78 @@ var ClientConnectionManager = /** @class */ (function (_super) {
      */
     ClientConnectionManager.prototype.destroyConnection = function (address) {
         var addressStr = address.toString();
+        // Clean up pending connections
         if (this.pendingConnections.hasOwnProperty(addressStr)) {
-            this.pendingConnections[addressStr].reject(null);
+            this.pendingConnections[addressStr].reject(new Error('Connection destroyed'));
+            delete this.pendingConnections[addressStr];
         }
+        // Clean up established connections
         if (this.establishedConnections.hasOwnProperty(addressStr)) {
             var conn = this.establishedConnections[addressStr];
             delete this.establishedConnections[addressStr];
-            conn.close();
+            try {
+                conn.close();
+            }
+            catch (error) {
+                this.logger.warn('ClientConnectionManager', "Error closing connection to " + addressStr + ":", error);
+            }
             this.onConnectionClosed(conn);
         }
+        // Mark as failed to prevent immediate reconnection attempts
+        this.failedConnections.add(addressStr);
+        this.logger.debug('ClientConnectionManager', "Connection to " + addressStr + " destroyed and marked as failed");
+    };
+    /**
+     * Cleans up all connections to a specific address during failover
+     * @param address The address to cleanup
+     */
+    ClientConnectionManager.prototype.cleanupConnectionsForFailover = function (address) {
+        var addressStr = address.toString();
+        this.logger.info('ClientConnectionManager', "Cleaning up all connections to " + addressStr + " for failover");
+        // Force cleanup of all connection types
+        this.destroyConnection(address);
+        // Remove from failed connections to allow reconnection after failover
+        this.failedConnections.delete(addressStr);
+    };
+    /**
+     * Clears all stored credentials - used for single-node cluster reset
+     */
+    ClientConnectionManager.prototype.clearAllCredentials = function () {
+        this.logger.info('ClientConnectionManager', '🧹 Clearing all stored credentials for cluster reset');
+        // Clear all stored credentials
+        this.credentialPreservationService.clearAllCredentials();
+        // Clear all failed connections to allow fresh reconnection attempts
+        this.failedConnections.clear();
+        this.logger.info('ClientConnectionManager', '✅ All credentials cleared, ready for fresh authentication');
+    };
+    /**
+     * Handles authentication errors by clearing failed connections and allowing retry
+     * @param address The address that had authentication issues
+     */
+    ClientConnectionManager.prototype.handleAuthenticationError = function (address) {
+        var addressStr = address.toString();
+        this.logger.warn('ClientConnectionManager', "Handling authentication error for " + addressStr);
+        // Clear from failed connections to allow retry with fresh credentials
+        this.failedConnections.delete(addressStr);
+        // Also clear any established connections to this address
+        if (this.establishedConnections.hasOwnProperty(addressStr)) {
+            this.logger.info('ClientConnectionManager', "Clearing established connection to " + addressStr + " due to auth error");
+            this.destroyConnection(address);
+        }
+        // Clear any pending connections
+        if (this.pendingConnections.hasOwnProperty(addressStr)) {
+            this.logger.info('ClientConnectionManager', "Clearing pending connection to " + addressStr + " due to auth error");
+            this.pendingConnections[addressStr].reject(new Error('Authentication error, connection cleared'));
+            delete this.pendingConnections[addressStr];
+        }
     };
     ClientConnectionManager.prototype.shutdown = function () {
         if (this.connectionHealthCheckInterval) {
             clearInterval(this.connectionHealthCheckInterval);
         }
+        if (this.connectionCleanupTask) {
+            clearInterval(this.connectionCleanupTask);
+        }
         for (var pending in this.pendingConnections) {
             this.pendingConnections[pending].reject(new HazelcastError_1.ClientNotActiveError('Client is shutting down!'));
         }
@@ -209,9 +525,20 @@ var ClientConnectionManager = /** @class */ (function (_super) {
     ClientConnectionManager.prototype.triggerConnect = function (address, asOwner) {
         var _this = this;
         if (!asOwner) {
-            if (this.client.getClusterService().getOwnerConnection() == null) {
-                var error = new HazelcastError_1.IllegalStateError('Owner connection is not available!');
-                return Promise.reject(error);
+            var ownerConnection = this.client.getClusterService().getOwnerConnection();
+            if (ownerConnection == null) {
+                // Check if this is a single-node scenario
+                var knownAddresses = this.client.getClusterService().getKnownAddresses();
+                var isSingleNode = knownAddresses.length === 1;
+                if (isSingleNode) {
+                    // Allow connection in single-node scenario
+                    this.logger.info('ClientConnectionManager', "\uD83D\uDD17 SINGLE-NODE: Allowing connection to " + address.toString() + " (only node in cluster)");
+                }
+                else {
+                    // Multi-node scenario - require owner connection (preserve existing logic)
+                    var error = new HazelcastError_1.IllegalStateError('Owner connection is not available!');
+                    return Promise.reject(error);
+                }
             }
         }
         if (this.client.getConfig().networkConfig.sslConfig.enabled) {
@@ -290,8 +617,65 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         this.emit(EMIT_CONNECTION_OPENED, connection);
     };
     ClientConnectionManager.prototype.authenticate = function (connection, ownerConnection) {
+        var _this = this;
+        var address = connection.getAddress();
+        var addressStr = address.toString();
+        this.logger.info('ClientConnectionManager', "\uD83D\uDD10 Starting authentication for " + addressStr + " (owner=" + ownerConnection + ")");
+        // Check if we have stored credentials for this address
+        var storedCredentials = this.credentialPreservationService.restoreCredentials(address);
+        var hasMemberAddedEvent = this.hasMemberAddedEvent(address);
+        if (storedCredentials) {
+            this.logger.info('ClientConnectionManager', "\uD83D\uDCCB Using STORED credentials for " + addressStr + ":");
+            this.logger.info('ClientConnectionManager', "   - UUID: " + storedCredentials.uuid);
+            this.logger.info('ClientConnectionManager', "   - Owner UUID: " + storedCredentials.ownerUuid);
+            this.logger.info('ClientConnectionManager', "   - Group Name: " + storedCredentials.groupName);
+            this.logger.info('ClientConnectionManager', "   - Member Added Event: " + (hasMemberAddedEvent ? 'YES' : 'NO'));
+        }
+        else {
+            this.logger.info('ClientConnectionManager', "\uD83D\uDCCB No stored credentials found for " + addressStr + ", using fresh authentication");
+        }
+        // Log current cluster state for debugging
+        var clusterService = this.client.getClusterService();
+        this.logger.info('ClientConnectionManager', "\uD83D\uDD0D Current cluster state for " + addressStr + ":");
+        this.logger.info('ClientConnectionManager', "   - Client UUID: " + (clusterService.uuid || 'NOT SET'));
+        this.logger.info('ClientConnectionManager', "   - Client Owner UUID: " + (clusterService.ownerUuid || 'NOT SET'));
+        this.logger.info('ClientConnectionManager', "   - Active Members: " + clusterService.getMembers().length);
+        // Log what we're about to send
+        this.logger.info('ClientConnectionManager', "\uD83D\uDCE4 Sending authentication request to " + addressStr + " with:");
+        this.logger.info('ClientConnectionManager', "   - Owner Connection: " + ownerConnection);
+        this.logger.info('ClientConnectionManager', "   - Using Stored Credentials: " + (storedCredentials ? 'YES' : 'NO'));
         var authenticator = new ConnectionAuthenticator_1.ConnectionAuthenticator(connection, this.client);
-        return authenticator.authenticate(ownerConnection);
+        // Use normal authentication flow - server handles everything
+        return authenticator.authenticate(ownerConnection)
+            .then(function () {
+            _this.logger.info('ClientConnectionManager', "\u2705 Authentication successful for " + addressStr);
+            // After successful authentication, store the new credentials from server
+            if (ownerConnection) {
+                var newUuid = clusterService.uuid;
+                var newOwnerUuid = clusterService.ownerUuid;
+                _this.logger.info('ClientConnectionManager', "\uD83D\uDCBE Storing new credentials from server for " + addressStr + ":");
+                _this.logger.info('ClientConnectionManager', "   - New UUID: " + newUuid);
+                _this.logger.info('ClientConnectionManager', "   - New Owner UUID: " + newOwnerUuid);
+                // Store the new credentials
+                _this.credentialPreservationService.updateCredentials(address, newUuid, newOwnerUuid);
+            }
+        })
+            .catch(function (error) {
+            _this.logger.error('ClientConnectionManager', "\u274C Authentication FAILED for " + addressStr + ":");
+            _this.logger.error('ClientConnectionManager', "   - Error: " + error.message);
+            _this.logger.error('ClientConnectionManager', "   - Used Stored Credentials: " + (storedCredentials ? 'YES' : 'NO'));
+            if (storedCredentials) {
+                _this.logger.error('ClientConnectionManager', "   - Failed Credentials: uuid=" + storedCredentials.uuid + ", ownerUuid=" + storedCredentials.ownerUuid);
+            }
+            _this.logger.error('ClientConnectionManager', "   - Current Client UUID: " + (clusterService.uuid || 'NOT SET'));
+            _this.logger.error('ClientConnectionManager', "   - Current Client Owner UUID: " + (clusterService.ownerUuid || 'NOT SET'));
+            // Clear failed credentials
+            if (storedCredentials) {
+                _this.logger.info('ClientConnectionManager', "\uD83D\uDDD1\uFE0F Clearing failed credentials for " + addressStr);
+                _this.credentialPreservationService.clearCredentialsForAddress(address);
+            }
+            throw error;
+        });
     };
     return ClientConnectionManager;
 }(events_1.EventEmitter));

package/lib/invocation/ClusterService.d.ts

@@ -6,6 +6,8 @@ import { ClientInfo } from '../ClientInfo';
 import HazelcastClient from '../HazelcastClient';
 import { MemberSelector } from '../core/MemberSelector';
 import { MembershipListener } from '../core/MembershipListener';
+import Address = require('../Address');
+import { HazelcastFailoverManager } from './HazelcastFailoverManager';
 export declare enum MemberEvent {
     ADDED = 1,
     REMOVED = 2,
@@ -33,6 +35,9 @@ export declare class ClusterService {
     private readonly failoverCooldown;
     private downAddresses;
     private readonly addressBlockDuration;
+    private reconnectionTask;
+    private readonly reconnectionInterval;
+    private failoverManager;
     constructor(client: HazelcastClient);
     /**
      * Starts cluster service.
@@ -45,6 +50,18 @@ export declare class ClusterService {
      */
     connectToCluster(): Promise<void>;
     getPossibleMemberAddresses(): Promise<string[]>;
+    /**
+     * Returns the owner connection if available
+     */
+    getOwnerConnection(): ClientConnection | null;
+    /**
+     * Returns whether failover is currently in progress
+     */
+    isFailoverInProgress(): boolean;
+    /**
+     * Returns the list of known addresses in the cluster
+     */
+    getKnownAddresses(): Address[];
     /**
      * Returns the list of members in the cluster.
      * @returns
@@ -61,11 +78,6 @@ export declare class ClusterService {
      * @returns {ClientInfo}
      */
     getClientInfo(): ClientInfo;
-    /**
-     * Returns the connection associated with owner node of this client.
-     * @returns {ClientConnection}
-     */
-    getOwnerConnection(): ClientConnection;
     /**
      * Adds MembershipListener to listen for membership updates. There is no check for duplicate registrations,
      * so if you register the listener twice, it will get events twice.
@@ -85,15 +97,96 @@ export declare class ClusterService {
     private onConnectionClosed(connection);
     private onHeartbeatStopped(connection);
     private triggerFailover();
+    /**
+     * Handles single-node cluster reset - treats node restart as fresh cluster
+     */
+    private handleSingleNodeClusterReset();
+    /**
+     * Handles multi-node failover - preserves existing logic
+     */
+    private handleMultiNodeFailover();
+    /**
+     * Attempts emergency recovery when failover fails
+     */
+    private attemptEmergencyRecovery();
     private isAddressKnownDown(address);
     private markAddressAsDown(address);
     private getDownAddressesInfo();
     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);
     private memberAdded(member);
     private memberRemoved(member);
+    /**
+     * Performs comprehensive credential cleanup when cluster membership changes
+     * This ensures ALL credentials are consistent with the current cluster owner UUID
+     * @param connectionManager The connection manager instance
+     * @param currentClusterOwnerUuid The current cluster owner UUID
+     */
+    /**
+     * Handles member added event - SERVER-FIRST APPROACH
+     * We trust what the server tells us and store it as credentials
+     * @param member The member that was added
+     */
+    private handleMemberAdded(member);
+    /**
+     * Finds the current owner from the cluster state
+     * @returns The current owner member or null if not found
+     */
+    private findCurrentOwner();
+    /**
+     * 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
+     * @param address The address to reconnect to
+     */
+    private attemptReconnectionToAddress(address);
+    /**
+     * Evaluates whether we should switch ownership to a reconnected node
+     * @param address The address of the reconnected node
+     * @param connection The connection to the reconnected node
+     */
+    private evaluateOwnershipChange(address, connection);
+    /**
+     * Promotes a connection to owner status
+     * @param connection The connection to promote
+     * @param address The address of the promoted connection
+     */
+    private promoteToOwner(connection, address);
+    /**
+     * Marks an address as down with a custom block duration
+     * @param address The address to mark as down
+     * @param blockDuration The duration to block the address (in milliseconds)
+     */
+    private markAddressAsDownWithDuration(address, blockDuration);
+    /**
+     * Handles ownership change when failover occurs
+     * @param newOwnerAddress The address of the new owner
+     * @param newOwnerConnection The connection to the new owner
+     */
+    handleOwnershipChange(newOwnerAddress: Address, newOwnerConnection: ClientConnection): void;
+    /**
+     * Gets the failover manager for external access
+     * @returns The failover manager instance
+     */
+    getFailoverManager(): HazelcastFailoverManager;
+    shutdown(): void;
 }