decouple Promises from q

Author: mustafaiman

src/DistributedObject.ts

@@ -1,4 +1,4 @@
-import Promise = Q.Promise;
+import {Promise} from 'es6-promise';
 export interface DistributedObject {
     /*
      * Returns the key of the partition that this DistributedObject is assigned to.

src/HazelcastClient.ts

@@ -3,7 +3,6 @@ import {InvocationService, ListenerService} from './invocation/InvocationService
 import ClientConnectionManager = require('./invocation/ClientConnectionManager');
 import {ClientConfig} from './Config';
 import ProxyManager = require('./proxy/ProxyManager');
-import Q = require('q');
 import {IMap} from './IMap';
 import {JsonSerializationService} from './serialization/SerializationService';
 import PartitionService = require('./PartitionService');
@@ -13,9 +12,10 @@ import {LoggingService} from './LoggingService';
 import {LifecycleService, LifecycleEvent} from './LifecycleService';
 import {ClientGetDistributedObjectsCodec} from './codec/ClientGetDistributedObjectsCodec';
 import {DistributedObject} from './DistributedObject';
-import defer = Q.defer;
 import {ClientInfo} from './ClientInfo';
 import ClientMessage = require('./ClientMessage');
+import {Promise} from 'es6-promise';
+import {defer} from 'q';
 
 export default class HazelcastClient {
 
@@ -31,7 +31,7 @@ export default class HazelcastClient {
     private proxyManager: ProxyManager;
     private heartbeat: Heartbeat;
 
-    public static newHazelcastClient(config?: ClientConfig): Q.Promise<HazelcastClient> {
+    public static newHazelcastClient(config?: ClientConfig): Promise<HazelcastClient> {
         var client: HazelcastClient = new HazelcastClient(config);
         return client.init();
     }
@@ -54,8 +54,8 @@ export default class HazelcastClient {
         this.heartbeat = new Heartbeat(this);
     }
 
-    private init(): Q.Promise<HazelcastClient> {
-        var deferred = Q.defer<HazelcastClient>();
+    private init(): Promise<HazelcastClient> {
+        var deferred = defer<HazelcastClient>();
         this.clusterService.start()
             .then(() => {
                 return this.partitionService.initialize();
@@ -79,8 +79,8 @@ export default class HazelcastClient {
         return this.clusterService.getClientInfo();
     }
 
-    getDistributedObjects(): Q.Promise<DistributedObject[]> {
-        var deferred = Q.defer<DistributedObject[]>();
+    getDistributedObjects(): Promise<DistributedObject[]> {
+        var deferred = defer<DistributedObject[]>();
         var clientMessage = ClientGetDistributedObjectsCodec.encodeRequest();
         var toObjectFunc = this.serializationService.toObject.bind(this);
         var proxyManager = this.proxyManager;
@@ -136,11 +136,11 @@ export default class HazelcastClient {
         return this.heartbeat;
     }
 
-    addDistributedObjectListener(listenerFunc: Function): Q.Promise<string> {
+    addDistributedObjectListener(listenerFunc: Function): Promise<string> {
         return this.proxyManager.addDistributedObjectListener(listenerFunc);
     }
 
-    removeDistributedObjectListener(listenerId: string): Q.Promise<boolean> {
+    removeDistributedObjectListener(listenerId: string): Promise<boolean> {
         return this.proxyManager.removeDistributedObjectListener(listenerId);
     }
 

src/IMap.ts

@@ -1,5 +1,5 @@
-import Promise = Q.Promise;
 import {DistributedObject} from './DistributedObject';
+import {Promise} from 'es6-promise';
 export interface IMap<K, V> extends DistributedObject {
 
     /**

src/ISet.ts

@@ -1,4 +1,4 @@
-import Promise = Q.Promise;
+import {Promise} from 'es6-promise';
 import {DistributedObject} from './DistributedObject';
 export interface ISet<E> extends DistributedObject {
     /**

src/PartitionService.ts

@@ -1,4 +1,5 @@
-import Q = require('q');
+import * as Q from 'q';
+import {Promise} from 'es6-promise';
 import GetPartitionsCodec = require('./codec/GetPartitionsCodec');
 import ClientMessage = require('./ClientMessage');
 import Address = require('./Address');
@@ -14,7 +15,7 @@ class PartitionService {
         this.client = client;
     }
 
-    initialize(): Q.Promise<PartitionService> {
+    initialize(): Promise<PartitionService> {
         var deferred = Q.defer<PartitionService>();
         this.refresh().then(() => {
             deferred.resolve(this);
@@ -23,7 +24,7 @@ class PartitionService {
         return deferred.promise;
     }
 
-    refresh(): Q.Promise<void> {
+    refresh(): Promise<void> {
         var ownerConnection = this.client.getClusterService().getOwnerConnection();
         var clientMessage: ClientMessage = GetPartitionsCodec.encodeRequest();
 

src/invocation/ClientConnection.ts

@@ -1,5 +1,6 @@
 import net = require('net');
-import Q = require('q');
+import * as Q from 'q';
+import {Promise} from 'es6-promise';
 import Address = require('../Address');
 import {BitsUtil} from '../BitsUtil';
 import {LoggingService} from '../LoggingService';
@@ -27,7 +28,7 @@ class ClientConnection {
         return this.address;
     }
 
-    connect(): Q.Promise<ClientConnection> {
+    connect(): Promise<ClientConnection> {
         var ready = Q.defer<ClientConnection>();
 
         this.socket = net.connect(this.address.port, this.address.host, () => {
@@ -48,7 +49,7 @@ class ClientConnection {
         return ready.promise;
     }
 
-    write(buffer: Buffer): Q.Promise<void> {
+    write(buffer: Buffer): Promise<void> {
         var deferred = Q.defer<void>();
         this.socket.write(buffer, 'utf8', (e: any) => {
             if (e === undefined) {

src/invocation/ClientConnectionManager.ts

@@ -1,4 +1,5 @@
-import Q = require('q');
+import * as Q from 'q';
+import {Promise} from 'es6-promise';
 
 import Address = require('../Address');
 import ClientConnection = require('./ClientConnection');
@@ -26,7 +27,7 @@ class ClientConnectionManager extends EventEmitter {
         this.client = client;
     }
 
-    getOrConnect(address: Address, ownerConnection: boolean = false): Q.Promise<ClientConnection> {
+    getOrConnect(address: Address, ownerConnection: boolean = false): Promise<ClientConnection> {
         var addressIndex = Address.encodeToString(address);
         var result: Q.Deferred<ClientConnection> = Q.defer<ClientConnection>();
 
@@ -62,9 +63,9 @@ class ClientConnectionManager extends EventEmitter {
         }).then(() => {
             this.onConnectionOpened(clientConnection);
             result.resolve(clientConnection);
+            delete this.pendingConnections[addressIndex];
         }).catch((e: any) => {
             result.reject(e);
-        }).finally(() => {
             delete this.pendingConnections[addressIndex];
         });
         return result.promise;
@@ -91,7 +92,7 @@ class ClientConnectionManager extends EventEmitter {
         this.emit(EMIT_CONNECTION_OPENED, connection);
     }
 
-    private authenticate(connection: ClientConnection, ownerConnection: boolean): Q.Promise<boolean> {
+    private authenticate(connection: ClientConnection, ownerConnection: boolean): Promise<boolean> {
         var authenticator = new ConnectionAuthenticator(connection, this.client);
 
         return authenticator.authenticate(ownerConnection);

src/invocation/ClusterService.ts

@@ -1,13 +1,14 @@
 import ClientConnection = require('./ClientConnection');
 import Address = require('../Address');
-import Q = require('q');
 import {ClientAddMembershipListenerCodec} from '../codec/ClientAddMembershipListenerCodec';
 import ClientMessage = require('../ClientMessage');
 import {Member} from '../Member';
 import {LoggingService} from '../LoggingService';
 import {EventEmitter} from 'events';
 import {ClientInfo} from '../ClientInfo';
 import HazelcastClient from '../HazelcastClient';
+import {Promise} from 'es6-promise';
+import * as Q from 'q';
 
 const MEMBER_ADDED = 1;
 const MEMBER_REMOVED = 2;
@@ -41,13 +42,13 @@ class ClusterService extends EventEmitter {
         this.members = [];
     }
 
-    start(): Q.Promise<void> {
+    start(): Promise<void> {
         this.initHeartbeatListener();
         this.initConnectionListener();
         return this.connectToCluster();
     }
 
-    connectToCluster(): Q.Promise<void> {
+    connectToCluster(): Promise<void> {
         if (this.members.length > 0) {
             this.knownAddresses = new Array<Address>();
             this.members.forEach((member: Member) => {
@@ -138,7 +139,7 @@ class ClusterService extends EventEmitter {
         return this.ownerConnection;
     }
 
-    initMemberShipListener(): Q.Promise<void> {
+    initMemberShipListener(): Promise<void> {
         var deferred = Q.defer<void>();
         var request = ClientAddMembershipListenerCodec.encodeRequest(false);
 

src/invocation/ConnectionAuthenticator.ts

@@ -1,10 +1,10 @@
-import Q = require('q');
-
 import ClientConnection = require('./ClientConnection');
 import {InvocationService} from './InvocationService';
 import ClientMessage = require('../ClientMessage');
 import {ClientAuthenticationCodec} from '../codec/ClientAuthenticationCodec';
 import HazelcastClient from '../HazelcastClient';
+import {Promise} from 'es6-promise';
+import * as Q from 'q';
 
 class ConnectionAuthenticator {
 
@@ -16,7 +16,7 @@ class ConnectionAuthenticator {
         this.client = client;
     }
 
-    authenticate(ownerConnection: boolean): Q.Promise<boolean> {
+    authenticate(ownerConnection: boolean): Promise<boolean> {
         var groupConfig = this.client.getConfig().groupConfig;
         var clusterService = this.client.getClusterService();
         var uuid: string = clusterService.uuid;

src/invocation/InvocationService.ts

@@ -1,6 +1,5 @@
 import ClientConnection = require('./ClientConnection');
 import ClientMessage = require('../ClientMessage');
-import Q = require('q');
 import Long = require('long');
 import {Data} from '../serialization/Data';
 import Address = require('../Address');
@@ -9,6 +8,8 @@ import {BitsUtil} from '../BitsUtil';
 import {LoggingService} from '../LoggingService';
 import {EventEmitter} from 'events';
 import HazelcastClient from '../HazelcastClient';
+import {Promise} from 'es6-promise';
+import * as Q from 'q';
 
 var EXCEPTION_MESSAGE_TYPE = 109;
 var INVOCATION_TIMEOUT = 120000;
@@ -38,7 +39,7 @@ export class InvocationService {
     private smartRoutingEnabled: boolean;
     private logger = LoggingService.getLoggingService();
 
-    invoke: (invocation: Invocation) => Q.Promise<ClientMessage>;
+    invoke: (invocation: Invocation) => Promise<ClientMessage>;
 
     constructor(hazelcastClient: HazelcastClient) {
         this.client = hazelcastClient;
@@ -51,7 +52,7 @@ export class InvocationService {
     }
 
     invokeOnConnection(connection: ClientConnection, request: ClientMessage,
-                       handler?: (...args: any[]) => any): Q.Promise<ClientMessage> {
+                       handler?: (...args: any[]) => any): Promise<ClientMessage> {
         var invocation = new Invocation(request);
         invocation.connection = connection;
         if (handler) {
@@ -60,19 +61,19 @@ export class InvocationService {
         return this.invoke(invocation);
     }
 
-    invokeOnPartition(request: ClientMessage, partitionId: number): Q.Promise<ClientMessage> {
+    invokeOnPartition(request: ClientMessage, partitionId: number): Promise<ClientMessage> {
         var invocation = new Invocation(request);
         invocation.partitionId = partitionId;
         return this.invoke(invocation);
     }
 
-    invokeOnTarget(request: ClientMessage, target: Address): Q.Promise<ClientMessage> {
+    invokeOnTarget(request: ClientMessage, target: Address): Promise<ClientMessage> {
         var invocation = new Invocation(request);
         invocation.address = target;
         return this.invoke(invocation);
     }
 
-    invokeOnRandomTarget(request: ClientMessage): Q.Promise<ClientMessage> {
+    invokeOnRandomTarget(request: ClientMessage): Promise<ClientMessage> {
         return this.invoke(new Invocation(request));
     }
 
@@ -97,14 +98,14 @@ export class InvocationService {
         }
     }
 
-    private sendToAddress(invocation: Invocation, addres: Address): Q.Promise<ClientMessage> {
+    private sendToAddress(invocation: Invocation, addres: Address): Promise<ClientMessage> {
         return this.client.getConnectionManager().getOrConnect(addres)
             .then<ClientMessage>((connection: ClientConnection) => {
                 return this.send(invocation, connection);
             });
     }
 
-    private send(invocation: Invocation, connection: ClientConnection): Q.Promise<ClientMessage> {
+    private send(invocation: Invocation, connection: ClientConnection): Promise<ClientMessage> {
         var correlationId = this.correlationCounter++;
         var message = invocation.request;
         message.setCorrelationId(Long.fromNumber(correlationId));
@@ -181,7 +182,7 @@ export class ListenerService {
         this.internalEventEmitter.setMaxListeners(0);
     }
 
-    registerListener(codec: any, handler: any): Q.Promise<string> {
+    registerListener(codec: any, handler: any): Promise<string> {
         var deferred = Q.defer<string>();
         var invocation = new Invocation(codec.encodeRequest(true));
         invocation.handler = handler;
@@ -194,7 +195,7 @@ export class ListenerService {
         return deferred.promise;
     }
 
-    deregisterListener(codec: any, listenerId: string): Q.Promise<boolean> {
+    deregisterListener(codec: any, listenerId: string): Promise<boolean> {
         var deferred = Q.defer<boolean>();
         var invocation = new Invocation(codec.encodeRequest(listenerId));
         var listenerIdToCorrelation = this.listenerIdToCorrelation;

src/proxy/BaseProxy.ts

@@ -1,8 +1,9 @@
 import {SerializationService} from '../serialization/SerializationService';
 import {Data} from '../serialization/Data';
 import ClientMessage = require('../ClientMessage');
-import Q = require('q');
 import HazelcastClient from '../HazelcastClient';
+import * as Q from 'q';
+import {Promise} from 'es6-promise';
 
 export class BaseProxy {
 
@@ -16,7 +17,7 @@ export class BaseProxy {
         this.serviceName = serviceName;
     }
 
-    private createPromise<T>(codec: any, promise: Q.Promise<ClientMessage>): Q.Promise<T> {
+    private createPromise<T>(codec: any, promise: Promise<ClientMessage>): Promise<T> {
         var deferred: Q.Deferred<T> = Q.defer<T>();
         var toObject = this.toObject.bind(this);
         promise.then(function(clientMessage: ClientMessage) {
@@ -32,20 +33,20 @@ export class BaseProxy {
         return deferred.promise;
     }
 
-    protected encodeInvokeOnKey<T>(codec: any, partitionKey: any, ...codecArguments: any[]): Q.Promise<T> {
+    protected encodeInvokeOnKey<T>(codec: any, partitionKey: any, ...codecArguments: any[]): Promise<T> {
         var partitionId: number = this.client.getPartitionService().getPartitionId(partitionKey);
         return this.encodeInvokeOnPartition<T>(codec, partitionId, ...codecArguments);
     }
 
-    protected encodeInvokeOnRandomTarget<T>(codec: any, ...codecArguments: any[]): Q.Promise<T> {
+    protected encodeInvokeOnRandomTarget<T>(codec: any, ...codecArguments: any[]): Promise<T> {
         var clientMessage = codec.encodeRequest(this.name, ...codecArguments);
         var invocationResponse = this.client.getInvocationService().invokeOnRandomTarget(clientMessage);
         return this.createPromise<T>(codec, invocationResponse);
     }
 
-    protected encodeInvokeOnPartition<T>(codec: any, partitionId: number, ...codecArguments: any[]): Q.Promise<T> {
+    protected encodeInvokeOnPartition<T>(codec: any, partitionId: number, ...codecArguments: any[]): Promise<T> {
         var clientMessage = codec.encodeRequest(this.name, ...codecArguments);
-        var invocationResponse: Q.Promise<ClientMessage> = this.client.getInvocationService()
+        var invocationResponse: Promise<ClientMessage> = this.client.getInvocationService()
             .invokeOnPartition(clientMessage, partitionId);
 
         return this.createPromise<T>(codec, invocationResponse);
@@ -72,7 +73,7 @@ export class BaseProxy {
         return this.serviceName;
     }
 
-    public destroy() : Q.Promise<void> {
+    public destroy() : Promise<void> {
         return this.client.getProxyManager().destroyProxy(this.name, this.serviceName);
     }
 }