@celerispay/hazelcast-client 3.12.5

package/lib/ListenerService.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { ConnectionHeartbeatListener } from './core/ConnectionHeartbeatListener';
+import HazelcastClient from './HazelcastClient';
+import { ClientConnection } from './invocation/ClientConnection';
+import { ClientEventRegistration } from './invocation/ClientEventRegistration';
+import { ListenerMessageCodec } from './ListenerMessageCodec';
+export declare class ListenerService implements ConnectionHeartbeatListener {
+    private client;
+    private internalEventEmitter;
+    private logger;
+    private isShutdown;
+    private isSmartService;
+    private activeRegistrations;
+    private failedRegistrations;
+    private userRegistrationKeyInformation;
+    private connectionRefreshTask;
+    private connectionRefreshTaskInterval;
+    constructor(client: HazelcastClient);
+    start(): void;
+    onConnectionAdded(connection: ClientConnection): void;
+    onConnectionRemoved(connection: ClientConnection): void;
+    onHeartbeatRestored(connection: ClientConnection): void;
+    reregisterListeners(): void;
+    reregisterListenersOnConnection(connection: ClientConnection): void;
+    removeRegistrationsOnConnection(connection: ClientConnection): void;
+    invokeRegistrationFromRecord(userRegistrationKey: string, connection: ClientConnection): Promise<ClientEventRegistration>;
+    registerListener(codec: ListenerMessageCodec, registerHandlerFunc: any): Promise<string>;
+    deregisterListener(userRegistrationKey: string): Promise<boolean>;
+    isSmart(): boolean;
+    shutdown(): void;
+    protected connectionRefreshHandler(): void;
+    protected registerListenerInternal(codec: ListenerMessageCodec, listenerHandlerFunc: Function): Promise<string>;
+    private trySyncConnectToAllConnections();
+}

package/lib/ListenerService.js

@@ -0,0 +1,233 @@
+"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 events_1 = require("events");
+var HazelcastError_1 = require("./HazelcastError");
+var ClientEventRegistration_1 = require("./invocation/ClientEventRegistration");
+var InvocationService_1 = require("./invocation/InvocationService");
+var RegistrationKey_1 = require("./invocation/RegistrationKey");
+var Util_1 = require("./Util");
+var UuidUtil_1 = require("./util/UuidUtil");
+var ListenerService = /** @class */ (function () {
+    function ListenerService(client) {
+        this.isShutdown = false;
+        this.client = client;
+        this.logger = this.client.getLoggingService().getLogger();
+        this.isSmartService = this.client.getConfig().networkConfig.smartRouting;
+        this.internalEventEmitter = new events_1.EventEmitter();
+        this.internalEventEmitter.setMaxListeners(0);
+        this.activeRegistrations = new Map();
+        this.failedRegistrations = new Map();
+        this.userRegistrationKeyInformation = new Map();
+        this.connectionRefreshTaskInterval = 2000;
+    }
+    ListenerService.prototype.start = function () {
+        this.client.getConnectionManager().on('connectionOpened', this.onConnectionAdded.bind(this));
+        this.client.getConnectionManager().on('connectionClosed', this.onConnectionRemoved.bind(this));
+        if (this.isSmart()) {
+            this.connectionRefreshTask = this.connectionRefreshHandler();
+        }
+    };
+    ListenerService.prototype.onConnectionAdded = function (connection) {
+        this.reregisterListenersOnConnection(connection);
+    };
+    ListenerService.prototype.onConnectionRemoved = function (connection) {
+        this.removeRegistrationsOnConnection(connection);
+    };
+    ListenerService.prototype.onHeartbeatRestored = function (connection) {
+        var _this = this;
+        var failedRegistrationsOnConn = this.failedRegistrations.get(connection);
+        failedRegistrationsOnConn.forEach(function (userKey, ignored) {
+            _this.invokeRegistrationFromRecord(userKey, connection);
+        });
+    };
+    ListenerService.prototype.reregisterListeners = function () {
+        var connections = this.client.getConnectionManager().getActiveConnections();
+        for (var connAddress in connections) {
+            this.reregisterListenersOnConnection(connections[connAddress]);
+        }
+    };
+    ListenerService.prototype.reregisterListenersOnConnection = function (connection) {
+        var _this = this;
+        this.activeRegistrations.forEach(function (registrationMap, userKey) {
+            if (registrationMap.has(connection)) {
+                return;
+            }
+            _this.invokeRegistrationFromRecord(userKey, connection).then(function (eventRegistration) {
+                registrationMap.set(connection, eventRegistration);
+            }).catch(function (e) {
+                _this.logger.warn('ListenerService', e);
+            });
+        }, this);
+    };
+    ListenerService.prototype.removeRegistrationsOnConnection = function (connection) {
+        var _this = this;
+        this.failedRegistrations.delete(connection);
+        this.activeRegistrations.forEach(function (registrationsOnUserKey, userKey) {
+            var eventRegistration = registrationsOnUserKey.get(connection);
+            if (eventRegistration !== undefined) {
+                _this.client.getInvocationService().removeEventHandler(eventRegistration.correlationId);
+            }
+        });
+    };
+    ListenerService.prototype.invokeRegistrationFromRecord = function (userRegistrationKey, connection) {
+        var _this = this;
+        var deferred = Util_1.DeferredPromise();
+        var activeRegsOnUserKey = this.activeRegistrations.get(userRegistrationKey);
+        if (activeRegsOnUserKey !== undefined && activeRegsOnUserKey.has(connection)) {
+            deferred.resolve(activeRegsOnUserKey.get(connection));
+            return deferred.promise;
+        }
+        var registrationKey = this.userRegistrationKeyInformation.get(userRegistrationKey);
+        var registerRequest = registrationKey.getRegisterRequest();
+        var codec = registrationKey.getCodec();
+        var invocation = new InvocationService_1.Invocation(this.client, registerRequest);
+        invocation.handler = registrationKey.getHandler();
+        invocation.connection = connection;
+        this.client.getInvocationService().invoke(invocation).then(function (responseMessage) {
+            var correlationId = responseMessage.getCorrelationId();
+            var response = codec.decodeAddResponse(responseMessage);
+            var eventRegistration = new ClientEventRegistration_1.ClientEventRegistration(response, correlationId, invocation.connection, codec);
+            _this.logger.debug('ListenerService', 'Listener ' + userRegistrationKey + ' re-registered on ' + connection.toString());
+            deferred.resolve(eventRegistration);
+        }).catch((function (e) {
+            var failedRegsOnConnection = _this.failedRegistrations.get(connection);
+            if (failedRegsOnConnection === undefined) {
+                failedRegsOnConnection = new Set();
+                failedRegsOnConnection.add(userRegistrationKey);
+                _this.failedRegistrations.set(connection, failedRegsOnConnection);
+            }
+            else {
+                failedRegsOnConnection.add(userRegistrationKey);
+            }
+            deferred.reject(new HazelcastError_1.HazelcastError('Could not add listener[' + userRegistrationKey +
+                '] to connection[' + connection.toString() + ']', e));
+        }));
+        return deferred.promise;
+    };
+    ListenerService.prototype.registerListener = function (codec, registerHandlerFunc) {
+        var _this = this;
+        var readyToRegisterPromise;
+        if (this.isSmart()) {
+            readyToRegisterPromise = this.trySyncConnectToAllConnections();
+        }
+        else {
+            // No need for preparation, just return a resolved promise
+            readyToRegisterPromise = Promise.resolve();
+        }
+        return readyToRegisterPromise.then(function () {
+            return _this.registerListenerInternal(codec, registerHandlerFunc);
+        });
+    };
+    ListenerService.prototype.deregisterListener = function (userRegistrationKey) {
+        var _this = this;
+        var deferred = Util_1.DeferredPromise();
+        var registrationsOnUserKey = this.activeRegistrations.get(userRegistrationKey);
+        if (registrationsOnUserKey === undefined) {
+            deferred.resolve(false);
+            return deferred.promise;
+        }
+        registrationsOnUserKey.forEach(function (eventRegistration, connection) {
+            var clientMessage = eventRegistration.codec.encodeRemoveRequest(eventRegistration.serverRegistrationId);
+            var invocation = new InvocationService_1.Invocation(_this.client, clientMessage);
+            invocation.connection = eventRegistration.subscriber;
+            _this.client.getInvocationService().invoke(invocation).then(function (responseMessage) {
+                registrationsOnUserKey.delete(connection);
+                _this.client.getInvocationService().removeEventHandler(eventRegistration.correlationId);
+                _this.logger.debug('ListenerService', 'Listener ' + userRegistrationKey + ' unregistered from ' + invocation.connection.toString());
+                _this.activeRegistrations.delete(userRegistrationKey);
+                _this.userRegistrationKeyInformation.delete(userRegistrationKey);
+                deferred.resolve(true);
+            });
+        });
+        return deferred.promise;
+    };
+    ListenerService.prototype.isSmart = function () {
+        return this.isSmartService;
+    };
+    ListenerService.prototype.shutdown = function () {
+        this.isShutdown = true;
+        clearTimeout(this.connectionRefreshTask);
+    };
+    ListenerService.prototype.connectionRefreshHandler = function () {
+        var _this = this;
+        if (this.isShutdown) {
+            return;
+        }
+        this.trySyncConnectToAllConnections().catch(function (e) {
+        }).finally(function () {
+            _this.connectionRefreshTask =
+                setTimeout(_this.connectionRefreshHandler.bind(_this), _this.connectionRefreshTaskInterval);
+        });
+    };
+    ListenerService.prototype.registerListenerInternal = function (codec, listenerHandlerFunc) {
+        var _this = this;
+        var activeConnections = Util_1.copyObjectShallow(this.client.getConnectionManager().getActiveConnections());
+        var userRegistrationKey = UuidUtil_1.UuidUtil.generate().toString();
+        var connectionsOnUserKey;
+        var deferred = Util_1.DeferredPromise();
+        var registerRequest = codec.encodeAddRequest(this.isSmart());
+        connectionsOnUserKey = this.activeRegistrations.get(userRegistrationKey);
+        if (connectionsOnUserKey === undefined) {
+            connectionsOnUserKey = new Map();
+            this.activeRegistrations.set(userRegistrationKey, connectionsOnUserKey);
+            this.userRegistrationKeyInformation.set(userRegistrationKey, new RegistrationKey_1.RegistrationKey(userRegistrationKey, codec, registerRequest, listenerHandlerFunc));
+        }
+        var _loop_1 = function (address) {
+            if (connectionsOnUserKey.has(activeConnections[address])) {
+                return "continue";
+            }
+            var requestCopy = registerRequest.clone();
+            var invocation = new InvocationService_1.Invocation(this_1.client, requestCopy);
+            invocation.handler = listenerHandlerFunc;
+            invocation.connection = activeConnections[address];
+            this_1.client.getInvocationService().invoke(invocation).then(function (responseMessage) {
+                var correlationId = responseMessage.getCorrelationId();
+                var response = codec.decodeAddResponse(responseMessage);
+                var clientEventRegistration = new ClientEventRegistration_1.ClientEventRegistration(response, correlationId, invocation.connection, codec);
+                _this.logger.debug('ListenerService', 'Listener ' + userRegistrationKey + ' registered on ' + invocation.connection.toString());
+                connectionsOnUserKey.set(activeConnections[address], clientEventRegistration);
+            }).then(function () {
+                deferred.resolve(userRegistrationKey);
+            }).catch(function (e) {
+                if (invocation.connection.isAlive()) {
+                    _this.deregisterListener(userRegistrationKey);
+                    deferred.reject(new HazelcastError_1.HazelcastError('Listener cannot be added!', e));
+                }
+            });
+        };
+        var this_1 = this;
+        for (var address in activeConnections) {
+            _loop_1(address);
+        }
+        return deferred.promise;
+    };
+    ListenerService.prototype.trySyncConnectToAllConnections = function () {
+        var _this = this;
+        assert(this.isSmart());
+        var members = this.client.getClusterService().getMembers();
+        var promises = [];
+        members.forEach(function (member) {
+            promises.push(_this.client.getConnectionManager().getOrConnect(member.address));
+        });
+        return Promise.all(promises).thenReturn();
+    };
+    return ListenerService;
+}());
+exports.ListenerService = ListenerService;

package/lib/LockReferenceIdGenerator.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="long" />
+import * as Long from 'long';
+export declare class LockReferenceIdGenerator {
+    private counter;
+    getNextReferenceId(): Long;
+}

package/lib/LockReferenceIdGenerator.js

@@ -0,0 +1,29 @@
+"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 Long = require("long");
+var LockReferenceIdGenerator = /** @class */ (function () {
+    function LockReferenceIdGenerator() {
+        this.counter = Long.fromNumber(0);
+    }
+    LockReferenceIdGenerator.prototype.getNextReferenceId = function () {
+        this.counter = this.counter.add(1);
+        return this.counter;
+    };
+    return LockReferenceIdGenerator;
+}());
+exports.LockReferenceIdGenerator = LockReferenceIdGenerator;

package/lib/PartitionService.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import HazelcastClient from './HazelcastClient';
+import Address = require('./Address');
+export declare class PartitionService {
+    private client;
+    private partitionMap;
+    private partitionCount;
+    private partitionRefreshTask;
+    private isShutdown;
+    private logger;
+    private lastRefreshTime;
+    private readonly minRefreshInterval;
+    constructor(client: HazelcastClient);
+    initialize(): Promise<void>;
+    shutdown(): void;
+    /**
+     * Clears the partition table, forcing a refresh on next operation
+     */
+    clearPartitionTable(): void;
+    /**
+     * Refreshes the internal partition table.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Returns the {@link Address} of the node which owns given partition id.
+     * @param partitionId
+     * @returns the address of the node.
+     */
+    getAddressForPartition(partitionId: number): Address;
+    /**
+     * Computes the partition id for a given key.
+     * @param key
+     * @returns the partition id.
+     */
+    getPartitionId(key: any): number;
+    getPartitionCount(): number;
+}

package/lib/PartitionService.js

@@ -0,0 +1,118 @@
+"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 GetPartitionsCodec = require("./codec/GetPartitionsCodec");
+var PARTITION_REFRESH_INTERVAL = 10000;
+var PartitionService = /** @class */ (function () {
+    function PartitionService(client) {
+        this.partitionMap = {};
+        this.lastRefreshTime = 0;
+        this.minRefreshInterval = 2000; // Minimum 2 seconds between refreshes
+        this.client = client;
+        this.logger = client.getLoggingService().getLogger();
+        this.isShutdown = false;
+    }
+    PartitionService.prototype.initialize = function () {
+        this.partitionRefreshTask = setInterval(this.refresh.bind(this), PARTITION_REFRESH_INTERVAL);
+        return this.refresh();
+    };
+    PartitionService.prototype.shutdown = function () {
+        clearInterval(this.partitionRefreshTask);
+        this.isShutdown = true;
+    };
+    /**
+     * Clears the partition table, forcing a refresh on next operation
+     */
+    PartitionService.prototype.clearPartitionTable = function () {
+        this.logger.info('PartitionService', 'Clearing partition table');
+        this.partitionMap = {};
+        this.partitionCount = 0;
+        this.lastRefreshTime = 0;
+    };
+    /**
+     * Refreshes the internal partition table.
+     */
+    PartitionService.prototype.refresh = function () {
+        var _this = this;
+        if (this.isShutdown) {
+            return Promise.resolve();
+        }
+        var now = Date.now();
+        if (now - this.lastRefreshTime < this.minRefreshInterval) {
+            this.logger.debug('PartitionService', 'Skipping refresh, too soon since last refresh');
+            return Promise.resolve();
+        }
+        var ownerConnection = this.client.getClusterService().getOwnerConnection();
+        if (ownerConnection == null) {
+            this.logger.warn('PartitionService', 'Cannot refresh partitions, no owner connection available');
+            return Promise.resolve();
+        }
+        var clientMessage = GetPartitionsCodec.encodeRequest();
+        return this.client.getInvocationService()
+            .invokeOnConnection(ownerConnection, clientMessage)
+            .then(function (response) {
+            var receivedPartitionMap = GetPartitionsCodec.decodeResponse(response);
+            _this.partitionMap = receivedPartitionMap;
+            _this.partitionCount = Object.keys(_this.partitionMap).length;
+            _this.lastRefreshTime = now;
+            _this.logger.debug('PartitionService', "Refreshed partition table with " + _this.partitionCount + " partitions");
+        }).catch(function (e) {
+            if (_this.client.getLifecycleService().isRunning()) {
+                _this.logger.warn('PartitionService', 'Error while fetching cluster partition table from '
+                    + _this.client.getClusterService().ownerUuid, e);
+                // If refresh fails, clear the table to force refresh on next operation
+                _this.clearPartitionTable();
+            }
+        });
+    };
+    /**
+     * Returns the {@link Address} of the node which owns given partition id.
+     * @param partitionId
+     * @returns the address of the node.
+     */
+    PartitionService.prototype.getAddressForPartition = function (partitionId) {
+        var _this = this;
+        var address = this.partitionMap[partitionId];
+        if (!address) {
+            this.logger.warn('PartitionService', "No address found for partition " + partitionId + ", refreshing partition table");
+            // Trigger a refresh if we don't have partition information
+            setImmediate(function () { return _this.refresh(); });
+        }
+        return address;
+    };
+    /**
+     * Computes the partition id for a given key.
+     * @param key
+     * @returns the partition id.
+     */
+    PartitionService.prototype.getPartitionId = function (key) {
+        var partitionHash;
+        if (typeof key === 'object' && 'getPartitionHash' in key) {
+            partitionHash = key.getPartitionHash();
+        }
+        else {
+            partitionHash = this.client.getSerializationService().toData(key).getPartitionHash();
+        }
+        return Math.abs(partitionHash) % this.partitionCount;
+    };
+    PartitionService.prototype.getPartitionCount = function () {
+        return this.partitionCount;
+    };
+    return PartitionService;
+}());
+exports.PartitionService = PartitionService;

package/lib/Util.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import { PagingPredicate } from './serialization/DefaultPredicates';
+import Address = require('./Address');
+export declare function assertNotNull(v: any): void;
+export declare function assertArray(x: any): void;
+export declare function assertString(v: any): void;
+export declare function shuffleArray<T>(array: T[]): void;
+export declare function assertNotNegative(v: number, message?: string): void;
+export declare function getType(obj: any): string;
+export declare function enumFromString<T>(enumType: any, value: string): T;
+export declare function getSortedQueryResultSet(list: any[], predicate: PagingPredicate): any[];
+export declare function copyObjectShallow<T>(obj: T): T;
+export declare function tryGetBoolean(val: any): boolean;
+export declare function tryGetNumber(val: any): number;
+export declare function tryGetArray(val: any): any[];
+export declare function tryGetString(val: any): string;
+export declare function getStringOrUndefined(val: any): string;
+export declare function getBooleanOrUndefined(val: any): boolean;
+export declare function tryGetEnum<T>(enumClass: any | {
+    [index: string]: number;
+}, str: string): T;
+export declare function resolvePath(path: string): string;
+export declare function loadNameFromPath(path: string, exportedName: string): any;
+export declare class AddressHelper {
+    private static readonly MAX_PORT_TRIES;
+    private static readonly INITIAL_FIRST_PORT;
+    static getSocketAddresses(address: string): Address[];
+    static createAddressFromString(address: string, defaultPort?: number): Address;
+}
+export declare function mergeJson(base: any, other: any): void;
+/**
+ * Returns a random integer between 0(inclusive) and `upperBound`(exclusive)
+ * Upper bound should be an integer.
+ * @param upperBound
+ * @returns A random integer between [0-upperBound)
+ */
+export declare function randomInt(upperBound: number): number;
+export declare class Task {
+    intervalId: NodeJS.Timer;
+    timeoutId: NodeJS.Timer;
+}
+export declare function scheduleWithRepetition(callback: (...args: any[]) => void, initialDelay: number, periodMillis: number): Task;
+export declare function cancelRepetitionTask(task: Task): void;
+export declare function DeferredPromise<T>(): Promise.Resolver<T>;
+export declare function getNodejsMajorVersion(): number;