@celerispay/hazelcast-client 3.12.5

package/lib/invocation/ClusterService.js

@@ -0,0 +1,417 @@
+"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 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.client = client;
+        this.logger = this.client.getLoggingService().getLogger();
+        this.members = [];
+    }
+    /**
+     * 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());
+        if (connection.isAuthenticatedAsOwner()) {
+            this.ownerConnection = null;
+            this.triggerFailover();
+        }
+    };
+    ClusterService.prototype.onHeartbeatStopped = function (connection) {
+        this.logger.warn('ClusterService', connection.toString() + ' stopped heartbeating.');
+        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);
+    };
+    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;
+}

package/lib/invocation/ConnectionAuthenticator.js

@@ -0,0 +1,88 @@
+"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 ClientAuthenticationCodec_1 = require("../codec/ClientAuthenticationCodec");
+var ClientAuthenticationCustomCodec_1 = require("../codec/ClientAuthenticationCustomCodec");
+var HazelcastError_1 = require("../HazelcastError");
+var BuildInfo_1 = require("../BuildInfo");
+var AuthenticationStatus;
+(function (AuthenticationStatus) {
+    AuthenticationStatus[AuthenticationStatus["AUTHENTICATED"] = 0] = "AUTHENTICATED";
+    AuthenticationStatus[AuthenticationStatus["CREDENTIALS_FAILED"] = 1] = "CREDENTIALS_FAILED";
+    AuthenticationStatus[AuthenticationStatus["SERIALIZATION_VERSION_MISMATCH"] = 2] = "SERIALIZATION_VERSION_MISMATCH";
+})(AuthenticationStatus || (AuthenticationStatus = {}));
+var ConnectionAuthenticator = /** @class */ (function () {
+    function ConnectionAuthenticator(connection, client) {
+        this.connection = connection;
+        this.client = client;
+        this.logger = this.client.getLoggingService().getLogger();
+        this.clusterService = this.client.getClusterService();
+    }
+    ConnectionAuthenticator.prototype.authenticate = function (asOwner) {
+        var _this = this;
+        var credentials = this.createCredentials(asOwner);
+        return this.client.getInvocationService()
+            .invokeOnConnection(this.connection, credentials)
+            .then(function (msg) {
+            var authResponse = ClientAuthenticationCodec_1.ClientAuthenticationCodec.decodeResponse(msg);
+            switch (authResponse.status) {
+                case 0 /* AUTHENTICATED */:
+                    _this.connection.setAddress(authResponse.address);
+                    _this.connection.setConnectedServerVersion(authResponse.serverHazelcastVersion);
+                    if (asOwner) {
+                        _this.clusterService.uuid = authResponse.uuid;
+                        _this.clusterService.ownerUuid = authResponse.ownerUuid;
+                    }
+                    _this.logger.info('ConnectionAuthenticator', 'Connection to ' +
+                        _this.connection.getAddress().toString() + ' authenticated');
+                    break;
+                case 1 /* CREDENTIALS_FAILED */:
+                    _this.logger.error('ConnectionAuthenticator', 'Invalid Credentials');
+                    throw new Error('Invalid Credentials, could not authenticate connection to ' +
+                        _this.connection.getAddress().toString());
+                case 2 /* SERIALIZATION_VERSION_MISMATCH */:
+                    _this.logger.error('ConnectionAuthenticator', 'Serialization version mismatch');
+                    throw new Error('Serialization version mismatch, could not authenticate connection to ' +
+                        _this.connection.getAddress().toString());
+                default:
+                    _this.logger.error('ConnectionAuthenticator', 'Unknown authentication status: '
+                        + authResponse.status);
+                    throw new HazelcastError_1.AuthenticationError('Unknown authentication status: ' + authResponse.status +
+                        ' , could not authenticate connection to ' +
+                        _this.connection.getAddress().toString());
+            }
+        });
+    };
+    ConnectionAuthenticator.prototype.createCredentials = function (asOwner) {
+        var groupConfig = this.client.getConfig().groupConfig;
+        var uuid = this.clusterService.uuid;
+        var ownerUuid = this.clusterService.ownerUuid;
+        var customCredentials = this.client.getConfig().customCredentials;
+        var clientMessage;
+        var clientVersion = BuildInfo_1.BuildInfo.getClientVersion();
+        if (customCredentials != null) {
+            var credentialsPayload = this.client.getSerializationService().toData(customCredentials);
+            clientMessage = ClientAuthenticationCustomCodec_1.ClientAuthenticationCustomCodec.encodeRequest(credentialsPayload, uuid, ownerUuid, asOwner, 'NJS', 1, clientVersion);
+        }
+        else {
+            clientMessage = ClientAuthenticationCodec_1.ClientAuthenticationCodec.encodeRequest(groupConfig.name, groupConfig.password, uuid, ownerUuid, asOwner, 'NJS', 1, clientVersion);
+        }
+        return clientMessage;
+    };
+    return ConnectionAuthenticator;
+}());
+exports.ConnectionAuthenticator = ConnectionAuthenticator;

package/lib/invocation/InvocationService.d.ts

@@ -0,0 +1,138 @@
+/// <reference types="bluebird" />
+import { Buffer } from 'safe-buffer';
+import * as Promise from 'bluebird';
+import HazelcastClient from '../HazelcastClient';
+import { ClientConnection } from './ClientConnection';
+import Address = require('../Address');
+import ClientMessage = require('../ClientMessage');
+/**
+ * A request to be sent to a hazelcast node.
+ */
+export declare class Invocation {
+    client: HazelcastClient;
+    invocationService: InvocationService;
+    /**
+     * Representatiton of the request in binary form.
+     */
+    request: ClientMessage;
+    /**
+     * Partition id of the request. If request is not bound to a specific partition, should be set to -1.
+     */
+    partitionId: number;
+    /**
+     * Address of the request. If request is not bound to any specific address, should be set to null.
+     */
+    address: Address;
+    /**
+     * Deadline of validity. Client will not try to send this request to server after the deadline passes.
+     */
+    deadline: number;
+    /**
+     * Connection of the request. If request is not bound to any specific address, should be set to null.
+     */
+    connection: ClientConnection;
+    /**
+     * Connection on which the request was written. May be different from `connection`.
+     */
+    sendConnection: ClientConnection;
+    /**
+     * Promise managing object.
+     */
+    deferred: Promise.Resolver<ClientMessage>;
+    invokeCount: number;
+    /**
+     * If this is an event listener registration, handler should be set to the function to be called on events.
+     * Otherwise, should be set to null.
+     */
+    handler: (...args: any[]) => any;
+    constructor(client: HazelcastClient, request: ClientMessage, timeoutMillis?: number);
+    private static isRetrySafeError(err);
+    shouldRetry(err: Error): boolean;
+    /**
+     * @returns {boolean}
+     */
+    hasPartitionId(): boolean;
+    isAllowedToRetryOnSelection(err: Error): boolean;
+}
+/**
+ * Sends requests to appropriate nodes. Resolves waiting promises with responses.
+ */
+export declare class InvocationService {
+    doInvoke: (invocation: Invocation) => void;
+    private correlationCounter;
+    private readonly eventHandlers;
+    private readonly pending;
+    private client;
+    private readonly invocationRetryPauseMillis;
+    private readonly invocationTimeoutMillis;
+    private readonly cleanResourcesMillis;
+    private readonly redoOperation;
+    private logger;
+    private cleanResourcesTask;
+    private isShutdown;
+    private readonly maxRetryAttempts;
+    private readonly partitionFailureBackoff;
+    constructor(hazelcastClient: HazelcastClient);
+    start(): void;
+    shutdown(): void;
+    redoOperationEnabled(): boolean;
+    invoke(invocation: Invocation): Promise<ClientMessage>;
+    /**
+     * Invokes given invocation on specified connection.
+     * @param connection
+     * @param request
+     * @param handler called with values returned from server for this invocation.
+     * @returns
+     */
+    invokeOnConnection(connection: ClientConnection, request: ClientMessage, handler?: (...args: any[]) => any): Promise<ClientMessage>;
+    /**
+     * Invokes given invocation on the node that owns given partition.
+     * @param request
+     * @param partitionId
+     * @param timeoutMillis optional override for the invocation timeout
+     * @returns
+     */
+    invokeOnPartition(request: ClientMessage, partitionId: number, timeoutMillis?: number): Promise<ClientMessage>;
+    /**
+     * Invokes given invocation on the host with given address.
+     * @param request
+     * @param target
+     * @returns
+     */
+    invokeOnTarget(request: ClientMessage, target: Address): Promise<ClientMessage>;
+    /**
+     * Invokes given invocation on any host.
+     * Useful when an operation is not bound to any host but a generic operation.
+     * @param request
+     * @returns
+     */
+    invokeOnRandomTarget(request: ClientMessage): Promise<ClientMessage>;
+    getInvocationTimeoutMillis(): number;
+    getInvocationRetryPauseMillis(): number;
+    /**
+     * Removes the handler for all event handlers with a specific correlation id.
+     * @param id correlation id
+     */
+    removeEventHandler(id: number): void;
+    /**
+     * Extract codec specific properties in a protocol message and resolves waiting promise.
+     * @param buffer
+     */
+    processResponse(buffer: Buffer): void;
+    private scheduleCleanResourcesTask(periodMillis);
+    private invokeSmart(invocation);
+    private invokeNonSmart(invocation);
+    private invokeOnOwner(invocation);
+    private invokeOnAddress(invocation, address);
+    private invokeOnPartitionOwner(invocation, partitionId);
+    private send(invocation, connection);
+    private notifyError(invocation, error);
+    /**
+     * Determines if an error is retryable. The given invocation is rejected with approprate error if the error is not retryable.
+     * @param invocation
+     * @param error
+     * @returns `true` if invocation is rejected, `false` otherwise
+     */
+    private rejectIfNotRetryable(invocation, error);
+    private registerInvocation(invocation);
+}