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

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

@@ -47,6 +47,10 @@ export declare class ClusterService {
      */
     connectToCluster(): Promise<void>;
     getPossibleMemberAddresses(): Promise<string[]>;
+    /**
+     * Returns the owner connection if available
+     */
+    getOwnerConnection(): ClientConnection | null;
     /**
      * Returns the list of members in the cluster.
      * @returns
@@ -63,11 +67,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.
@@ -87,6 +86,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;
@@ -103,6 +103,12 @@ var ClusterService = /** @class */ (function () {
             return Array.from(new Set(Array.from(addresses).concat(Array.from(providerAddresses))));
         });
     };
+    /**
+     * Returns the owner connection if available
+     */
+    ClusterService.prototype.getOwnerConnection = function () {
+        return this.ownerConnection;
+    };
     /**
      * Returns the list of members in the cluster.
      * @returns
@@ -144,16 +150,15 @@ var ClusterService = /** @class */ (function () {
     ClusterService.prototype.getClientInfo = function () {
         var info = new ClientInfo_1.ClientInfo();
         info.uuid = this.uuid;
-        info.localAddress = this.getOwnerConnection().getLocalAddress();
+        var ownerConnection = this.getOwnerConnection();
+        if (ownerConnection) {
+            info.localAddress = ownerConnection.getLocalAddress();
+        }
+        else {
+            info.localAddress = null;
+        }
         return info;
     };
-    /**
-     * Returns the connection associated with owner node of this client.
-     * @returns {ClientConnection}
-     */
-    ClusterService.prototype.getOwnerConnection = function () {
-        return this.ownerConnection;
-    };
     /**
      * 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.
@@ -185,7 +190,11 @@ var ClusterService = /** @class */ (function () {
             var handleAttributeChange = _this.handleMemberAttributeChange.bind(_this);
             ClientAddMembershipListenerCodec_1.ClientAddMembershipListenerCodec.handle(m, handleMember, handleMemberList, handleAttributeChange, null);
         };
-        return this.client.getInvocationService().invokeOnConnection(this.getOwnerConnection(), request, handler)
+        var ownerConnection = this.getOwnerConnection();
+        if (!ownerConnection) {
+            return Promise.reject(new Error('Cannot initialize membership listener: no owner connection available'));
+        }
+        return this.client.getInvocationService().invokeOnConnection(ownerConnection, request, handler)
             .then(function (resp) {
             _this.logger.trace('ClusterService', 'Registered listener with id '
                 + ClientAddMembershipListenerCodec_1.ClientAddMembershipListenerCodec.decodeResponse(resp).response);
@@ -242,14 +251,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);
@@ -567,7 +612,7 @@ var ClusterService = /** @class */ (function () {
         // 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;
+        var pendingConnections = Object.keys(connectionManager.getPendingConnections()).length;
         if (pendingConnections > 0) {
             this.logger.debug('ClusterService', "Already have pending connections, skipping reconnection to " + addressStr);
             return;
@@ -651,6 +696,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/lib/proxy/ProxyManager.d.ts

@@ -37,4 +37,8 @@ export declare class ProxyManager {
     private findNextAddress();
     private initializeProxy(proxyObject, promise, deadline);
     private createDistributedObjectListener();
+    /**
+     * Checks if the cluster is healthy enough to create proxies
+     */
+    private isClusterHealthy();
 }

package/lib/proxy/ProxyManager.js

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+var Promise = require("bluebird");
 var ClientAddDistributedObjectListenerCodec_1 = require("../codec/ClientAddDistributedObjectListenerCodec");
 var ClientCreateProxyCodec_1 = require("../codec/ClientCreateProxyCodec");
 var ClientDestroyProxyCodec_1 = require("../codec/ClientDestroyProxyCodec");
@@ -68,6 +69,12 @@ var ProxyManager = /** @class */ (function () {
         if (this.proxies[fullName]) {
             return this.proxies[fullName];
         }
+        // Check if cluster is healthy before creating proxy
+        if (!this.isClusterHealthy()) {
+            var error = new Error('Cluster is not healthy, cannot create proxy for ' + name);
+            this.logger.error('ProxyManager', error.message);
+            return Promise.reject(error);
+        }
         var deferred = Util_1.DeferredPromise();
         var newProxy;
         if (serviceName === ProxyManager.MAP_SERVICE && this.client.getConfig().getNearCacheConfig(name)) {
@@ -91,6 +98,9 @@ var ProxyManager = /** @class */ (function () {
         if (createAtServer) {
             this.createProxy(newProxy).then(function () {
                 deferred.resolve(newProxy);
+            }).catch(function (error) {
+                _this.logger.error('ProxyManager', 'Failed to create proxy for ' + name + ': ' + error);
+                deferred.reject(error);
             });
         }
         this.proxies[fullName] = deferred.promise;
@@ -130,46 +140,68 @@ var ProxyManager = /** @class */ (function () {
     };
     ProxyManager.prototype.findNextAddress = function () {
         var members = this.client.getClusterService().getMembers();
+        // If no members available, return null but log the issue
+        if (!members || members.length === 0) {
+            this.logger.warn('ProxyManager', 'No cluster members available for proxy creation');
+            return null;
+        }
         var liteMember = null;
+        var dataMember = null;
         for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
             var member = members_1[_i];
             if (member != null && member.isLiteMember === false) {
-                return member.address;
+                dataMember = member;
+                break; // Prefer data members
             }
             else if (member != null && member.isLiteMember) {
                 liteMember = member;
             }
         }
-        if (liteMember != null) {
+        // Return data member if available, otherwise lite member, otherwise null
+        if (dataMember != null) {
+            return dataMember.address;
+        }
+        else if (liteMember != null) {
             return liteMember.address;
         }
         else {
+            this.logger.warn('ProxyManager', 'No valid members found for proxy creation');
             return null;
         }
     };
     ProxyManager.prototype.initializeProxy = function (proxyObject, promise, deadline) {
         var _this = this;
-        if (Date.now() <= deadline) {
-            var address = this.findNextAddress();
-            var request = ClientCreateProxyCodec_1.ClientCreateProxyCodec.encodeRequest(proxyObject.getName(), proxyObject.getServiceName(), address);
-            var invocation = new InvocationService_1.Invocation(this.client, request);
-            invocation.address = address;
-            this.client.getInvocationService().invoke(invocation).then(function (response) {
-                promise.resolve(response);
-            }).catch(function (error) {
-                if (_this.isRetryable(error)) {
-                    _this.logger.warn('ProxyManager', 'Create proxy request for ' + proxyObject.getName() +
-                        ' failed. Retrying in ' + _this.invocationRetryPauseMillis + 'ms. ' + error);
-                    setTimeout(_this.initializeProxy.bind(_this, proxyObject, promise, deadline), _this.invocationRetryPauseMillis);
-                }
-                else {
-                    _this.logger.warn('ProxyManager', 'Create proxy request for ' + proxyObject.getName() + ' failed ' + error);
-                }
-            });
+        if (Date.now() > deadline) {
+            var error = new Error('Create proxy request timed-out for ' + proxyObject.getName());
+            this.logger.error('ProxyManager', error.message);
+            promise.reject(error);
+            return;
         }
-        else {
-            promise.reject('Create proxy request timed-out for ' + proxyObject.getName());
+        var address = this.findNextAddress();
+        if (!address) {
+            var error = new Error('No cluster members available for proxy creation: ' + proxyObject.getName());
+            this.logger.error('ProxyManager', error.message);
+            promise.reject(error);
+            return;
         }
+        var request = ClientCreateProxyCodec_1.ClientCreateProxyCodec.encodeRequest(proxyObject.getName(), proxyObject.getServiceName(), address);
+        var invocation = new InvocationService_1.Invocation(this.client, request);
+        invocation.address = address;
+        this.client.getInvocationService().invoke(invocation).then(function (response) {
+            promise.resolve(response);
+        }).catch(function (error) {
+            if (_this.isRetryable(error)) {
+                _this.logger.warn('ProxyManager', 'Create proxy request for ' + proxyObject.getName() +
+                    ' failed. Retrying in ' + _this.invocationRetryPauseMillis + 'ms. ' + error);
+                setTimeout(function () {
+                    _this.initializeProxy(proxyObject, promise, deadline);
+                }, _this.invocationRetryPauseMillis);
+            }
+            else {
+                _this.logger.error('ProxyManager', 'Create proxy request for ' + proxyObject.getName() + ' failed ' + error);
+                promise.reject(error);
+            }
+        });
     };
     ProxyManager.prototype.createDistributedObjectListener = function () {
         return {
@@ -184,6 +216,30 @@ var ProxyManager = /** @class */ (function () {
             },
         };
     };
+    /**
+     * Checks if the cluster is healthy enough to create proxies
+     */
+    ProxyManager.prototype.isClusterHealthy = function () {
+        var members = this.client.getClusterService().getMembers();
+        var hasMembers = members && members.length > 0;
+        if (!hasMembers) {
+            this.logger.warn('ProxyManager', 'No cluster members available');
+            return false;
+        }
+        // Check if we have at least one data member
+        var hasDataMember = members.some(function (member) { return member && !member.isLiteMember; });
+        if (!hasDataMember) {
+            this.logger.warn('ProxyManager', 'No data members available in cluster');
+            return false;
+        }
+        // Check if we have an owner connection
+        var ownerConnection = this.client.getClusterService().getOwnerConnection();
+        if (!ownerConnection || !ownerConnection.isHealthy()) {
+            this.logger.warn('ProxyManager', 'No healthy owner connection available');
+            return false;
+        }
+        return true;
+    };
     ProxyManager.MAP_SERVICE = 'hz:impl:mapService';
     ProxyManager.SET_SERVICE = 'hz:impl:setService';
     ProxyManager.LOCK_SERVICE = 'hz:impl:lockService';

package/package.json

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