@celerispay/hazelcast-client 3.12.5

package/lib/nearcache/NearCache.js

@@ -0,0 +1,250 @@
+"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 EvictionPolicy_1 = require("../config/EvictionPolicy");
+var InMemoryFormat_1 = require("../config/InMemoryFormat");
+var DataStoreHashMap_1 = require("../DataStoreHashMap");
+var Util_1 = require("../Util");
+var AlwaysFreshStaleReadDetectorImpl = require("./AlwaysFreshStaleReadDetectorImpl");
+var DataRecord_1 = require("./DataRecord");
+var NearCacheImpl = /** @class */ (function () {
+    function NearCacheImpl(nearCacheConfig, serializationService) {
+        this.staleReadDetector = AlwaysFreshStaleReadDetectorImpl.INSTANCE;
+        this.reservationCounter = Long.ZERO;
+        this.evictedCount = 0;
+        this.expiredCount = 0;
+        this.missCount = 0;
+        this.hitCount = 0;
+        this.creationTime = Date.now();
+        this.serializationService = serializationService;
+        this.name = nearCacheConfig.name;
+        this.invalidateOnChange = nearCacheConfig.invalidateOnChange;
+        this.maxIdleSeconds = nearCacheConfig.maxIdleSeconds;
+        this.inMemoryFormat = nearCacheConfig.inMemoryFormat;
+        this.timeToLiveSeconds = nearCacheConfig.timeToLiveSeconds;
+        this.evictionPolicy = nearCacheConfig.evictionPolicy;
+        this.evictionMaxSize = nearCacheConfig.evictionMaxSize;
+        this.evictionSamplingCount = nearCacheConfig.evictionSamplingCount;
+        this.evictionSamplingPoolSize = nearCacheConfig.evictionSamplingPoolSize;
+        if (this.evictionPolicy === EvictionPolicy_1.EvictionPolicy.LFU) {
+            this.compareFunc = DataRecord_1.DataRecord.lfuComp;
+        }
+        else if (this.evictionPolicy === EvictionPolicy_1.EvictionPolicy.LRU) {
+            this.compareFunc = DataRecord_1.DataRecord.lruComp;
+        }
+        else if (this.evictionPolicy === EvictionPolicy_1.EvictionPolicy.RANDOM) {
+            this.compareFunc = DataRecord_1.DataRecord.randomComp;
+        }
+        else {
+            this.compareFunc = undefined;
+        }
+        this.evictionCandidatePool = [];
+        this.internalStore = new DataStoreHashMap_1.DataKeyedHashMap();
+        this.ready = Util_1.DeferredPromise();
+    }
+    NearCacheImpl.prototype.setReady = function () {
+        this.ready.resolve();
+    };
+    NearCacheImpl.prototype.getName = function () {
+        return this.name;
+    };
+    NearCacheImpl.prototype.nextReservationId = function () {
+        var res = this.reservationCounter;
+        this.reservationCounter = this.reservationCounter.add(1);
+        return res;
+    };
+    NearCacheImpl.prototype.tryReserveForUpdate = function (key) {
+        var internalRecord = this.internalStore.get(key);
+        var resId = this.nextReservationId();
+        if (internalRecord === undefined) {
+            this.doEvictionIfRequired();
+            var dr = new DataRecord_1.DataRecord(key, undefined, undefined, this.timeToLiveSeconds);
+            dr.casStatus(DataRecord_1.DataRecord.READ_PERMITTED, resId);
+            this.internalStore.set(key, dr);
+            return resId;
+        }
+        if (internalRecord.casStatus(DataRecord_1.DataRecord.READ_PERMITTED, resId)) {
+            return resId;
+        }
+        return DataRecord_1.DataRecord.NOT_RESERVED;
+    };
+    NearCacheImpl.prototype.tryPublishReserved = function (key, value, reservationId) {
+        var internalRecord = this.internalStore.get(key);
+        if (internalRecord && internalRecord.casStatus(reservationId, DataRecord_1.DataRecord.READ_PERMITTED)) {
+            if (this.inMemoryFormat === InMemoryFormat_1.InMemoryFormat.OBJECT) {
+                internalRecord.value = this.serializationService.toObject(value);
+            }
+            else {
+                internalRecord.value = this.serializationService.toData(value);
+            }
+            internalRecord.setCreationTime();
+            this.initInvalidationMetadata(internalRecord);
+        }
+        else if (internalRecord === undefined) {
+            return undefined;
+        }
+        else {
+            if (this.inMemoryFormat === InMemoryFormat_1.InMemoryFormat.BINARY) {
+                return this.serializationService.toObject(internalRecord.value);
+            }
+            else {
+                return internalRecord.value;
+            }
+        }
+    };
+    NearCacheImpl.prototype.setStaleReadDetector = function (staleReadDetector) {
+        this.staleReadDetector = staleReadDetector;
+    };
+    /**
+     * 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
+     */
+    NearCacheImpl.prototype.put = function (key, value) {
+        this.doEvictionIfRequired();
+        if (this.inMemoryFormat === InMemoryFormat_1.InMemoryFormat.OBJECT) {
+            value = this.serializationService.toObject(value);
+        }
+        else {
+            value = this.serializationService.toData(value);
+        }
+        var dr = new DataRecord_1.DataRecord(key, value, undefined, this.timeToLiveSeconds);
+        this.initInvalidationMetadata(dr);
+        this.internalStore.set(key, dr);
+    };
+    /**
+     *
+     * @param key
+     * @returns the value if present in near cache, 'undefined' if not
+     */
+    NearCacheImpl.prototype.get = function (key) {
+        var _this = this;
+        return this.ready.promise.then(function () {
+            var dr = _this.internalStore.get(key);
+            if (dr === undefined) {
+                _this.missCount++;
+                return undefined;
+            }
+            if (_this.staleReadDetector.isStaleRead(key, dr)) {
+                _this.internalStore.delete(key);
+                _this.missCount++;
+                return undefined;
+            }
+            if (dr.isExpired(_this.maxIdleSeconds)) {
+                _this.expireRecord(key);
+                _this.missCount++;
+                return undefined;
+            }
+            dr.setAccessTime();
+            dr.hitRecord();
+            _this.hitCount++;
+            if (_this.inMemoryFormat === InMemoryFormat_1.InMemoryFormat.BINARY) {
+                return _this.serializationService.toObject(dr.value);
+            }
+            else {
+                return dr.value;
+            }
+        });
+    };
+    NearCacheImpl.prototype.invalidate = function (key) {
+        this.internalStore.delete(key);
+    };
+    NearCacheImpl.prototype.clear = function () {
+        this.internalStore.clear();
+    };
+    NearCacheImpl.prototype.isInvalidatedOnChange = function () {
+        return this.invalidateOnChange;
+    };
+    NearCacheImpl.prototype.getStatistics = function () {
+        var stats = {
+            creationTime: this.creationTime,
+            evictedCount: this.evictedCount,
+            expiredCount: this.expiredCount,
+            missCount: this.missCount,
+            hitCount: this.hitCount,
+            entryCount: this.internalStore.size,
+        };
+        return stats;
+    };
+    NearCacheImpl.prototype.isEvictionRequired = function () {
+        return this.evictionPolicy !== EvictionPolicy_1.EvictionPolicy.NONE && this.evictionMaxSize <= this.internalStore.size;
+    };
+    NearCacheImpl.prototype.doEvictionIfRequired = function () {
+        if (!this.isEvictionRequired()) {
+            return;
+        }
+        var internalSize = this.internalStore.size;
+        if (this.recomputeEvictionPool() > 0) {
+            return;
+        }
+        else {
+            this.evictRecord(this.evictionCandidatePool[0].key);
+            this.evictionCandidatePool = this.evictionCandidatePool.slice(1);
+        }
+    };
+    /**
+     * @returns number of expired elements.
+     */
+    NearCacheImpl.prototype.recomputeEvictionPool = function () {
+        var arr = Array.from(this.internalStore.values());
+        Util_1.shuffleArray(arr);
+        var newCandidates = arr.slice(0, this.evictionSamplingCount);
+        var cleanedNewCandidates = newCandidates.filter(this.filterExpiredRecord, this);
+        var expiredCount = newCandidates.length - cleanedNewCandidates.length;
+        if (expiredCount > 0) {
+            return expiredCount;
+        }
+        (_a = this.evictionCandidatePool).push.apply(_a, cleanedNewCandidates);
+        this.evictionCandidatePool.sort(this.compareFunc);
+        this.evictionCandidatePool = this.evictionCandidatePool.slice(0, this.evictionSamplingPoolSize);
+        return 0;
+        var _a;
+    };
+    NearCacheImpl.prototype.filterExpiredRecord = function (candidate) {
+        if (candidate.isExpired(this.maxIdleSeconds)) {
+            this.expireRecord(candidate.key);
+            return false;
+        }
+        else {
+            return true;
+        }
+    };
+    NearCacheImpl.prototype.expireRecord = function (key) {
+        if (this.internalStore.delete(key)) {
+            this.expiredCount++;
+        }
+    };
+    NearCacheImpl.prototype.evictRecord = function (key) {
+        if (this.internalStore.delete(key)) {
+            this.evictedCount++;
+        }
+    };
+    NearCacheImpl.prototype.initInvalidationMetadata = function (dr) {
+        if (this.staleReadDetector === AlwaysFreshStaleReadDetectorImpl.INSTANCE) {
+            return;
+        }
+        var partitionId = this.staleReadDetector.getPartitionId(dr.key);
+        var metadataContainer = this.staleReadDetector.getMetadataContainer(partitionId);
+        dr.setInvalidationSequence(metadataContainer.getSequence());
+        dr.setUuid(metadataContainer.getUuid());
+    };
+    return NearCacheImpl;
+}());
+exports.NearCacheImpl = NearCacheImpl;

package/lib/nearcache/NearCacheManager.d.ts

@@ -0,0 +1,13 @@
+import { NearCache } from './NearCache';
+import { SerializationService } from '../serialization/SerializationService';
+import HazelcastClient from '../HazelcastClient';
+export declare class NearCacheManager {
+    protected readonly serializationService: SerializationService;
+    private readonly caches;
+    private readonly client;
+    constructor(client: HazelcastClient);
+    getOrCreateNearCache(name: string): NearCache;
+    destroyNearCache(name: string): void;
+    destroyAllNearCaches(): void;
+    listAllNearCaches(): NearCache[];
+}

package/lib/nearcache/NearCacheManager.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 NearCache_1 = require("./NearCache");
+var NearCacheManager = /** @class */ (function () {
+    function NearCacheManager(client) {
+        this.caches = new Map();
+        this.client = client;
+    }
+    NearCacheManager.prototype.getOrCreateNearCache = function (name) {
+        var nearCache = this.caches.get(name);
+        if (nearCache == null) {
+            nearCache = new NearCache_1.NearCacheImpl(this.client.getConfig().getNearCacheConfig(name), this.client.getSerializationService());
+            this.caches.set(name, nearCache);
+        }
+        return nearCache;
+    };
+    NearCacheManager.prototype.destroyNearCache = function (name) {
+        var nearCache = this.caches.get(name);
+        if (nearCache != null) {
+            this.caches.delete(name);
+            nearCache.clear();
+        }
+    };
+    NearCacheManager.prototype.destroyAllNearCaches = function () {
+        for (var _i = 0, _a = Array.from(this.caches.keys()); _i < _a.length; _i++) {
+            var key = _a[_i];
+            this.destroyNearCache(key);
+        }
+    };
+    NearCacheManager.prototype.listAllNearCaches = function () {
+        return Array.from(this.caches.values());
+    };
+    return NearCacheManager;
+}());
+exports.NearCacheManager = NearCacheManager;

package/lib/nearcache/RepairingHandler.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="long" />
+import * as Long from 'long';
+import { UUID } from '../core/UUID';
+import { PartitionService } from '../PartitionService';
+import { Data } from '../serialization/Data';
+import { MetadataContainer } from './MetadataContainer';
+import { NearCache } from './NearCache';
+export declare class RepairingHandler {
+    private readonly nearCache;
+    private readonly partitionCount;
+    private readonly partitionService;
+    private readonly localUuid;
+    private readonly name;
+    private containers;
+    constructor(name: string, partitionService: PartitionService, nearCache: NearCache, localUuid: string);
+    initUuid(partitionIdUuidPairsList: Array<[number, UUID]>): void;
+    initSequence(partitionIdSequencePairsList: [string, Array<[number, Long]>]): void;
+    handle(key: Data, sourceUuid: string, partitionUuid: UUID, sequence: Long): void;
+    handleBatch(keys: any[], sourceUuids: string[], partitionUuids: UUID[], sequences: Long[]): void;
+    checkOrRepairSequence(partitionId: number, nextSequence: Long, viaAntiEntropy?: boolean): void;
+    checkOrRepairUuid(partitionId: number, newuuid: UUID): void;
+    updateLastKnownStaleSequence(metadataContainer: MetadataContainer): void;
+    getMetadataContainer(partitionId: number): MetadataContainer;
+    getName(): string;
+    private getPartitionIdOrDefault(key);
+}

package/lib/nearcache/RepairingHandler.js

@@ -0,0 +1,114 @@
+"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 MetadataContainer_1 = require("./MetadataContainer");
+var RepairingHandler = /** @class */ (function () {
+    function RepairingHandler(name, partitionService, nearCache, localUuid) {
+        this.nearCache = nearCache;
+        this.name = name;
+        this.partitionService = partitionService;
+        this.partitionCount = this.partitionService.getPartitionCount();
+        this.localUuid = localUuid;
+        this.containers = [];
+        for (var i = 0; i < this.partitionCount; i++) {
+            this.containers[i] = new MetadataContainer_1.MetadataContainer();
+        }
+    }
+    RepairingHandler.prototype.initUuid = function (partitionIdUuidPairsList) {
+        for (var _i = 0, partitionIdUuidPairsList_1 = partitionIdUuidPairsList; _i < partitionIdUuidPairsList_1.length; _i++) {
+            var item = partitionIdUuidPairsList_1[_i];
+            var partitionId = item[0];
+            var partitionUuid = item[1];
+            this.getMetadataContainer(partitionId).setUuid(partitionUuid);
+        }
+    };
+    RepairingHandler.prototype.initSequence = function (partitionIdSequencePairsList) {
+        var list = partitionIdSequencePairsList[1];
+        for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+            var item = list_1[_i];
+            var partitionId = item[0];
+            var partitionSequence = item[1];
+            this.getMetadataContainer(partitionId).setSequence(partitionSequence);
+        }
+    };
+    RepairingHandler.prototype.handle = function (key, sourceUuid, partitionUuid, sequence) {
+        if (this.localUuid !== sourceUuid) {
+            if (key == null) {
+                this.nearCache.clear();
+            }
+            else {
+                this.nearCache.invalidate(key);
+            }
+        }
+        var partitionId = this.getPartitionIdOrDefault(key);
+        this.checkOrRepairSequence(partitionId, sequence);
+        this.checkOrRepairUuid(partitionId, partitionUuid);
+    };
+    RepairingHandler.prototype.handleBatch = function (keys, sourceUuids, partitionUuids, sequences) {
+        for (var i = 0; i < keys.length; i++) {
+            this.handle(keys[i], sourceUuids[i], partitionUuids[i], sequences[i]);
+        }
+    };
+    RepairingHandler.prototype.checkOrRepairSequence = function (partitionId, nextSequence, viaAntiEntropy) {
+        if (viaAntiEntropy === void 0) { viaAntiEntropy = false; }
+        var metadata = this.getMetadataContainer(partitionId);
+        var current = metadata.getSequence();
+        if (current.greaterThanOrEqual(nextSequence)) {
+            return;
+        }
+        metadata.setSequence(nextSequence);
+        var missed = nextSequence.subtract(current);
+        if (!viaAntiEntropy) {
+            missed = missed.subtract(1);
+        }
+        if (missed.greaterThan(0)) {
+            metadata.increaseMissedSequenceCount(missed);
+        }
+    };
+    RepairingHandler.prototype.checkOrRepairUuid = function (partitionId, newuuid) {
+        var metadata = this.getMetadataContainer(partitionId);
+        var currentUuid = metadata.getUuid();
+        if (currentUuid != null && currentUuid.equals(newuuid)) {
+            return;
+        }
+        metadata.setUuid(newuuid);
+        metadata.reset();
+    };
+    RepairingHandler.prototype.updateLastKnownStaleSequence = function (metadataContainer) {
+        var lastStaleSequence = metadataContainer.getStaleSequence();
+        var lastSequence = metadataContainer.getSequence();
+        if (lastStaleSequence.lessThan(lastSequence)) {
+            metadataContainer.setStaleSequence(lastSequence);
+        }
+    };
+    RepairingHandler.prototype.getMetadataContainer = function (partitionId) {
+        return this.containers[partitionId];
+    };
+    RepairingHandler.prototype.getName = function () {
+        return this.name;
+    };
+    RepairingHandler.prototype.getPartitionIdOrDefault = function (key) {
+        if (key != null) {
+            return this.partitionService.getPartitionId(key);
+        }
+        else {
+            return this.partitionService.getPartitionId(this.name);
+        }
+    };
+    return RepairingHandler;
+}());
+exports.RepairingHandler = RepairingHandler;

package/lib/nearcache/RepairingTask.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="bluebird" />
+import HazelcastClient from '../HazelcastClient';
+import { NearCache } from './NearCache';
+import { RepairingHandler } from './RepairingHandler';
+import * as Promise from 'bluebird';
+export declare class RepairingTask {
+    private antientropyTaskHandle;
+    private handlers;
+    private reconcilliationInterval;
+    private maxToleratedMissCount;
+    private localUuid;
+    private metadataFetcher;
+    private client;
+    private partitionCount;
+    private readonly minAllowedReconciliationSeconds;
+    private readonly logger;
+    constructor(client: HazelcastClient);
+    registerAndGetHandler(objectName: string, nearCache: NearCache): Promise<RepairingHandler>;
+    deregisterHandler(objectName: string): void;
+    start(): void;
+    shutdown(): void;
+    antiEntropyTask(): void;
+    private isAboveMaxToleratedMissCount(handler);
+    private updateLastKnownStaleSequences(handler);
+    private getReconciliationIntervalMillis(seconds);
+}

package/lib/nearcache/RepairingTask.js

@@ -0,0 +1,117 @@
+"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 Long = require("long");
+var MetadataFetcher_1 = require("./MetadataFetcher");
+var RepairingHandler_1 = require("./RepairingHandler");
+var Promise = require("bluebird");
+var PROPERTY_MAX_RECONCILIATION_INTERVAL_SECONDS = 'hazelcast.invalidation.reconciliation.interval.seconds';
+var PROPERTY_MIN_RECONCILIATION_INTERVAL_SECONDS = 'hazelcast.invalidation.min.reconciliation.interval.seconds';
+var PROPERTY_MAX_TOLERATED_MISS_COUNT = 'hazelcast.invalidation.max.tolerated.miss.count';
+var RepairingTask = /** @class */ (function () {
+    function RepairingTask(client) {
+        this.client = client;
+        this.logger = this.client.getLoggingService().getLogger();
+        var config = this.client.getConfig();
+        this.minAllowedReconciliationSeconds = config.properties[PROPERTY_MIN_RECONCILIATION_INTERVAL_SECONDS];
+        var requestedReconciliationSeconds = config.properties[PROPERTY_MAX_RECONCILIATION_INTERVAL_SECONDS];
+        this.reconcilliationInterval = this.getReconciliationIntervalMillis(requestedReconciliationSeconds);
+        this.handlers = new Map();
+        this.localUuid = this.client.getLocalEndpoint().uuid;
+        this.maxToleratedMissCount = config.properties[PROPERTY_MAX_TOLERATED_MISS_COUNT];
+        this.metadataFetcher = new MetadataFetcher_1.MetadataFetcher(client);
+        this.partitionCount = this.client.getPartitionService().getPartitionCount();
+    }
+    RepairingTask.prototype.registerAndGetHandler = function (objectName, nearCache) {
+        var _this = this;
+        var handler = this.handlers.get(objectName);
+        if (handler !== undefined) {
+            return Promise.resolve(handler);
+        }
+        handler = new RepairingHandler_1.RepairingHandler(objectName, this.client.getPartitionService(), nearCache, this.localUuid);
+        return this.metadataFetcher.initHandler(handler).then(function () {
+            _this.handlers.set(objectName, handler);
+            if (_this.antientropyTaskHandle === undefined) {
+                _this.start();
+            }
+            return handler;
+        });
+    };
+    RepairingTask.prototype.deregisterHandler = function (objectName) {
+        this.handlers.delete(objectName);
+    };
+    RepairingTask.prototype.start = function () {
+        assert(this.reconcilliationInterval > 0);
+        this.antientropyTaskHandle = setInterval(this.antiEntropyTask.bind(this), this.reconcilliationInterval);
+    };
+    RepairingTask.prototype.shutdown = function () {
+        if (this.antientropyTaskHandle != null) {
+            clearInterval(this.antientropyTaskHandle);
+        }
+    };
+    RepairingTask.prototype.antiEntropyTask = function () {
+        var _this = this;
+        if (this.client.getLifecycleService().isRunning()) {
+            this.handlers.forEach(function (handler) {
+                if (_this.isAboveMaxToleratedMissCount(handler)) {
+                    _this.updateLastKnownStaleSequences(handler);
+                }
+            });
+            this.metadataFetcher.fetchMetadata(this.handlers);
+        }
+        else {
+            this.shutdown();
+            this.logger.debug('RepairingTask', 'Anti entropy task was on although client was not running.' +
+                'Anti entropy task was shutdown forcibly.');
+        }
+    };
+    RepairingTask.prototype.isAboveMaxToleratedMissCount = function (handler) {
+        var totalMissCount = Long.fromNumber(0);
+        for (var i = 0; i < this.partitionCount; i++) {
+            var added = handler.getMetadataContainer(i).getMissedSequenceCount();
+            totalMissCount = totalMissCount.add(added);
+            if (totalMissCount.greaterThanOrEqual(this.maxToleratedMissCount)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    RepairingTask.prototype.updateLastKnownStaleSequences = function (handler) {
+        for (var i = 0; i < this.partitionCount; i++) {
+            var container = handler.getMetadataContainer(i);
+            var missedCount = container.getMissedSequenceCount();
+            if (missedCount.notEquals(0)) {
+                container.increaseMissedSequenceCount(missedCount.negate());
+                handler.updateLastKnownStaleSequence(container);
+            }
+        }
+    };
+    RepairingTask.prototype.getReconciliationIntervalMillis = function (seconds) {
+        if (seconds === 0 || seconds >= this.minAllowedReconciliationSeconds) {
+            return seconds * 1000;
+        }
+        else {
+            var message = 'Reconciliation interval can be at least ' + this.minAllowedReconciliationSeconds + ' seconds ' +
+                'if not 0. Configured interval is ' + seconds + ' seconds. ' +
+                'Note: configuring a value of 0 seconds disables the reconciliation task.';
+            throw new RangeError(message);
+        }
+    };
+    return RepairingTask;
+}());
+exports.RepairingTask = RepairingTask;

package/lib/nearcache/StaleReadDetector.d.ts

@@ -0,0 +1,7 @@
+import { DataRecord } from './DataRecord';
+import { MetadataContainer } from './MetadataContainer';
+export interface StaleReadDetector {
+    isStaleRead(key: any, record: DataRecord): boolean;
+    getPartitionId(key: any): number;
+    getMetadataContainer(partitionId: number): MetadataContainer;
+}

package/lib/nearcache/StaleReadDetector.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/nearcache/StaleReadDetectorImpl.d.ts

@@ -0,0 +1,13 @@
+import { PartitionService } from '../PartitionService';
+import { DataRecord } from './DataRecord';
+import { MetadataContainer } from './MetadataContainer';
+import { RepairingHandler } from './RepairingHandler';
+import { StaleReadDetector } from './StaleReadDetector';
+export declare class StaleReadDetectorImpl implements StaleReadDetector {
+    private readonly repairingHandler;
+    private readonly partitionService;
+    constructor(handler: RepairingHandler, partitionService: PartitionService);
+    isStaleRead(key: any, record: DataRecord): boolean;
+    getMetadataContainer(partitionId: number): MetadataContainer;
+    getPartitionId(key: any): number;
+}

package/lib/nearcache/StaleReadDetectorImpl.js

@@ -0,0 +1,35 @@
+"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 StaleReadDetectorImpl = /** @class */ (function () {
+    function StaleReadDetectorImpl(handler, partitionService) {
+        this.repairingHandler = handler;
+        this.partitionService = partitionService;
+    }
+    StaleReadDetectorImpl.prototype.isStaleRead = function (key, record) {
+        var metadata = this.getMetadataContainer(this.getPartitionId(record.key));
+        return !record.hasSameUuid(metadata.getUuid()) || record.getInvalidationSequence().lessThan(metadata.getStaleSequence());
+    };
+    StaleReadDetectorImpl.prototype.getMetadataContainer = function (partitionId) {
+        return this.repairingHandler.getMetadataContainer(partitionId);
+    };
+    StaleReadDetectorImpl.prototype.getPartitionId = function (key) {
+        return this.partitionService.getPartitionId(key);
+    };
+    return StaleReadDetectorImpl;
+}());
+exports.StaleReadDetectorImpl = StaleReadDetectorImpl;