@celerispay/hazelcast-client 3.12.5-1

package/lib/invocation/RegistrationKey.d.ts

@@ -0,0 +1,16 @@
+import ClientMessage = require('../ClientMessage');
+import { ListenerMessageCodec } from '../ListenerMessageCodec';
+export declare class RegistrationKey {
+    private readonly userRegistrationId;
+    private registerHandlerFunc;
+    private registerRequest;
+    private codec;
+    constructor(regId: string, codec: ListenerMessageCodec, registerRequest?: ClientMessage, registerHandlerFunc?: Function);
+    getRegisterRequest(): ClientMessage;
+    setRegisterRequest(registerRequest: ClientMessage): void;
+    getCodec(): ListenerMessageCodec;
+    setCodec(value: ListenerMessageCodec): void;
+    getHandler(): Function;
+    setHandler(handler: Function): void;
+    getUserRegistrationKey(): string;
+}

package/lib/invocation/RegistrationKey.js

@@ -0,0 +1,48 @@
+"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 RegistrationKey = /** @class */ (function () {
+    function RegistrationKey(regId, codec, registerRequest, registerHandlerFunc) {
+        this.userRegistrationId = regId;
+        this.registerHandlerFunc = registerHandlerFunc;
+        this.registerRequest = registerRequest;
+        this.codec = codec;
+    }
+    RegistrationKey.prototype.getRegisterRequest = function () {
+        return this.registerRequest;
+    };
+    RegistrationKey.prototype.setRegisterRequest = function (registerRequest) {
+        this.registerRequest = registerRequest;
+    };
+    RegistrationKey.prototype.getCodec = function () {
+        return this.codec;
+    };
+    RegistrationKey.prototype.setCodec = function (value) {
+        this.codec = value;
+    };
+    RegistrationKey.prototype.getHandler = function () {
+        return this.registerHandlerFunc;
+    };
+    RegistrationKey.prototype.setHandler = function (handler) {
+        this.registerHandlerFunc = handler;
+    };
+    RegistrationKey.prototype.getUserRegistrationKey = function () {
+        return this.userRegistrationId;
+    };
+    return RegistrationKey;
+}());
+exports.RegistrationKey = RegistrationKey;

package/lib/logging/DefaultLogger.d.ts

@@ -0,0 +1,12 @@
+import { LogLevel } from './LoggingService';
+import { ILogger } from './ILogger';
+export declare class DefaultLogger implements ILogger {
+    private readonly level;
+    constructor(level: number);
+    log(level: LogLevel, objectName: string, message: string, furtherInfo: any): void;
+    error(objectName: string, message: string, furtherInfo?: any): void;
+    warn(objectName: string, message: string, furtherInfo?: any): void;
+    info(objectName: string, message: string, furtherInfo?: any): void;
+    debug(objectName: string, message: string, furtherInfo?: any): void;
+    trace(objectName: string, message: string, furtherInfo?: any): void;
+}

package/lib/logging/DefaultLogger.js

@@ -0,0 +1,48 @@
+"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 LoggingService_1 = require("./LoggingService");
+var DefaultLogger = /** @class */ (function () {
+    function DefaultLogger(level) {
+        this.level = level;
+    }
+    DefaultLogger.prototype.log = function (level, objectName, message, furtherInfo) {
+        if (level <= this.level) {
+            console.log('[DefaultLogger] %s at %s: %s', LoggingService_1.LogLevel[level], objectName, message);
+            if (furtherInfo != null) {
+                console.log(furtherInfo);
+            }
+        }
+    };
+    DefaultLogger.prototype.error = function (objectName, message, furtherInfo) {
+        this.log(LoggingService_1.LogLevel.ERROR, objectName, message, furtherInfo);
+    };
+    DefaultLogger.prototype.warn = function (objectName, message, furtherInfo) {
+        this.log(LoggingService_1.LogLevel.WARN, objectName, message, furtherInfo);
+    };
+    DefaultLogger.prototype.info = function (objectName, message, furtherInfo) {
+        this.log(LoggingService_1.LogLevel.INFO, objectName, message, furtherInfo);
+    };
+    DefaultLogger.prototype.debug = function (objectName, message, furtherInfo) {
+        this.log(LoggingService_1.LogLevel.DEBUG, objectName, message, furtherInfo);
+    };
+    DefaultLogger.prototype.trace = function (objectName, message, furtherInfo) {
+        this.log(LoggingService_1.LogLevel.TRACE, objectName, message, furtherInfo);
+    };
+    return DefaultLogger;
+}());
+exports.DefaultLogger = DefaultLogger;

package/lib/logging/ILogger.d.ts

@@ -0,0 +1,49 @@
+import { LogLevel } from './LoggingService';
+/**
+ * The Hazelcast logging interface.
+ */
+export interface ILogger {
+    /**
+     * Logs a message with an associated objectName and furtherInfo at the given level.
+     * @param level the log level
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
+     */
+    log(level: LogLevel, objectName: string, message: string, furtherInfo: any): void;
+    /**
+     * Logs a message with an associated objectName and furtherInfo at the error level.
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
+     */
+    error(objectName: string, message: string, furtherInfo?: any): void;
+    /**
+     * Logs a message with an associated objectName and furtherInfo at the warn level.
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
+     */
+    warn(objectName: string, message: string, furtherInfo?: any): void;
+    /**
+     * Logs a message with an associated objectName and furtherInfo at the info level.
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
+     */
+    info(objectName: string, message: string, furtherInfo?: any): void;
+    /**
+     * Logs a message with an associated objectName and furtherInfo at the debug level.
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
+     */
+    debug(objectName: string, message: string, furtherInfo?: any): void;
+    /**
+     * Logs a message with an associated objectName and furtherInfo at the trace level.
+     * @param objectName name of the object in which the message is logged
+     * @param message the message to log
+     * @param furtherInfo further info about the log
+     */
+    trace(objectName: string, message: string, furtherInfo?: any): void;
+}

package/lib/logging/ILogger.js

@@ -0,0 +1,17 @@
+"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 });

package/lib/logging/LoggingService.d.ts

@@ -0,0 +1,16 @@
+import { Property } from '../config/Properties';
+import { ILogger } from './ILogger';
+export declare enum LogLevel {
+    OFF = -1,
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3,
+    TRACE = 4,
+}
+export declare class LoggingService {
+    private readonly logger;
+    constructor(customLogger: ILogger, logLevel: number);
+    isLogger(loggingProperty: Property): loggingProperty is ILogger;
+    getLogger(): ILogger;
+}

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;