@celerispay/hazelcast-client 3.12.5-1

package/lib/invocation/ClusterService.js

@@ -0,0 +1,581 @@
+"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 Promise = require("bluebird");
+var ClientAddMembershipListenerCodec_1 = require("../codec/ClientAddMembershipListenerCodec");
+var ClientInfo_1 = require("../ClientInfo");
+var HazelcastError_1 = require("../HazelcastError");
+var assert = require("assert");
+var Util_1 = require("../Util");
+var MemberAttributeEvent_1 = require("../core/MemberAttributeEvent");
+var MembershipEvent_1 = require("../core/MembershipEvent");
+var UuidUtil_1 = require("../util/UuidUtil");
+var Address = require("../Address");
+var MemberEvent;
+(function (MemberEvent) {
+    MemberEvent[MemberEvent["ADDED"] = 1] = "ADDED";
+    MemberEvent[MemberEvent["REMOVED"] = 2] = "REMOVED";
+})(MemberEvent = exports.MemberEvent || (exports.MemberEvent = {}));
+/**
+ * Manages the relationship of this client with the cluster.
+ */
+var ClusterService = /** @class */ (function () {
+    function ClusterService(client) {
+        /**
+         * The unique identifier of the owner server node. This node is responsible for resource cleanup
+         */
+        this.ownerUuid = null;
+        /**
+         * The unique identifier of this client instance. Assigned by owner node on authentication
+         */
+        this.uuid = null;
+        this.knownAddresses = [];
+        this.members = [];
+        this.membershipListeners = new Map();
+        this.failoverInProgress = false;
+        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.reconnectionTask = null;
+        this.reconnectionInterval = 10000; // 10 seconds between reconnection attempts
+        this.client = client;
+        this.logger = this.client.getLoggingService().getLogger();
+        this.members = [];
+        this.startReconnectionTask();
+    }
+    /**
+     * Starts cluster service.
+     * @returns
+     */
+    ClusterService.prototype.start = function () {
+        this.initHeartbeatListener();
+        this.initConnectionListener();
+        return this.connectToCluster();
+    };
+    /**
+     * Connects to cluster. It uses the addresses provided in the configuration.
+     * @returns
+     */
+    ClusterService.prototype.connectToCluster = function () {
+        var _this = this;
+        return this.getPossibleMemberAddresses().then(function (res) {
+            _this.knownAddresses = [];
+            res.forEach(function (value) {
+                _this.knownAddresses = _this.knownAddresses.concat(Util_1.AddressHelper.getSocketAddresses(value));
+            });
+            var attemptLimit = _this.client.getConfig().networkConfig.connectionAttemptLimit;
+            var attemptPeriod = _this.client.getConfig().networkConfig.connectionAttemptPeriod;
+            return _this.tryConnectingToAddresses(0, attemptLimit, attemptPeriod);
+        });
+    };
+    ClusterService.prototype.getPossibleMemberAddresses = function () {
+        var _this = this;
+        var addresses = new Set();
+        this.getMembers().forEach(function (member) {
+            addresses.add(member.address.toString());
+        });
+        var providerAddresses = new Set();
+        var promises = [];
+        this.client.getConnectionManager().addressProviders.forEach(function (addressProvider) {
+            promises.push(addressProvider.loadAddresses().then(function (res) {
+                providerAddresses = new Set(Array.from(providerAddresses).concat(res));
+            }).catch(function (err) {
+                _this.logger.warn('Error from AddressProvider: ' + addressProvider, err);
+            }));
+        });
+        return Promise.all(promises).then(function () {
+            return Array.from(new Set(Array.from(addresses).concat(Array.from(providerAddresses))));
+        });
+    };
+    /**
+     * Returns the list of members in the cluster.
+     * @returns
+     */
+    ClusterService.prototype.getMembers = function (selector) {
+        if (selector === undefined) {
+            return this.members;
+        }
+        else {
+            var members_1 = [];
+            this.members.forEach(function (member) {
+                if (selector.select(member)) {
+                    members_1.push(member);
+                }
+            });
+            return members_1;
+        }
+    };
+    ClusterService.prototype.getMember = function (uuid) {
+        for (var _i = 0, _a = this.members; _i < _a.length; _i++) {
+            var member = _a[_i];
+            if (member.uuid === uuid) {
+                return member;
+            }
+        }
+        return null;
+    };
+    /**
+     * Returns the number of nodes in cluster.
+     * @returns {number}
+     */
+    ClusterService.prototype.getSize = function () {
+        return this.members.length;
+    };
+    /**
+     * Returns information about this client.
+     * @returns {ClientInfo}
+     */
+    ClusterService.prototype.getClientInfo = function () {
+        var info = new ClientInfo_1.ClientInfo();
+        info.uuid = this.uuid;
+        info.localAddress = this.getOwnerConnection().getLocalAddress();
+        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.
+     * @param {MembershipListener} The listener to be registered
+     * @return The registration ID
+     */
+    ClusterService.prototype.addMembershipListener = function (membershipListener) {
+        var registrationId = UuidUtil_1.UuidUtil.generate().toString();
+        this.membershipListeners.set(registrationId, membershipListener);
+        return registrationId;
+    };
+    /**
+     * Removes registered MembershipListener.
+     * @param {string} The registration ID
+     * @return {boolean} true if successfully removed, false otherwise
+     */
+    ClusterService.prototype.removeMembershipListener = function (registrationId) {
+        if (registrationId === null) {
+            throw new RangeError('registrationId cannot be null');
+        }
+        return this.membershipListeners.delete(registrationId);
+    };
+    ClusterService.prototype.initMembershipListener = function () {
+        var _this = this;
+        var request = ClientAddMembershipListenerCodec_1.ClientAddMembershipListenerCodec.encodeRequest(false);
+        var handler = function (m) {
+            var handleMember = _this.handleMember.bind(_this);
+            var handleMemberList = _this.handleMemberList.bind(_this);
+            var handleAttributeChange = _this.handleMemberAttributeChange.bind(_this);
+            ClientAddMembershipListenerCodec_1.ClientAddMembershipListenerCodec.handle(m, handleMember, handleMemberList, handleAttributeChange, null);
+        };
+        return this.client.getInvocationService().invokeOnConnection(this.getOwnerConnection(), request, handler)
+            .then(function (resp) {
+            _this.logger.trace('ClusterService', 'Registered listener with id '
+                + ClientAddMembershipListenerCodec_1.ClientAddMembershipListenerCodec.decodeResponse(resp).response);
+        });
+    };
+    ClusterService.prototype.initHeartbeatListener = function () {
+        this.client.getHeartbeat().addListener({
+            onHeartbeatStopped: this.onHeartbeatStopped.bind(this),
+        });
+    };
+    ClusterService.prototype.initConnectionListener = function () {
+        this.client.getConnectionManager().on('connectionClosed', this.onConnectionClosed.bind(this));
+    };
+    ClusterService.prototype.onConnectionClosed = function (connection) {
+        this.logger.warn('ClusterService', 'Connection closed to ' + connection.toString());
+        // Mark the address as down when connection is closed
+        this.markAddressAsDown(connection.getAddress());
+        if (connection.isAuthenticatedAsOwner()) {
+            this.ownerConnection = null;
+            this.triggerFailover();
+        }
+    };
+    ClusterService.prototype.onHeartbeatStopped = function (connection) {
+        this.logger.warn('ClusterService', connection.toString() + ' stopped heartbeating.');
+        // Mark the address as down when heartbeat stops
+        this.markAddressAsDown(connection.getAddress());
+        if (connection.isAuthenticatedAsOwner()) {
+            this.client.getConnectionManager().destroyConnection(connection.getAddress());
+            this.ownerConnection = null;
+            this.triggerFailover();
+        }
+    };
+    ClusterService.prototype.triggerFailover = function () {
+        var _this = this;
+        var now = Date.now();
+        if (this.failoverInProgress || (now - this.lastFailoverAttempt) < this.failoverCooldown) {
+            this.logger.debug('ClusterService', 'Failover already in progress or too soon since last attempt');
+            return;
+        }
+        this.failoverInProgress = true;
+        this.lastFailoverAttempt = now;
+        this.logger.info('ClusterService', 'Starting failover process...');
+        // Clear any stale partition information
+        this.client.getPartitionService().clearPartitionTable();
+        // Attempt to reconnect to cluster
+        this.connectToCluster()
+            .then(function () {
+            _this.logger.info('ClusterService', 'Failover completed successfully');
+        })
+            .catch(function (error) {
+            _this.logger.error('ClusterService', 'Failover failed', error);
+            // If failover fails, shutdown the client to prevent further issues
+            _this.client.shutdown();
+        })
+            .finally(function () {
+            _this.failoverInProgress = false;
+        });
+    };
+    ClusterService.prototype.isAddressKnownDown = function (address) {
+        var addressStr = address.toString();
+        var downTime = this.downAddresses.get(addressStr);
+        if (!downTime) {
+            return false;
+        }
+        var now = Date.now();
+        var timeSinceDown = now - downTime;
+        // If address has been down for longer than block duration, unblock it
+        if (timeSinceDown > this.addressBlockDuration) {
+            this.logger.debug('ClusterService', "Unblocking address " + addressStr + " after " + this.addressBlockDuration + "ms");
+            this.downAddresses.delete(addressStr);
+            return false;
+        }
+        // Address is still blocked
+        var remainingBlockTime = this.addressBlockDuration - timeSinceDown;
+        this.logger.debug('ClusterService', "Address " + addressStr + " is blocked for " + remainingBlockTime + "ms more");
+        return true;
+    };
+    ClusterService.prototype.markAddressAsDown = function (address) {
+        var _this = this;
+        var addressStr = address.toString();
+        var now = Date.now();
+        this.downAddresses.set(addressStr, now);
+        this.logger.warn('ClusterService', "Marked address " + addressStr + " as down, will be blocked for " + this.addressBlockDuration + "ms");
+        // Schedule cleanup of this address after block duration
+        setTimeout(function () {
+            if (_this.downAddresses.has(addressStr)) {
+                _this.logger.info('ClusterService', "Unblocking address " + addressStr + " after block duration");
+                _this.downAddresses.delete(addressStr);
+            }
+        }, this.addressBlockDuration);
+    };
+    ClusterService.prototype.getDownAddressesInfo = function () {
+        var _this = this;
+        var now = Date.now();
+        var downInfo = [];
+        this.downAddresses.forEach(function (downTime, address) {
+            var timeSinceDown = now - downTime;
+            var remainingTime = Math.max(0, _this.addressBlockDuration - timeSinceDown);
+            downInfo.push(address + " (" + Math.ceil(remainingTime / 1000) + "s remaining)");
+        });
+        return downInfo.length > 0 ? downInfo.join(', ') : 'none';
+    };
+    ClusterService.prototype.tryConnectingToAddresses = function (index, remainingAttemptLimit, attemptPeriod, cause) {
+        var _this = this;
+        this.logger.debug('ClusterService', 'Trying to connect to addresses, remaining attempt limit: ' + remainingAttemptLimit
+            + ', attempt period: ' + attemptPeriod + ', down addresses: ' + this.getDownAddressesInfo());
+        if (this.knownAddresses.length <= index) {
+            remainingAttemptLimit = remainingAttemptLimit - 1;
+            if (remainingAttemptLimit === 0) {
+                var errorMessage = 'Unable to connect to any of the following addresses: ' +
+                    this.knownAddresses.map(function (element) {
+                        return element.toString();
+                    }).join(', ');
+                this.logger.debug('ClusterService', errorMessage);
+                var error = new HazelcastError_1.IllegalStateError(errorMessage, cause);
+                return Promise.reject(error);
+            }
+            else {
+                var deferred_1 = Util_1.DeferredPromise();
+                setTimeout(function () {
+                    _this.tryConnectingToAddresses(0, remainingAttemptLimit, attemptPeriod).then(function () {
+                        deferred_1.resolve();
+                    }).catch(function (e) {
+                        deferred_1.reject(e);
+                    });
+                }, attemptPeriod);
+                return deferred_1.promise;
+            }
+        }
+        else {
+            var currentAddress_1 = this.knownAddresses[index];
+            // Skip addresses that are known to be down
+            if (this.isAddressKnownDown(currentAddress_1)) {
+                this.logger.debug('ClusterService', "Skipping known down address: " + currentAddress_1.toString());
+                return this.tryConnectingToAddresses(index + 1, remainingAttemptLimit, attemptPeriod, cause);
+            }
+            return this.client.getConnectionManager().getOrConnect(currentAddress_1, true).then(function (connection) {
+                connection.setAuthenticatedAsOwner(true);
+                _this.ownerConnection = connection;
+                _this.logger.info('ClusterService', "Successfully connected to owner node: " + currentAddress_1.toString());
+                return _this.initMembershipListener();
+            }).catch(function (e) {
+                _this.logger.warn('ClusterService', "Failed to connect to " + currentAddress_1.toString() + ":", e);
+                _this.markAddressAsDown(currentAddress_1);
+                return _this.tryConnectingToAddresses(index + 1, remainingAttemptLimit, attemptPeriod, e);
+            });
+        }
+    };
+    ClusterService.prototype.handleMember = function (member, eventType) {
+        if (eventType === MemberEvent.ADDED) {
+            this.logger.info('ClusterService', member.toString() + ' added to cluster');
+            this.memberAdded(member);
+        }
+        else if (eventType === MemberEvent.REMOVED) {
+            this.logger.info('ClusterService', member.toString() + ' removed from cluster');
+            this.memberRemoved(member);
+        }
+        this.client.getPartitionService().refresh();
+    };
+    ClusterService.prototype.handleMemberList = function (members) {
+        var prevMembers = this.members;
+        this.members = members;
+        this.client.getPartitionService().refresh();
+        this.logger.info('ClusterService', 'Members received.', this.members);
+        var events = this.detectMembershipEvents(prevMembers);
+        for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
+            var event = events_1[_i];
+            this.fireMembershipEvent(event);
+        }
+    };
+    ClusterService.prototype.detectMembershipEvents = function (prevMembers) {
+        var events = [];
+        var eventMembers = Array.from(this.members);
+        var addedMembers = [];
+        var deletedMembers = Array.from(prevMembers);
+        for (var _i = 0, _a = this.members; _i < _a.length; _i++) {
+            var member = _a[_i];
+            var idx = deletedMembers.findIndex(member.equals, member);
+            if (idx === -1) {
+                addedMembers.push(member);
+            }
+            else {
+                deletedMembers.splice(idx, 1);
+            }
+        }
+        // removal events should be added before added events
+        for (var _b = 0, deletedMembers_1 = deletedMembers; _b < deletedMembers_1.length; _b++) {
+            var member = deletedMembers_1[_b];
+            events.push(new MembershipEvent_1.MembershipEvent(member, MemberEvent.REMOVED, eventMembers));
+        }
+        for (var _c = 0, addedMembers_1 = addedMembers; _c < addedMembers_1.length; _c++) {
+            var member = addedMembers_1[_c];
+            events.push(new MembershipEvent_1.MembershipEvent(member, MemberEvent.ADDED, eventMembers));
+        }
+        return events;
+    };
+    ClusterService.prototype.fireMembershipEvent = function (membershipEvent) {
+        this.membershipListeners.forEach(function (membershipListener, registrationId) {
+            if (membershipEvent.eventType === MemberEvent.ADDED) {
+                if (membershipListener && membershipListener.memberAdded) {
+                    membershipListener.memberAdded(membershipEvent);
+                }
+            }
+            else if (membershipEvent.eventType === MemberEvent.REMOVED) {
+                if (membershipListener && membershipListener.memberRemoved) {
+                    membershipListener.memberRemoved(membershipEvent);
+                }
+            }
+        });
+    };
+    ClusterService.prototype.handleMemberAttributeChange = function (uuid, key, operationType, value) {
+        var _this = this;
+        this.membershipListeners.forEach(function (membershipListener, registrationId) {
+            if (membershipListener && membershipListener.memberAttributeChanged) {
+                var member = _this.getMember(uuid);
+                var memberAttributeEvent = new MemberAttributeEvent_1.MemberAttributeEvent(member, key, operationType, value);
+                membershipListener.memberAttributeChanged(memberAttributeEvent);
+            }
+        });
+    };
+    ClusterService.prototype.memberAdded = function (member) {
+        this.members.push(member);
+        var membershipEvent = new MembershipEvent_1.MembershipEvent(member, MemberEvent.ADDED, this.members);
+        this.fireMembershipEvent(membershipEvent);
+    };
+    ClusterService.prototype.memberRemoved = function (member) {
+        var memberIndex = this.members.findIndex(member.equals, member);
+        if (memberIndex !== -1) {
+            var removedMemberList = this.members.splice(memberIndex, 1);
+            assert(removedMemberList.length === 1);
+        }
+        this.client.getConnectionManager().destroyConnection(member.address);
+        var membershipEvent = new MembershipEvent_1.MembershipEvent(member, MemberEvent.REMOVED, this.members);
+        this.fireMembershipEvent(membershipEvent);
+    };
+    ClusterService.prototype.startReconnectionTask = function () {
+        var _this = this;
+        // Periodically attempt to reconnect to previously failed addresses
+        this.reconnectionTask = setInterval(function () {
+            _this.attemptReconnectionToFailedNodes();
+        }, this.reconnectionInterval);
+    };
+    ClusterService.prototype.attemptReconnectionToFailedNodes = function () {
+        var _this = this;
+        if (this.failoverInProgress || !this.ownerConnection) {
+            return;
+        }
+        var now = Date.now();
+        var addressesToReconnect = [];
+        var totalDownAddresses = this.downAddresses.size;
+        // If we have no down addresses, we can increase the reconnection interval
+        if (totalDownAddresses === 0) {
+            return;
+        }
+        // Find addresses that are no longer blocked
+        this.downAddresses.forEach(function (downTime, addressStr) {
+            var timeSinceDown = now - downTime;
+            if (timeSinceDown > _this.addressBlockDuration) {
+                // Parse the address string back to Address object
+                try {
+                    var _a = addressStr.split(':'), host = _a[0], portStr = _a[1];
+                    var port = parseInt(portStr, 10);
+                    if (host && !isNaN(port)) {
+                        var address = new Address(host, port);
+                        addressesToReconnect.push(address);
+                    }
+                }
+                catch (error) {
+                    _this.logger.warn('ClusterService', "Failed to parse address " + addressStr + " for reconnection:", error);
+                }
+            }
+        });
+        if (addressesToReconnect.length > 0) {
+            this.logger.info('ClusterService', "Attempting to reconnect to " + addressesToReconnect.length + " previously failed nodes: " + addressesToReconnect.map(function (addr) { return addr.toString(); }).join(', '));
+            // Attempt to establish connections to each unblocked address
+            addressesToReconnect.forEach(function (address) {
+                _this.attemptReconnectionToAddress(address);
+            });
+        }
+        else if (totalDownAddresses > 0) {
+            // Log remaining blocked addresses for debugging
+            var remainingBlocked = Array.from(this.downAddresses.keys()).map(function (addr) {
+                var downTime = _this.downAddresses.get(addr);
+                var timeSinceDown = now - downTime;
+                var remainingTime = Math.max(0, _this.addressBlockDuration - timeSinceDown);
+                return addr + " (" + Math.ceil(remainingTime / 1000) + "s remaining)";
+            });
+            this.logger.debug('ClusterService', "Still waiting for " + totalDownAddresses + " addresses to unblock: " + remainingBlocked.join(', '));
+        }
+    };
+    /**
+     * Attempts to establish a connection to a specific address
+     * @param address The address to reconnect to
+     */
+    ClusterService.prototype.attemptReconnectionToAddress = function (address) {
+        var _this = this;
+        var addressStr = address.toString();
+        // Remove from down addresses to allow connection attempt
+        this.downAddresses.delete(addressStr);
+        this.logger.debug('ClusterService', "Attempting reconnection to " + addressStr);
+        // Attempt to establish connection (not as owner, just as regular member connection)
+        this.client.getConnectionManager().getOrConnect(address, false)
+            .then(function (connection) {
+            _this.logger.info('ClusterService', "Successfully reconnected to " + addressStr);
+            // Check if this reconnected node should become the new owner
+            _this.evaluateOwnershipChange(address, connection);
+            // Trigger partition service refresh to update routing information
+            _this.client.getPartitionService().refresh();
+        }).catch(function (error) {
+            _this.logger.warn('ClusterService', "Reconnection attempt to " + addressStr + " failed:", error);
+            // Mark the address as down again, but with a shorter block duration for reconnection attempts
+            var shorterBlockDuration = Math.min(_this.addressBlockDuration / 2, 15000); // Max 15 seconds
+            _this.markAddressAsDownWithDuration(address, shorterBlockDuration);
+        });
+    };
+    /**
+     * 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
+     */
+    ClusterService.prototype.evaluateOwnershipChange = function (address, connection) {
+        // If we don't have an owner connection, this reconnected node becomes the owner
+        if (!this.ownerConnection) {
+            this.logger.info('ClusterService', "Promoting reconnected node " + address.toString() + " to owner status");
+            this.promoteToOwner(connection, address);
+            return;
+        }
+        // If our current owner connection is having issues, consider switching
+        if (this.ownerConnection && !this.ownerConnection.isAlive()) {
+            this.logger.info('ClusterService', "Current owner is unhealthy, switching to reconnected node " + address.toString());
+            this.promoteToOwner(connection, address);
+            return;
+        }
+        // Check if this reconnected node was previously our owner (by checking if it's in our known addresses)
+        var wasPreviousOwner = this.knownAddresses.some(function (knownAddr) { return knownAddr.equals(address); });
+        if (wasPreviousOwner) {
+            this.logger.debug('ClusterService', "Reconnected node " + address.toString() + " was previously known, monitoring for ownership opportunity");
+            // Don't switch ownership immediately, but keep the connection for potential future use
+        }
+    };
+    /**
+     * Promotes a connection to owner status
+     * @param connection The connection to promote
+     * @param address The address of the promoted connection
+     */
+    ClusterService.prototype.promoteToOwner = function (connection, address) {
+        try {
+            // Close the old owner connection if it exists
+            if (this.ownerConnection && this.ownerConnection !== connection) {
+                this.logger.info('ClusterService', "Closing previous owner connection to " + this.ownerConnection.getAddress().toString());
+                this.client.getConnectionManager().destroyConnection(this.ownerConnection.getAddress());
+            }
+            // Set the new owner connection
+            connection.setAuthenticatedAsOwner(true);
+            this.ownerConnection = connection;
+            this.logger.info('ClusterService', "Successfully promoted " + address.toString() + " to owner status");
+            // Refresh partition information with the new owner
+            this.client.getPartitionService().refresh();
+        }
+        catch (error) {
+            this.logger.error('ClusterService', "Failed to promote " + address.toString() + " to owner:", error);
+            // If promotion fails, mark the address as down again
+            this.markAddressAsDown(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)
+     */
+    ClusterService.prototype.markAddressAsDownWithDuration = function (address, blockDuration) {
+        var _this = this;
+        var addressStr = address.toString();
+        var now = Date.now();
+        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
+        setTimeout(function () {
+            if (_this.downAddresses.has(addressStr)) {
+                _this.logger.info('ClusterService', "Unblocking address " + addressStr + " after block duration");
+                _this.downAddresses.delete(addressStr);
+            }
+        }, blockDuration);
+    };
+    ClusterService.prototype.shutdown = function () {
+        if (this.reconnectionTask) {
+            clearInterval(this.reconnectionTask);
+            this.reconnectionTask = null;
+        }
+        this.downAddresses.clear();
+    };
+    return ClusterService;
+}());
+exports.ClusterService = ClusterService;

package/lib/invocation/ConnectionAuthenticator.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import HazelcastClient from '../HazelcastClient';
+import { ClientConnection } from './ClientConnection';
+import ClientMessage = require('../ClientMessage');
+export declare class ConnectionAuthenticator {
+    private connection;
+    private client;
+    private clusterService;
+    private logger;
+    constructor(connection: ClientConnection, client: HazelcastClient);
+    authenticate(asOwner: boolean): Promise<void>;
+    createCredentials(asOwner: boolean): ClientMessage;
+}