hazelcast-client/lib/proxy/ProxyManager.js

Hazelcast - open source In-Memory Data Grid - client for NodeJS

"use strict";
var MapProxy_1 = require("./MapProxy");
var SetProxy_1 = require("./SetProxy");
var ClientCreateProxyCodec_1 = require("../codec/ClientCreateProxyCodec");
var ClientDestroyProxyCodec_1 = require("../codec/ClientDestroyProxyCodec");
var ClientAddDistributedObjectListenerCodec_1 = require("../codec/ClientAddDistributedObjectListenerCodec");
var ClientRemoveDistributedObjectListenerCodec_1 = require("../codec/ClientRemoveDistributedObjectListenerCodec");
var QueueProxy_1 = require("./QueueProxy");
var ListProxy_1 = require("./ListProxy");
var LockProxy_1 = require("./LockProxy");
var MultiMapProxy_1 = require("./MultiMapProxy");
var RingbufferProxy_1 = require("./RingbufferProxy");
var ReplicatedMapProxy_1 = require("./ReplicatedMapProxy");
var NearCachedMapProxy_1 = require("./NearCachedMapProxy");
var SemaphoreProxy_1 = require("./SemaphoreProxy");
var AtomicLongProxy_1 = require("./AtomicLongProxy");
var ProxyManager = (function () {
    function ProxyManager(client) {
        this.MAP_SERVICE = 'hz:impl:mapService';
        this.SET_SERVICE = 'hz:impl:setService';
        this.LOCK_SERVICE = 'hz:impl:lockService';
        this.QUEUE_SERVICE = 'hz:impl:queueService';
        this.LIST_SERVICE = 'hz:impl:listService';
        this.MULTIMAP_SERVICE = 'hz:impl:multiMapService';
        this.RINGBUFFER_SERVICE = 'hz:impl:ringbufferService';
        this.REPLICATEDMAP_SERVICE = 'hz:impl:replicatedMapService';
        this.SEMAPHORE_SERVICE = 'hz:impl:semaphoreService';
        this.ATOMICLONG_SERVICE = 'hz:impl:atomicLongService';
        this.service = {
            'hz:impl:mapService': MapProxy_1.MapProxy,
            'hz:impl:setService': SetProxy_1.SetProxy,
            'hz:impl:queueService': QueueProxy_1.QueueProxy,
            'hz:impl:listService': ListProxy_1.ListProxy,
            'hz:impl:lockService': LockProxy_1.LockProxy,
            'hz:impl:multiMapService': MultiMapProxy_1.MultiMapProxy,
            'hz:impl:ringbufferService': RingbufferProxy_1.RingbufferProxy,
            'hz:impl:replicatedMapService': ReplicatedMapProxy_1.ReplicatedMapProxy,
            'hz:impl:semaphoreService': SemaphoreProxy_1.SemaphoreProxy,
            'hz:impl:atomicLongService': AtomicLongProxy_1.AtomicLongProxy
        };
        this.proxies = {};
        this.client = client;
    }
    ProxyManager.prototype.getOrCreateProxy = function (name, serviceName, createAtServer) {
        if (createAtServer === void 0) { createAtServer = true; }
        if (this.proxies[name]) {
            return this.proxies[name];
        }
        else {
            var newProxy;
            if (serviceName === this.MAP_SERVICE && this.client.getConfig().nearCacheConfigs[name]) {
                newProxy = new NearCachedMapProxy_1.NearCachedMapProxy(this.client, serviceName, name);
            }
            else {
                newProxy = new this.service[serviceName](this.client, serviceName, name);
            }
            if (createAtServer) {
                this.createProxy(name, serviceName);
            }
            this.proxies[name] = newProxy;
            return newProxy;
        }
    };
    ProxyManager.prototype.createProxy = function (name, serviceName) {
        var connection = this.client.getClusterService().getOwnerConnection();
        var request = ClientCreateProxyCodec_1.ClientCreateProxyCodec.encodeRequest(name, serviceName, connection.getAddress());
        var createProxyPromise = this.client.getInvocationService()
            .invokeOnConnection(connection, request);
        return createProxyPromise;
    };
    ProxyManager.prototype.destroyProxy = function (name, serviceName) {
        delete this.proxies[name];
        var clientMessage = ClientDestroyProxyCodec_1.ClientDestroyProxyCodec.encodeRequest(name, serviceName);
        clientMessage.setPartitionId(-1);
        return this.client.getInvocationService().invokeOnRandomTarget(clientMessage).then(function () {
            return;
        });
    };
    ProxyManager.prototype.addDistributedObjectListener = function (listenerFunc) {
        var handler = function (clientMessage) {
            var converterFunc = function (name, serviceName, eventType) {
                if (eventType === 'CREATED') {
                    listenerFunc(name, serviceName, 'created');
                }
                else if (eventType === 'DESTROYED') {
                    listenerFunc(name, serviceName, 'destroyed');
                }
            };
            ClientAddDistributedObjectListenerCodec_1.ClientAddDistributedObjectListenerCodec.handle(clientMessage, converterFunc, null);
        };
        return this.client.getListenerService().registerListener(ClientAddDistributedObjectListenerCodec_1.ClientAddDistributedObjectListenerCodec.encodeRequest(true), handler, ClientAddDistributedObjectListenerCodec_1.ClientAddDistributedObjectListenerCodec.decodeResponse);
    };
    ProxyManager.prototype.removeDistributedObjectListener = function (listenerId) {
        return this.client.getListenerService().deregisterListener(ClientRemoveDistributedObjectListenerCodec_1.ClientRemoveDistributedObjectListenerCodec.encodeRequest(listenerId), ClientRemoveDistributedObjectListenerCodec_1.ClientRemoveDistributedObjectListenerCodec.decodeResponse);
    };
    return ProxyManager;
}());
module.exports = ProxyManager;
//# sourceMappingURL=ProxyManager.js.map