@celerispay/hazelcast-client 3.12.5

package/lib/logging/LoggingService.js

@@ -0,0 +1,50 @@
+"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 DefaultLogger_1 = require("./DefaultLogger");
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["OFF"] = -1] = "OFF";
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+var LoggingService = /** @class */ (function () {
+    function LoggingService(customLogger, logLevel) {
+        if (customLogger == null) {
+            this.logger = new DefaultLogger_1.DefaultLogger(logLevel);
+        }
+        else if (this.isLogger(customLogger)) {
+            this.logger = customLogger;
+        }
+        else {
+            throw new RangeError('Logger should implement ILogger functions!');
+        }
+    }
+    LoggingService.prototype.isLogger = function (loggingProperty) {
+        loggingProperty = loggingProperty;
+        return loggingProperty.log !== undefined && loggingProperty.error !== undefined && loggingProperty.warn !== undefined &&
+            loggingProperty.info !== undefined && loggingProperty.debug !== undefined && loggingProperty.trace !== undefined;
+    };
+    LoggingService.prototype.getLogger = function () {
+        return this.logger;
+    };
+    return LoggingService;
+}());
+exports.LoggingService = LoggingService;

package/lib/nearcache/AlwaysFreshStaleReadDetectorImpl.d.ts

@@ -0,0 +1,10 @@
+import { DataRecord } from './DataRecord';
+import { MetadataContainer } from './MetadataContainer';
+import { StaleReadDetector } from './StaleReadDetector';
+export declare class AlwaysFreshStaleReadDetector implements StaleReadDetector {
+    isStaleRead(key: any, record: DataRecord): boolean;
+    getPartitionId(key: any): number;
+    getMetadataContainer(partitionId: number): MetadataContainer;
+}
+declare const INSTANCE: AlwaysFreshStaleReadDetector;
+export { INSTANCE };

package/lib/nearcache/AlwaysFreshStaleReadDetectorImpl.js

@@ -0,0 +1,34 @@
+"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 AlwaysFreshStaleReadDetector = /** @class */ (function () {
+    function AlwaysFreshStaleReadDetector() {
+    }
+    AlwaysFreshStaleReadDetector.prototype.isStaleRead = function (key, record) {
+        return false;
+    };
+    AlwaysFreshStaleReadDetector.prototype.getPartitionId = function (key) {
+        return 0;
+    };
+    AlwaysFreshStaleReadDetector.prototype.getMetadataContainer = function (partitionId) {
+        return null;
+    };
+    return AlwaysFreshStaleReadDetector;
+}());
+exports.AlwaysFreshStaleReadDetector = AlwaysFreshStaleReadDetector;
+var INSTANCE = new AlwaysFreshStaleReadDetector();
+exports.INSTANCE = INSTANCE;

package/lib/nearcache/DataRecord.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="long" />
+import * as Long from 'long';
+import { UUID } from '../core/UUID';
+import { Data } from '../serialization/Data';
+export declare class DataRecord {
+    static readonly NOT_RESERVED: Long;
+    static readonly RESERVED: Long;
+    static readonly READ_PERMITTED: Long;
+    key: Data;
+    value: Data | any;
+    private creationTime;
+    private expirationTime;
+    private lastAccessTime;
+    private accessHit;
+    private invalidationSequence;
+    private uuid;
+    private status;
+    private ttl;
+    constructor(key: Data, value: Data | any, creationTime?: number, ttl?: number);
+    static lruComp(x: DataRecord, y: DataRecord): number;
+    static lfuComp(x: DataRecord, y: DataRecord): number;
+    static randomComp(x: DataRecord, y: DataRecord): number;
+    isExpired(maxIdleSeconds: number): boolean;
+    setAccessTime(): void;
+    hitRecord(): void;
+    getInvalidationSequence(): Long;
+    setInvalidationSequence(sequence: Long): void;
+    hasSameUuid(uuid: UUID): boolean;
+    setUuid(uuid: UUID): void;
+    casStatus(expected: Long, update: Long): boolean;
+    getStatus(): Long;
+    setCreationTime(creationTime?: number): void;
+}

package/lib/nearcache/DataRecord.js

@@ -0,0 +1,109 @@
+"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 DataRecord = /** @class */ (function () {
+    function DataRecord(key, value, creationTime, ttl) {
+        this.key = key;
+        this.value = value;
+        this.ttl = ttl;
+        if (creationTime) {
+            this.creationTime = creationTime;
+        }
+        else {
+            this.creationTime = Date.now();
+        }
+        if (ttl) {
+            this.expirationTime = this.creationTime + ttl * 1000;
+        }
+        else {
+            this.expirationTime = undefined;
+        }
+        this.lastAccessTime = this.creationTime;
+        this.accessHit = 0;
+        this.invalidationSequence = Long.fromNumber(0);
+        this.uuid = null;
+        this.status = DataRecord.READ_PERMITTED;
+    }
+    /*tslint:disable:member-ordering*/
+    DataRecord.lruComp = function (x, y) {
+        return x.lastAccessTime - y.lastAccessTime;
+    };
+    DataRecord.lfuComp = function (x, y) {
+        return x.accessHit - y.accessHit;
+    };
+    DataRecord.randomComp = function (x, y) {
+        return Math.random() - 0.5;
+    };
+    DataRecord.prototype.isExpired = function (maxIdleSeconds) {
+        var now = Date.now();
+        if ((this.expirationTime > 0 && this.expirationTime < now) ||
+            (maxIdleSeconds > 0 && this.lastAccessTime + maxIdleSeconds * 1000 < now)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
+    DataRecord.prototype.setAccessTime = function () {
+        this.lastAccessTime = Date.now();
+    };
+    DataRecord.prototype.hitRecord = function () {
+        this.accessHit++;
+    };
+    DataRecord.prototype.getInvalidationSequence = function () {
+        return this.invalidationSequence;
+    };
+    DataRecord.prototype.setInvalidationSequence = function (sequence) {
+        this.invalidationSequence = sequence;
+    };
+    DataRecord.prototype.hasSameUuid = function (uuid) {
+        return uuid != null && this.uuid != null && this.uuid.equals(uuid);
+    };
+    DataRecord.prototype.setUuid = function (uuid) {
+        this.uuid = uuid;
+    };
+    DataRecord.prototype.casStatus = function (expected, update) {
+        if (expected.equals(this.status)) {
+            this.status = update;
+            return true;
+        }
+        return false;
+    };
+    DataRecord.prototype.getStatus = function () {
+        return this.status;
+    };
+    DataRecord.prototype.setCreationTime = function (creationTime) {
+        if (creationTime) {
+            this.creationTime = creationTime;
+        }
+        else {
+            this.creationTime = Date.now();
+        }
+        if (this.ttl) {
+            this.expirationTime = this.creationTime + this.ttl * 1000;
+        }
+        else {
+            this.expirationTime = undefined;
+        }
+    };
+    DataRecord.NOT_RESERVED = Long.NEG_ONE;
+    DataRecord.RESERVED = Long.fromNumber(-2);
+    DataRecord.READ_PERMITTED = Long.fromNumber(-3);
+    return DataRecord;
+}());
+exports.DataRecord = DataRecord;

package/lib/nearcache/MetadataContainer.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="long" />
+import * as Long from 'long';
+import { UUID } from '../core/UUID';
+export declare class MetadataContainer {
+    private sequence;
+    private staleSequence;
+    private missedSequenceCount;
+    private uuid;
+    reset(): void;
+    setSequence(sequence: Long): void;
+    getSequence(): Long;
+    setStaleSequence(staleSequence: Long): void;
+    getStaleSequence(): Long;
+    increaseMissedSequenceCount(missed: Long): void;
+    getMissedSequenceCount(): Long;
+    setUuid(uuid: UUID): void;
+    getUuid(): UUID;
+}

package/lib/nearcache/MetadataContainer.js

@@ -0,0 +1,56 @@
+"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 MetadataContainer = /** @class */ (function () {
+    function MetadataContainer() {
+        this.sequence = Long.fromNumber(0);
+        this.staleSequence = Long.fromNumber(0);
+        this.missedSequenceCount = Long.fromNumber(0);
+    }
+    MetadataContainer.prototype.reset = function () {
+        this.sequence = Long.fromNumber(0);
+        this.staleSequence = Long.fromNumber(0);
+        this.missedSequenceCount = Long.fromNumber(0);
+    };
+    MetadataContainer.prototype.setSequence = function (sequence) {
+        this.sequence = sequence;
+    };
+    MetadataContainer.prototype.getSequence = function () {
+        return this.sequence;
+    };
+    MetadataContainer.prototype.setStaleSequence = function (staleSequence) {
+        this.staleSequence = staleSequence;
+    };
+    MetadataContainer.prototype.getStaleSequence = function () {
+        return this.staleSequence;
+    };
+    MetadataContainer.prototype.increaseMissedSequenceCount = function (missed) {
+        this.missedSequenceCount = this.missedSequenceCount.add(missed);
+    };
+    MetadataContainer.prototype.getMissedSequenceCount = function () {
+        return this.missedSequenceCount;
+    };
+    MetadataContainer.prototype.setUuid = function (uuid) {
+        this.uuid = uuid;
+    };
+    MetadataContainer.prototype.getUuid = function () {
+        return this.uuid;
+    };
+    return MetadataContainer;
+}());
+exports.MetadataContainer = MetadataContainer;

package/lib/nearcache/MetadataFetcher.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="bluebird" />
+/// <reference types="long" />
+import * as Promise from 'bluebird';
+import { UUID } from '../core/UUID';
+import HazelcastClient from '../HazelcastClient';
+import { RepairingHandler } from './RepairingHandler';
+import ClientMessage = require('../ClientMessage');
+export declare class MetadataFetcher {
+    private client;
+    private partitionService;
+    private logger;
+    constructor(client: HazelcastClient);
+    initHandler(handler: RepairingHandler): Promise<void>;
+    fetchMetadata(handlers: Map<string, RepairingHandler>): Promise<void>;
+    protected processResponse(responseMessage: ClientMessage, handlers: Map<string, RepairingHandler>): void;
+    protected repairUuids(handler: RepairingHandler, partitionIdUuidList: Array<[number, UUID]>): void;
+    protected repairSequences(handler: RepairingHandler, partitionIdSequenceList: Array<[string, Array<[number, Long]>]>): void;
+    protected scanMembers(objectNames: string[]): Array<Promise<ClientMessage>>;
+    private getObjectNames(handlers);
+}

package/lib/nearcache/MetadataFetcher.js

@@ -0,0 +1,92 @@
+"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 MapFetchNearCacheInvalidationMetadataCodec_1 = require("../codec/MapFetchNearCacheInvalidationMetadataCodec");
+var MemberSelectors_1 = require("../core/MemberSelectors");
+var InvocationService_1 = require("../invocation/InvocationService");
+var MetadataFetcher = /** @class */ (function () {
+    function MetadataFetcher(client) {
+        this.logger = client.getLoggingService().getLogger();
+        this.client = client;
+        this.partitionService = this.client.getPartitionService();
+    }
+    MetadataFetcher.prototype.initHandler = function (handler) {
+        var scanPromises = this.scanMembers([handler.getName()]);
+        return Promise.all(scanPromises).then(function (responses) {
+            responses.forEach(function (response) {
+                var metadata = MapFetchNearCacheInvalidationMetadataCodec_1.MapFetchNearCacheInvalidationMetadataCodec.decodeResponse(response);
+                handler.initUuid(metadata.partitionUuidList);
+                handler.initSequence(metadata.namePartitionSequenceList[0]);
+            });
+        });
+    };
+    MetadataFetcher.prototype.fetchMetadata = function (handlers) {
+        var _this = this;
+        var objectNames = this.getObjectNames(handlers);
+        var promises = this.scanMembers(objectNames);
+        return Promise.each(promises, function (clientMessage) {
+            _this.processResponse(clientMessage, handlers);
+        }).return();
+    };
+    MetadataFetcher.prototype.processResponse = function (responseMessage, handlers) {
+        var _this = this;
+        var metadata = MapFetchNearCacheInvalidationMetadataCodec_1.MapFetchNearCacheInvalidationMetadataCodec.decodeResponse(responseMessage);
+        handlers.forEach(function (handler) {
+            try {
+                _this.repairUuids(handler, metadata.partitionUuidList);
+                _this.repairSequences(handler, metadata.namePartitionSequenceList);
+            }
+            catch (e) {
+                _this.logger.warn('MetadataFetcher', 'Can not get invalidation metadata ' + e.message);
+            }
+        });
+    };
+    MetadataFetcher.prototype.repairUuids = function (handler, partitionIdUuidList) {
+        partitionIdUuidList.forEach(function (entry) {
+            handler.checkOrRepairUuid(entry[0], entry[1]);
+        });
+    };
+    MetadataFetcher.prototype.repairSequences = function (handler, partitionIdSequenceList) {
+        partitionIdSequenceList.forEach(function (partitionIdSeq) {
+            var pairs = partitionIdSeq[1];
+            pairs.forEach(function (pair) {
+                handler.checkOrRepairSequence(pair[0], pair[1], true);
+            });
+        });
+    };
+    MetadataFetcher.prototype.scanMembers = function (objectNames) {
+        var _this = this;
+        var members = this.client.getClusterService().getMembers(MemberSelectors_1.MemberSelectors.DATA_MEMBER_SELECTOR);
+        var promises = [];
+        members.forEach(function (member) {
+            var request = MapFetchNearCacheInvalidationMetadataCodec_1.MapFetchNearCacheInvalidationMetadataCodec.encodeRequest(objectNames, member.address);
+            var promise = _this.client.getInvocationService().invoke(new InvocationService_1.Invocation(_this.client, request));
+            promises.push(promise);
+        });
+        return promises;
+    };
+    MetadataFetcher.prototype.getObjectNames = function (handlers) {
+        var names = [];
+        handlers.forEach(function (handler) {
+            names.push(handler.getName());
+        });
+        return names;
+    };
+    return MetadataFetcher;
+}());
+exports.MetadataFetcher = MetadataFetcher;

package/lib/nearcache/NearCache.d.ts

@@ -0,0 +1,89 @@
+/// <reference types="bluebird" />
+/// <reference types="long" />
+import * as Long from 'long';
+import { NearCacheConfig } from '../config/NearCacheConfig';
+import { DataKeyedHashMap } from '../DataStoreHashMap';
+import { Data } from '../serialization/Data';
+import { SerializationService } from '../serialization/SerializationService';
+import { DataRecord } from './DataRecord';
+import { StaleReadDetector } from './StaleReadDetector';
+import * as Promise from 'bluebird';
+export interface NearCacheStatistics {
+    creationTime: number;
+    evictedCount: number;
+    expiredCount: number;
+    missCount: number;
+    hitCount: number;
+    entryCount: number;
+}
+export interface NearCache {
+    put(key: Data, value: any): void;
+    get(key: Data): Promise<Data | any>;
+    getName(): string;
+    invalidate(key: Data): void;
+    clear(): void;
+    getStatistics(): NearCacheStatistics;
+    isInvalidatedOnChange(): boolean;
+    setStaleReadDetector(detector: StaleReadDetector): void;
+    tryReserveForUpdate(key: Data): Long;
+    tryPublishReserved(key: Data, value: any, reservationId: Long): any;
+    setReady(): void;
+}
+export declare class NearCacheImpl implements NearCache {
+    internalStore: DataKeyedHashMap<DataRecord>;
+    private serializationService;
+    private name;
+    private invalidateOnChange;
+    private maxIdleSeconds;
+    private inMemoryFormat;
+    private timeToLiveSeconds;
+    private evictionPolicy;
+    private evictionMaxSize;
+    private evictionSamplingCount;
+    private evictionSamplingPoolSize;
+    private evictionCandidatePool;
+    private staleReadDetector;
+    private reservationCounter;
+    private evictedCount;
+    private expiredCount;
+    private missCount;
+    private hitCount;
+    private creationTime;
+    private compareFunc;
+    private ready;
+    constructor(nearCacheConfig: NearCacheConfig, serializationService: SerializationService);
+    setReady(): void;
+    getName(): string;
+    nextReservationId(): Long;
+    tryReserveForUpdate(key: Data): Long;
+    tryPublishReserved(key: Data, value: any, reservationId: Long): any;
+    setStaleReadDetector(staleReadDetector: StaleReadDetector): void;
+    /**
+     * Creates a new {DataRecord} for given key and value. Then, puts the record in near cache.
+     * If the number of records in near cache exceeds {evictionMaxSize}, it removes expired items first.
+     * If there is no expired item, it triggers an invalidation process to create free space.
+     * @param key
+     * @param value
+     */
+    put(key: Data, value: any): void;
+    /**
+     *
+     * @param key
+     * @returns the value if present in near cache, 'undefined' if not
+     */
+    get(key: Data): Promise<Data | any>;
+    invalidate(key: Data): void;
+    clear(): void;
+    isInvalidatedOnChange(): boolean;
+    getStatistics(): NearCacheStatistics;
+    protected isEvictionRequired(): boolean;
+    protected doEvictionIfRequired(): void;
+    /**
+     * @returns number of expired elements.
+     */
+    protected recomputeEvictionPool(): number;
+    protected filterExpiredRecord(candidate: DataRecord): boolean;
+    protected expireRecord(key: any | Data): void;
+    protected evictRecord(key: any | Data): void;
+    private initInvalidationMetadata(dr);
+}