@celerispay/hazelcast-client 3.12.5-1

package/lib/invocation/ClientConnectionManager.js

@@ -0,0 +1,360 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var safe_buffer_1 = require("safe-buffer");
+var Promise = require("bluebird");
+var events_1 = require("events");
+var HazelcastError_1 = require("../HazelcastError");
+var ClientConnection_1 = require("./ClientConnection");
+var ConnectionAuthenticator_1 = require("./ConnectionAuthenticator");
+var net = require("net");
+var tls = require("tls");
+var Util_1 = require("../Util");
+var BasicSSLOptionsFactory_1 = require("../connection/BasicSSLOptionsFactory");
+var EMIT_CONNECTION_CLOSED = 'connectionClosed';
+var EMIT_CONNECTION_OPENED = 'connectionOpened';
+/**
+ * Maintains connections between the client and members of the cluster.
+ */
+var ClientConnectionManager = /** @class */ (function (_super) {
+    __extends(ClientConnectionManager, _super);
+    function ClientConnectionManager(client, addressTranslator, addressProviders) {
+        var _this = _super.call(this) || this;
+        _this.establishedConnections = {};
+        _this.pendingConnections = {};
+        _this.failedConnections = new Set();
+        _this.maxConnectionRetries = 3;
+        _this.connectionRetryDelay = 1000;
+        _this.connectionCleanupTask = null;
+        _this.connectionCleanupInterval = 15000; // 15 seconds between cleanup checks
+        _this.client = client;
+        _this.logger = _this.client.getLoggingService().getLogger();
+        _this.addressTranslator = addressTranslator;
+        _this.addressProviders = addressProviders;
+        _this.startConnectionHealthCheck();
+        _this.startConnectionCleanupTask();
+        return _this;
+    }
+    ClientConnectionManager.prototype.startConnectionHealthCheck = function () {
+        var _this = this;
+        // Check connection health every 5 seconds
+        this.connectionHealthCheckInterval = setInterval(function () {
+            _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());
+            }
+        });
+    };
+    ClientConnectionManager.prototype.checkConnectionHealth = function () {
+        // Use Object.keys() instead of Object.values() for compatibility
+        var connectionKeys = Object.keys(this.establishedConnections);
+        for (var _i = 0, connectionKeys_1 = connectionKeys; _i < connectionKeys_1.length; _i++) {
+            var key = connectionKeys_1[_i];
+            var connection = this.establishedConnections[key];
+            if (!connection.isAlive()) {
+                this.logger.warn('ClientConnectionManager', "Connection to " + connection.getAddress().toString() + " is not alive, destroying it");
+                this.destroyConnection(connection.getAddress());
+            }
+        }
+    };
+    ClientConnectionManager.prototype.isConnectionHealthy = function (connection) {
+        // Only check if connection is alive - isAuthenticated() method doesn't exist
+        return connection.isAlive();
+    };
+    ClientConnectionManager.prototype.retryConnection = function (address, asOwner, retryCount) {
+        var _this = this;
+        if (retryCount === void 0) { retryCount = 0; }
+        return this.createConnection(address, asOwner).then(function (connection) {
+            _this.failedConnections.delete(address.toString());
+            return connection;
+        }).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) {
+                    setTimeout(function () {
+                        _this.retryConnection(address, asOwner, retryCount + 1).then(resolve).catch(resolve);
+                    }, _this.connectionRetryDelay);
+                });
+            }
+            else {
+                _this.failedConnections.add(address.toString());
+                _this.logger.error('ClientConnectionManager', "Failed to connect to " + address.toString() + " after " + _this.maxConnectionRetries + " attempts");
+                throw error;
+            }
+        });
+    };
+    ClientConnectionManager.prototype.createConnection = function (address, asOwner) {
+        var _this = this;
+        return this.addressTranslator.translate(address).then(function (addr) {
+            if (addr == null) {
+                throw new RangeError('Address Translator could not translate address ' + address.toString());
+            }
+            return _this.triggerConnect(addr, asOwner).then(function (socket) {
+                var clientConnection = new ClientConnection_1.ClientConnection(_this.client, addr, socket);
+                return _this.initiateCommunication(clientConnection).then(function () {
+                    return clientConnection.registerResponseCallback(function (data) {
+                        _this.client.getInvocationService().processResponse(data);
+                    });
+                }).then(function () {
+                    return _this.authenticate(clientConnection, asOwner);
+                }).then(function () {
+                    return clientConnection;
+                });
+            });
+        });
+    };
+    ClientConnectionManager.prototype.getActiveConnections = function () {
+        return this.establishedConnections;
+    };
+    /**
+     * 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}.
+     * @param address
+     * @param asOwner Sets the connected node as owner of this client if true.
+     * @returns {Promise<ClientConnection>|Promise<T>}
+     */
+    ClientConnectionManager.prototype.getOrConnect = function (address, asOwner) {
+        var _this = this;
+        if (asOwner === void 0) { asOwner = false; }
+        var addressIndex = address.toString();
+        // Check if connection is already established and healthy
+        var establishedConnection = this.establishedConnections[addressIndex];
+        if (establishedConnection && this.isConnectionHealthy(establishedConnection)) {
+            return Promise.resolve(establishedConnection);
+        }
+        // If existing connection is unhealthy, destroy it
+        if (establishedConnection && !this.isConnectionHealthy(establishedConnection)) {
+            this.logger.warn('ClientConnectionManager', "Destroying unhealthy connection to " + addressIndex);
+            this.destroyConnection(address);
+        }
+        // Check if we're already trying to connect
+        var pendingConnection = this.pendingConnections[addressIndex];
+        if (pendingConnection) {
+            return pendingConnection.promise;
+        }
+        // Check if this address has failed too many times recently
+        if (this.failedConnections.has(addressIndex)) {
+            var error = new Error("Address " + addressIndex + " has failed recently and is temporarily blocked");
+            return Promise.reject(error);
+        }
+        var connectionResolver = Util_1.DeferredPromise();
+        this.pendingConnections[addressIndex] = connectionResolver;
+        this.retryConnection(address, asOwner)
+            .then(function (clientConnection) {
+            _this.establishedConnections[clientConnection.getAddress().toString()] = clientConnection;
+            _this.onConnectionOpened(clientConnection);
+            connectionResolver.resolve(clientConnection);
+        })
+            .catch(function (e) {
+            _this.logger.error('ClientConnectionManager', "Failed to establish connection to " + addressIndex, e);
+            connectionResolver.reject(e);
+        })
+            .finally(function () {
+            delete _this.pendingConnections[addressIndex];
+        });
+        var connectionTimeout = this.client.getConfig().networkConfig.connectionTimeout;
+        if (connectionTimeout !== 0) {
+            return connectionResolver.promise.timeout(connectionTimeout, new HazelcastError_1.HazelcastError('Connection timed-out')).finally(function () {
+                delete _this.pendingConnections[addressIndex];
+            });
+        }
+        return connectionResolver.promise;
+    };
+    /**
+     * Destroys the connection with given node address.
+     * @param address
+     */
+    ClientConnectionManager.prototype.destroyConnection = function (address) {
+        var addressStr = address.toString();
+        // Clean up pending connections
+        if (this.pendingConnections.hasOwnProperty(addressStr)) {
+            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];
+            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
+     */
+    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);
+    };
+    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!'));
+        }
+        for (var conn in this.establishedConnections) {
+            this.establishedConnections[conn].close();
+        }
+        this.failedConnections.clear();
+    };
+    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);
+            }
+        }
+        if (this.client.getConfig().networkConfig.sslConfig.enabled) {
+            if (this.client.getConfig().networkConfig.sslConfig.sslOptions) {
+                var opts = this.client.getConfig().networkConfig.sslConfig.sslOptions;
+                return this.connectTLSSocket(address, opts);
+            }
+            else if (this.client.getConfig().networkConfig.sslConfig.sslOptionsFactoryConfig) {
+                var factoryConfig = this.client.getConfig().networkConfig.sslConfig.sslOptionsFactoryConfig;
+                var factoryProperties = this.client.getConfig().networkConfig.sslConfig.sslOptionsFactoryProperties;
+                var factory_1;
+                if (factoryConfig.path) {
+                    factory_1 = new (Util_1.loadNameFromPath(factoryConfig.path, factoryConfig.exportedName))();
+                }
+                else {
+                    factory_1 = new BasicSSLOptionsFactory_1.BasicSSLOptionsFactory();
+                }
+                return factory_1.init(factoryProperties).then(function () {
+                    return _this.connectTLSSocket(address, factory_1.getSSLOptions());
+                });
+            }
+            else {
+                // the default behavior when ssl is enabled
+                var opts = this.client.getConfig().networkConfig.sslConfig.sslOptions = {
+                    checkServerIdentity: function () { return null; },
+                    rejectUnauthorized: true,
+                };
+                return this.connectTLSSocket(address, opts);
+            }
+        }
+        else {
+            return this.connectNetSocket(address);
+        }
+    };
+    ClientConnectionManager.prototype.connectTLSSocket = function (address, configOpts) {
+        var _this = this;
+        var connectionResolver = Util_1.DeferredPromise();
+        var socket = tls.connect(address.port, address.host, configOpts);
+        socket.once('secureConnect', function () {
+            connectionResolver.resolve(socket);
+        });
+        socket.on('error', function (e) {
+            _this.logger.warn('ClientConnectionManager', 'Could not connect to address ' + address.toString(), e);
+            connectionResolver.reject(e);
+            if (e.code === 'EPIPE' || e.code === 'ECONNRESET') {
+                _this.destroyConnection(address);
+            }
+        });
+        return connectionResolver.promise;
+    };
+    ClientConnectionManager.prototype.connectNetSocket = function (address) {
+        var _this = this;
+        var connectionResolver = Util_1.DeferredPromise();
+        var socket = net.connect(address.port, address.host);
+        socket.once('connect', function () {
+            connectionResolver.resolve(socket);
+        });
+        socket.on('error', function (e) {
+            _this.logger.warn('ClientConnectionManager', 'Could not connect to address ' + address.toString(), e);
+            connectionResolver.reject(e);
+            if (e.code === 'EPIPE' || e.code === 'ECONNRESET') {
+                _this.destroyConnection(address);
+            }
+        });
+        return connectionResolver.promise;
+    };
+    ClientConnectionManager.prototype.initiateCommunication = function (connection) {
+        // Send the protocol version
+        var buffer = safe_buffer_1.Buffer.from('CB2');
+        return connection.write(buffer);
+    };
+    ClientConnectionManager.prototype.onConnectionClosed = function (connection) {
+        this.emit(EMIT_CONNECTION_CLOSED, connection);
+    };
+    ClientConnectionManager.prototype.onConnectionOpened = function (connection) {
+        this.emit(EMIT_CONNECTION_OPENED, connection);
+    };
+    ClientConnectionManager.prototype.authenticate = function (connection, ownerConnection) {
+        var authenticator = new ConnectionAuthenticator_1.ConnectionAuthenticator(connection, this.client);
+        return authenticator.authenticate(ownerConnection);
+    };
+    return ClientConnectionManager;
+}(events_1.EventEmitter));
+exports.ClientConnectionManager = ClientConnectionManager;

package/lib/invocation/ClientEventRegistration.d.ts

@@ -0,0 +1,10 @@
+import { ListenerMessageCodec } from '../ListenerMessageCodec';
+import { ClientConnection } from './ClientConnection';
+export declare class ClientEventRegistration {
+    readonly serverRegistrationId: string;
+    readonly correlationId: number;
+    readonly subscriber: ClientConnection;
+    readonly codec: ListenerMessageCodec;
+    constructor(serverRegistrationId: string, correlationId: number, subscriber: ClientConnection, codec: ListenerMessageCodec);
+    toString(): string;
+}

package/lib/invocation/ClientEventRegistration.js

@@ -0,0 +1,30 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var ClientEventRegistration = /** @class */ (function () {
+    function ClientEventRegistration(serverRegistrationId, correlationId, subscriber, codec) {
+        this.serverRegistrationId = serverRegistrationId;
+        this.correlationId = correlationId;
+        this.subscriber = subscriber;
+        this.codec = codec;
+    }
+    ClientEventRegistration.prototype.toString = function () {
+        return this.serverRegistrationId;
+    };
+    return ClientEventRegistration;
+}());
+exports.ClientEventRegistration = ClientEventRegistration;

package/lib/invocation/ClusterService.d.ts

@@ -0,0 +1,127 @@
+/// <reference types="bluebird" />
+import { ClientConnection } from './ClientConnection';
+import * as Promise from 'bluebird';
+import { Member } from '../core/Member';
+import { ClientInfo } from '../ClientInfo';
+import HazelcastClient from '../HazelcastClient';
+import { MemberSelector } from '../core/MemberSelector';
+import { MembershipListener } from '../core/MembershipListener';
+export declare enum MemberEvent {
+    ADDED = 1,
+    REMOVED = 2,
+}
+/**
+ * Manages the relationship of this client with the cluster.
+ */
+export declare class ClusterService {
+    /**
+     * The unique identifier of the owner server node. This node is responsible for resource cleanup
+     */
+    ownerUuid: string;
+    /**
+     * The unique identifier of this client instance. Assigned by owner node on authentication
+     */
+    uuid: string;
+    private knownAddresses;
+    private members;
+    private client;
+    private ownerConnection;
+    private membershipListeners;
+    private logger;
+    private failoverInProgress;
+    private lastFailoverAttempt;
+    private readonly failoverCooldown;
+    private downAddresses;
+    private readonly addressBlockDuration;
+    private reconnectionTask;
+    private readonly reconnectionInterval;
+    constructor(client: HazelcastClient);
+    /**
+     * Starts cluster service.
+     * @returns
+     */
+    start(): Promise<void>;
+    /**
+     * Connects to cluster. It uses the addresses provided in the configuration.
+     * @returns
+     */
+    connectToCluster(): Promise<void>;
+    getPossibleMemberAddresses(): Promise<string[]>;
+    /**
+     * Returns the list of members in the cluster.
+     * @returns
+     */
+    getMembers(selector?: MemberSelector): Member[];
+    getMember(uuid: string): Member;
+    /**
+     * Returns the number of nodes in cluster.
+     * @returns {number}
+     */
+    getSize(): number;
+    /**
+     * Returns information about this client.
+     * @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.
+     * @param {MembershipListener} The listener to be registered
+     * @return The registration ID
+     */
+    addMembershipListener(membershipListener: MembershipListener): string;
+    /**
+     * Removes registered MembershipListener.
+     * @param {string} The registration ID
+     * @return {boolean} true if successfully removed, false otherwise
+     */
+    removeMembershipListener(registrationId: string): boolean;
+    initMembershipListener(): Promise<void>;
+    private initHeartbeatListener();
+    private initConnectionListener();
+    private onConnectionClosed(connection);
+    private onHeartbeatStopped(connection);
+    private triggerFailover();
+    private isAddressKnownDown(address);
+    private markAddressAsDown(address);
+    private getDownAddressesInfo();
+    private tryConnectingToAddresses(index, remainingAttemptLimit, attemptPeriod, cause?);
+    private handleMember(member, eventType);
+    private handleMemberList(members);
+    private detectMembershipEvents(prevMembers);
+    private fireMembershipEvent(membershipEvent);
+    private handleMemberAttributeChange(uuid, key, operationType, value);
+    private memberAdded(member);
+    private memberRemoved(member);
+    private startReconnectionTask();
+    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);
+    shutdown(): void;
+}