@celerispay/hazelcast-client 3.12.5-1

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);
+}

package/lib/invocation/InvocationService.js

@@ -0,0 +1,387 @@
+"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 assert = require("assert");
+var Promise = require("bluebird");
+var BitsUtil_1 = require("../BitsUtil");
+var HazelcastError_1 = require("../HazelcastError");
+var Util_1 = require("../Util");
+var ClientMessage = require("../ClientMessage");
+var EXCEPTION_MESSAGE_TYPE = 109;
+var MAX_FAST_INVOCATION_COUNT = 5;
+var PROPERTY_INVOCATION_RETRY_PAUSE_MILLIS = 'hazelcast.client.invocation.retry.pause.millis';
+var PROPERTY_INVOCATION_TIMEOUT_MILLIS = 'hazelcast.client.invocation.timeout.millis';
+var PROPERTY_CLEAN_RESOURCES_MILLIS = 'hazelcast.client.internal.clean.resources.millis';
+/**
+ * A request to be sent to a hazelcast node.
+ */
+var Invocation = /** @class */ (function () {
+    function Invocation(client, request, timeoutMillis) {
+        this.invokeCount = 0;
+        this.client = client;
+        this.invocationService = client.getInvocationService();
+        this.deadline = timeoutMillis === undefined
+            ? Date.now() + this.invocationService.getInvocationTimeoutMillis()
+            : Date.now() + timeoutMillis;
+        this.request = request;
+    }
+    Invocation.isRetrySafeError = function (err) {
+        return err instanceof HazelcastError_1.IOError
+            || err instanceof HazelcastError_1.HazelcastInstanceNotActiveError
+            || err instanceof HazelcastError_1.RetryableHazelcastError;
+    };
+    Invocation.prototype.shouldRetry = function (err) {
+        if (Invocation.isRetrySafeError(err)) {
+            return true;
+        }
+        if (err instanceof HazelcastError_1.TargetDisconnectedError) {
+            return this.request.isRetryable() || this.invocationService.redoOperationEnabled();
+        }
+        return false;
+    };
+    /**
+     * @returns {boolean}
+     */
+    Invocation.prototype.hasPartitionId = function () {
+        return this.hasOwnProperty('partitionId') && this.partitionId >= 0;
+    };
+    Invocation.prototype.isAllowedToRetryOnSelection = function (err) {
+        return (this.connection == null && this.address == null) || !(err instanceof HazelcastError_1.IOError);
+    };
+    return Invocation;
+}());
+exports.Invocation = Invocation;
+/**
+ * Sends requests to appropriate nodes. Resolves waiting promises with responses.
+ */
+var InvocationService = /** @class */ (function () {
+    function InvocationService(hazelcastClient) {
+        this.correlationCounter = 1;
+        this.eventHandlers = new Map();
+        this.pending = new Map();
+        this.maxRetryAttempts = 10;
+        this.partitionFailureBackoff = 2000; // 2 seconds backoff for partition failures
+        this.client = hazelcastClient;
+        this.logger = this.client.getLoggingService().getLogger();
+        var config = hazelcastClient.getConfig();
+        if (config.networkConfig.smartRouting) {
+            this.doInvoke = this.invokeSmart;
+        }
+        else {
+            this.doInvoke = this.invokeNonSmart;
+        }
+        this.invocationRetryPauseMillis = config.properties[PROPERTY_INVOCATION_RETRY_PAUSE_MILLIS];
+        this.invocationTimeoutMillis = config.properties[PROPERTY_INVOCATION_TIMEOUT_MILLIS];
+        this.cleanResourcesMillis = config.properties[PROPERTY_CLEAN_RESOURCES_MILLIS];
+        this.redoOperation = config.networkConfig.redoOperation;
+        this.isShutdown = false;
+    }
+    InvocationService.prototype.start = function () {
+        this.cleanResourcesTask = this.scheduleCleanResourcesTask(this.cleanResourcesMillis);
+    };
+    InvocationService.prototype.shutdown = function () {
+        var _this = this;
+        if (this.isShutdown) {
+            return;
+        }
+        this.isShutdown = true;
+        if (this.cleanResourcesTask !== undefined) {
+            Util_1.cancelRepetitionTask(this.cleanResourcesTask);
+        }
+        this.pending.forEach(function (invocation) {
+            _this.notifyError(invocation, new HazelcastError_1.ClientNotActiveError('Client is shutting down.'));
+        });
+    };
+    InvocationService.prototype.redoOperationEnabled = function () {
+        return this.redoOperation;
+    };
+    InvocationService.prototype.invoke = function (invocation) {
+        invocation.deferred = Util_1.DeferredPromise();
+        var newCorrelationId = this.correlationCounter++;
+        invocation.request.setCorrelationId(newCorrelationId);
+        this.doInvoke(invocation);
+        return invocation.deferred.promise;
+    };
+    /**
+     * Invokes given invocation on specified connection.
+     * @param connection
+     * @param request
+     * @param handler called with values returned from server for this invocation.
+     * @returns
+     */
+    InvocationService.prototype.invokeOnConnection = function (connection, request, handler) {
+        var invocation = new Invocation(this.client, request);
+        invocation.connection = connection;
+        if (handler) {
+            invocation.handler = handler;
+        }
+        return this.invoke(invocation);
+    };
+    /**
+     * Invokes given invocation on the node that owns given partition.
+     * @param request
+     * @param partitionId
+     * @param timeoutMillis optional override for the invocation timeout
+     * @returns
+     */
+    InvocationService.prototype.invokeOnPartition = function (request, partitionId, timeoutMillis) {
+        var invocation = new Invocation(this.client, request, timeoutMillis);
+        invocation.partitionId = partitionId;
+        return this.invoke(invocation);
+    };
+    /**
+     * Invokes given invocation on the host with given address.
+     * @param request
+     * @param target
+     * @returns
+     */
+    InvocationService.prototype.invokeOnTarget = function (request, target) {
+        var invocation = new Invocation(this.client, request);
+        invocation.address = target;
+        return this.invoke(invocation);
+    };
+    /**
+     * Invokes given invocation on any host.
+     * Useful when an operation is not bound to any host but a generic operation.
+     * @param request
+     * @returns
+     */
+    InvocationService.prototype.invokeOnRandomTarget = function (request) {
+        return this.invoke(new Invocation(this.client, request));
+    };
+    InvocationService.prototype.getInvocationTimeoutMillis = function () {
+        return this.invocationTimeoutMillis;
+    };
+    InvocationService.prototype.getInvocationRetryPauseMillis = function () {
+        return this.invocationRetryPauseMillis;
+    };
+    /**
+     * Removes the handler for all event handlers with a specific correlation id.
+     * @param id correlation id
+     */
+    InvocationService.prototype.removeEventHandler = function (id) {
+        if (this.eventHandlers.hasOwnProperty('' + id)) {
+            this.eventHandlers.delete(id);
+        }
+    };
+    /**
+     * Extract codec specific properties in a protocol message and resolves waiting promise.
+     * @param buffer
+     */
+    InvocationService.prototype.processResponse = function (buffer) {
+        var _this = this;
+        var clientMessage = new ClientMessage(buffer);
+        var correlationId = clientMessage.getCorrelationId();
+        var messageType = clientMessage.getMessageType();
+        if (clientMessage.hasFlags(BitsUtil_1.BitsUtil.LISTENER_FLAG)) {
+            setImmediate(function () {
+                var invocation = _this.eventHandlers.get(correlationId);
+                if (invocation !== undefined) {
+                    invocation.handler(clientMessage);
+                }
+            });
+            return;
+        }
+        var pendingInvocation = this.pending.get(correlationId);
+        if (pendingInvocation === undefined) {
+            if (!this.isShutdown) {
+                this.logger.warn('InvocationService', 'Found no registration for invocation id ' + correlationId);
+            }
+            return;
+        }
+        var deferred = pendingInvocation.deferred;
+        if (messageType === EXCEPTION_MESSAGE_TYPE) {
+            var remoteError = this.client.getErrorFactory().createErrorFromClientMessage(clientMessage);
+            this.notifyError(pendingInvocation, remoteError);
+        }
+        else {
+            this.pending.delete(correlationId);
+            deferred.resolve(clientMessage);
+        }
+    };
+    InvocationService.prototype.scheduleCleanResourcesTask = function (periodMillis) {
+        var _this = this;
+        return Util_1.scheduleWithRepetition(function () {
+            _this.pending.forEach(function (invocation) {
+                var connection = invocation.sendConnection;
+                if (connection === undefined) {
+                    return;
+                }
+                if (!connection.isAlive()) {
+                    _this.notifyError(invocation, new HazelcastError_1.TargetDisconnectedError('Target member disconnected.'));
+                }
+            });
+        }, periodMillis, periodMillis);
+    };
+    InvocationService.prototype.invokeSmart = function (invocation) {
+        var _this = this;
+        var invocationPromise;
+        invocation.invokeCount++;
+        if (invocation.hasOwnProperty('connection')) {
+            invocationPromise = this.send(invocation, invocation.connection);
+        }
+        else if (invocation.hasPartitionId()) {
+            invocationPromise = this.invokeOnPartitionOwner(invocation, invocation.partitionId);
+        }
+        else if (invocation.hasOwnProperty('address')) {
+            invocationPromise = this.invokeOnAddress(invocation, invocation.address);
+        }
+        else {
+            invocationPromise = this.invokeOnOwner(invocation);
+        }
+        invocationPromise.catch(function (err) {
+            _this.notifyError(invocation, err);
+        });
+    };
+    InvocationService.prototype.invokeNonSmart = function (invocation) {
+        var _this = this;
+        var invocationPromise;
+        invocation.invokeCount++;
+        if (invocation.hasOwnProperty('connection')) {
+            invocationPromise = this.send(invocation, invocation.connection);
+        }
+        else {
+            invocationPromise = this.invokeOnOwner(invocation);
+        }
+        invocationPromise.catch(function (err) {
+            _this.notifyError(invocation, err);
+        });
+    };
+    InvocationService.prototype.invokeOnOwner = function (invocation) {
+        var owner = this.client.getClusterService().getOwnerConnection();
+        if (owner == null) {
+            return Promise.reject(new HazelcastError_1.IOError('Unisocket client\'s owner connection is not available.'));
+        }
+        return this.send(invocation, owner);
+    };
+    InvocationService.prototype.invokeOnAddress = function (invocation, address) {
+        var _this = this;
+        return this.client.getConnectionManager().getOrConnect(address).then(function (connection) {
+            return _this.send(invocation, connection);
+        }).catch(function (e) {
+            _this.logger.debug('InvocationService', e);
+            throw new HazelcastError_1.IOError(address.toString() + ' is not available.', e);
+        });
+    };
+    InvocationService.prototype.invokeOnPartitionOwner = function (invocation, partitionId) {
+        var _this = this;
+        var ownerAddress = this.client.getPartitionService().getAddressForPartition(partitionId);
+        if (!ownerAddress) {
+            // If we don't have partition information, refresh and retry
+            this.logger.debug('InvocationService', "No partition owner for partition " + partitionId + ", refreshing partition table");
+            return this.client.getPartitionService().refresh().then(function () {
+                var newOwnerAddress = _this.client.getPartitionService().getAddressForPartition(partitionId);
+                if (!newOwnerAddress) {
+                    throw new Error("Still no partition owner for partition " + partitionId + " after refresh");
+                }
+                return _this.invokeOnAddress(invocation, newOwnerAddress);
+            });
+        }
+        return this.client.getConnectionManager().getOrConnect(ownerAddress).then(function (connection) {
+            return _this.send(invocation, connection);
+        }).catch(function (e) {
+            _this.logger.debug('InvocationService', "Partition owner " + ownerAddress.toString() + " unavailable for partition " + partitionId + ":", e);
+            // If this is a partition-specific failure, refresh partition table and retry
+            if (invocation.hasPartitionId()) {
+                _this.logger.debug('InvocationService', "Refreshing partition table due to partition owner failure");
+                return _this.client.getPartitionService().refresh().then(function () {
+                    // Retry the invocation with updated partition information
+                    return _this.doInvoke(invocation);
+                });
+            }
+            throw new HazelcastError_1.IOError(ownerAddress.toString() + '(partition owner) is not available.', e);
+        });
+    };
+    InvocationService.prototype.send = function (invocation, connection) {
+        assert(connection != null);
+        if (this.isShutdown) {
+            return Promise.reject(new HazelcastError_1.ClientNotActiveError('Client is shutdown.'));
+        }
+        this.registerInvocation(invocation);
+        return connection.write(invocation.request.getBuffer()).then(function () {
+            invocation.sendConnection = connection;
+        });
+    };
+    InvocationService.prototype.notifyError = function (invocation, error) {
+        var correlationId = invocation.request.getCorrelationId();
+        if (this.rejectIfNotRetryable(invocation, error)) {
+            this.pending.delete(correlationId);
+            return;
+        }
+        // Check if we've exceeded max retry attempts
+        if (invocation.invokeCount >= this.maxRetryAttempts) {
+            this.logger.error('InvocationService', "Max retry attempts (" + this.maxRetryAttempts + ") exceeded for correlation-id=" + correlationId);
+            invocation.deferred.reject(new Error("Max retry attempts exceeded: " + error.message));
+            this.pending.delete(correlationId);
+            return;
+        }
+        this.logger.debug('InvocationService', 'Retrying(' + invocation.invokeCount + ') on correlation-id=' + correlationId, error);
+        // Use exponential backoff for partition failures
+        var retryDelay = this.getInvocationRetryPauseMillis();
+        if (invocation.hasPartitionId() && error instanceof HazelcastError_1.IOError) {
+            retryDelay = this.partitionFailureBackoff;
+        }
+        if (invocation.invokeCount < MAX_FAST_INVOCATION_COUNT) {
+            this.doInvoke(invocation);
+        }
+        else {
+            setTimeout(this.doInvoke.bind(this, invocation), retryDelay);
+        }
+    };
+    /**
+     * 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
+     */
+    InvocationService.prototype.rejectIfNotRetryable = function (invocation, error) {
+        if (!this.client.getLifecycleService().isRunning()) {
+            invocation.deferred.reject(new HazelcastError_1.ClientNotActiveError('Client is not active.', error));
+            return true;
+        }
+        if (!invocation.isAllowedToRetryOnSelection(error)) {
+            invocation.deferred.reject(error);
+            return true;
+        }
+        if (!invocation.shouldRetry(error)) {
+            invocation.deferred.reject(error);
+            return true;
+        }
+        if (invocation.deadline < Date.now()) {
+            this.logger.trace('InvocationService', 'Error will not be retried because invocation timed out');
+            invocation.deferred.reject(new HazelcastError_1.InvocationTimeoutError('Invocation ' + invocation.request.getCorrelationId() + ')'
+                + ' reached its deadline.', error));
+            return true;
+        }
+    };
+    InvocationService.prototype.registerInvocation = function (invocation) {
+        var message = invocation.request;
+        var correlationId = message.getCorrelationId();
+        if (invocation.hasPartitionId()) {
+            message.setPartitionId(invocation.partitionId);
+        }
+        else {
+            message.setPartitionId(-1);
+        }
+        if (invocation.hasOwnProperty('handler')) {
+            this.eventHandlers.set(correlationId, invocation);
+        }
+        this.pending.set(correlationId, invocation);
+    };
+    return InvocationService;
+}());
+exports.InvocationService = InvocationService;

package/lib/invocation/Murmur.d.ts

@@ -0,0 +1,2 @@
+declare function murmurhash3_32_gc(key: any): number;
+export = murmurhash3_32_gc;

package/lib/invocation/Murmur.js

@@ -0,0 +1,65 @@
+"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.
+ */
+/* tslint:disable */
+var seed = 0x01000193;
+function murmurhash3_32_gc(key) {
+    var remainder, bytes, h1, h1b, c1, c2, k1, i;
+    remainder = key.length & 3; // key.length % 4
+    bytes = key.length - remainder;
+    h1 = seed;
+    c1 = 0xcc9e2d51;
+    c2 = 0x1b873593;
+    i = 0;
+    while (i < bytes) {
+        k1 =
+            ((key.readUInt8(i) & 0xff)) |
+                ((key.readUInt8(++i) & 0xff) << 8) |
+                ((key.readUInt8(++i) & 0xff) << 16) |
+                ((key.readUInt8(++i) & 0xff) << 24);
+        ++i;
+        k1 = ((((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16))) & 0xffffffff;
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 = ((((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16))) & 0xffffffff;
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1b = ((((h1 & 0xffff) * 5) + ((((h1 >>> 16) * 5) & 0xffff) << 16))) & 0xffffffff;
+        h1 = (((h1b & 0xffff) + 0x6b64) + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16));
+    }
+    k1 = 0;
+    switch (remainder) {
+        case 3:
+            k1 ^= (key.readUInt8(i + 2) & 0xff) << 16;
+        case 2:
+            k1 ^= (key.readUInt8(i + 1) & 0xff) << 8;
+        case 1:
+            k1 ^= (key.readUInt8(i) & 0xff);
+            k1 = (((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = (((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
+            h1 ^= k1;
+    }
+    h1 ^= key.length;
+    h1 ^= h1 >>> 16;
+    h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) & 0xffffffff;
+    h1 ^= h1 >>> 13;
+    h1 = ((((h1 & 0xffff) * 0xc2b2ae35) + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16))) & 0xffffffff;
+    h1 ^= h1 >>> 16;
+    var result = h1 >>> 0;
+    // This simulates the 32 bit integer overflow to match Java implementation
+    return result | 0;
+}
+module.exports = murmurhash3_32_gc;