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

package/lib/invocation/ClientConnectionManager.d.ts

@@ -82,9 +82,14 @@ export declare class ClientConnectionManager extends EventEmitter {
     destroyConnection(address: Address): void;
     /**
      * Cleans up all connections to a specific address during failover
-     * @param address
+     * @param address The address to cleanup
      */
     cleanupConnectionsForFailover(address: Address): 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);

package/lib/invocation/ClientConnectionManager.js

@@ -133,6 +133,16 @@ 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, reject) {
@@ -328,7 +338,7 @@ var ClientConnectionManager = /** @class */ (function (_super) {
     };
     /**
      * Cleans up all connections to a specific address during failover
-     * @param address
+     * @param address The address to cleanup
      */
     ClientConnectionManager.prototype.cleanupConnectionsForFailover = function (address) {
         var addressStr = address.toString();
@@ -338,6 +348,27 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         // Remove from failed connections to allow reconnection after failover
         this.failedConnections.delete(addressStr);
     };
+    /**
+     * 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);

package/lib/invocation/ClusterService.d.ts

@@ -87,6 +87,10 @@ export declare class ClusterService {
     private onConnectionClosed(connection);
     private onHeartbeatStopped(connection);
     private triggerFailover();
+    /**
+     * Attempts emergency recovery when failover fails
+     */
+    private attemptEmergencyRecovery();
     private isAddressKnownDown(address);
     private markAddressAsDown(address);
     private getDownAddressesInfo();

package/lib/invocation/ClusterService.js

@@ -50,7 +50,7 @@ var ClusterService = /** @class */ (function () {
         this.lastFailoverAttempt = 0;
         this.failoverCooldown = 5000; // 5 seconds cooldown between failover attempts
         this.downAddresses = new Map(); // address -> timestamp when marked down
-        this.addressBlockDuration = 30000; // 30 seconds block duration for down addresses
+        this.addressBlockDuration = 15000; // Reduced from 30000ms to 15000ms
         this.reconnectionTask = null;
         this.reconnectionInterval = 10000; // 10 seconds between reconnection attempts
         this.client = client;
@@ -242,14 +242,50 @@ var ClusterService = /** @class */ (function () {
         })
             .catch(function (error) {
             _this.logger.error('ClusterService', 'Failover failed', error);
+            // If failover fails, try to unblock at least one address to allow recovery
+            _this.attemptEmergencyRecovery();
             _this.logCurrentState(); // Log state after failed failover
-            // If failover fails, shutdown the client to prevent further issues
-            _this.client.shutdown();
+            // Don't shutdown immediately, give recovery a chance
         })
             .finally(function () {
             _this.failoverInProgress = false;
         });
     };
+    /**
+     * Attempts emergency recovery when failover fails
+     */
+    ClusterService.prototype.attemptEmergencyRecovery = function () {
+        var _this = this;
+        this.logger.warn('ClusterService', 'Attempting emergency recovery...');
+        // Unblock at least one address to allow recovery
+        if (this.downAddresses.size > 0) {
+            var firstBlockedAddress_1 = Array.from(this.downAddresses.keys())[0];
+            this.logger.info('ClusterService', "Emergency unblocking address " + firstBlockedAddress_1);
+            this.downAddresses.delete(firstBlockedAddress_1);
+            // Try to connect to the unblocked address
+            try {
+                var _a = firstBlockedAddress_1.split(':'), host = _a[0], portStr = _a[1];
+                var port = parseInt(portStr, 10);
+                if (host && !isNaN(port)) {
+                    var address_1 = new Address(host, port);
+                    this.logger.info('ClusterService', "Attempting emergency connection to " + firstBlockedAddress_1);
+                    // Try to connect without blocking
+                    this.client.getConnectionManager().getOrConnect(address_1, false)
+                        .then(function (connection) {
+                        _this.logger.info('ClusterService', "Emergency connection successful to " + firstBlockedAddress_1);
+                        _this.evaluateOwnershipChange(address_1, connection);
+                        _this.client.getPartitionService().refresh();
+                    })
+                        .catch(function (error) {
+                        _this.logger.warn('ClusterService', "Emergency connection failed to " + firstBlockedAddress_1 + ":", error);
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.error('ClusterService', 'Error during emergency recovery:', error);
+            }
+        }
+    };
     ClusterService.prototype.isAddressKnownDown = function (address) {
         var addressStr = address.toString();
         var downTime = this.downAddresses.get(addressStr);
@@ -651,6 +687,18 @@ var ClusterService = /** @class */ (function () {
         var _this = this;
         var addressStr = address.toString();
         var now = Date.now();
+        // Don't block if we already have a healthy connection to this address
+        if (this.client.getConnectionManager().hasConnection(address)) {
+            this.logger.debug('ClusterService', "Not blocking " + addressStr + " as we have a healthy connection");
+            return;
+        }
+        // Don't block if this would leave us with no available nodes
+        var totalDownAddresses = this.downAddresses.size;
+        var totalMembers = this.members.length;
+        if (totalDownAddresses >= totalMembers - 1) {
+            this.logger.warn('ClusterService', "Not blocking " + addressStr + " as it would leave us with no available nodes");
+            return;
+        }
         this.downAddresses.set(addressStr, now);
         this.logger.warn('ClusterService', "Marked address " + addressStr + " as down, will be blocked for " + blockDuration + "ms");
         // Schedule cleanup of this address after block duration

package/package.json

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