move Defer to new file to break circular dependency

Signed-off-by: jackyalbo <jacky.albo@gmail.com>

Author: jackyalbo

src/rpc/ice.js

@@ -6,6 +6,7 @@ module.exports = Ice;
 
 const _ = require('lodash');
 const P = require('../util/promise');
+const Defer = require('../util/defer');
 const os = require('os');
 const net = require('net');
 const tls = require('tls');
@@ -1341,7 +1342,7 @@ function IceSession(local, remote, packet, udp) {
     self.state = 'init';
     js_utils.self_bind(self, 'run_udp_request_loop');
     js_utils.self_bind(self, 'run_udp_indication_loop');
-    self.defer = new P.Defer();
+    self.defer = new Defer();
     self.defer.promise.catch(_.noop); // to ignore 'Unhandled rejection' printouts
     // set session timeout
     self.ready_timeout = setTimeout(function() {

src/rpc/rpc.js

@@ -11,6 +11,7 @@ const assert = require('assert');
 const EventEmitter = require('events').EventEmitter;
 
 const P = require('../util/promise');
+const Defer = require('../util/defer');
 const js_utils = require('../util/js_utils');
 const dbg = require('../util/debug_module')(__filename);
 const config = require('../../config');
@@ -191,7 +192,7 @@ class RPC extends EventEmitter {
 
             // initialize the request
             req._new_request(api, method_api, params, options.auth_token);
-            req._response_defer = new P.Defer();
+            req._response_defer = new Defer();
             req._response_defer.promise.catch(_.noop); // to prevent error log of unhandled rejection
 
             if (options.tracker) {

src/rpc/rpc_base_conn.js

@@ -7,6 +7,8 @@ const _ = require('lodash');
 const events = require('events');
 
 const P = require('../util/promise');
+const Defer = require('../util/defer');
+
 const dbg = require('../util/debug_module')(__filename);
 const config = require('../../config');
 const time_utils = require('../util/time_utils');
@@ -38,7 +40,7 @@ class RpcBaseConnection extends events.EventEmitter {
         this._state = STATE_INIT;
 
         // the connecting_defer is used by connect() to wait for the connected event
-        this.connecting_defer = new P.Defer();
+        this.connecting_defer = new Defer();
         this._connect_promise = events.once(this, 'connect');
         this._connect_promise.catch(_.noop); // to prevent error log of unhandled rejection
 

src/rpc/rpc_http.js

@@ -5,7 +5,7 @@ const _ = require('lodash');
 const http = require('http');
 const https = require('https');
 
-const P = require('../util/promise');
+const Defer = require('../util/defer');
 const dbg = require('../util/debug_module')(__filename);
 const buffer_utils = require('../util/buffer_utils');
 const http_utils = require('../util/http_utils');
@@ -145,7 +145,7 @@ class RpcHttpConnection extends RpcBaseConnection {
 
         dbg.log3('HTTP request', http_req.method, http_req.path, http_req._headers);
 
-        const send_defer = new P.Defer();
+        const send_defer = new Defer();
 
         // reject on send errors
         http_req.on('error', send_defer.reject);

src/rpc/rpc_request.js

@@ -2,7 +2,7 @@
 'use strict';
 
 /** @typedef {import('./rpc_base_conn')} RpcBaseConnection */
-/** @typedef {import('../util/promise').Defer} Defer */
+/** @typedef {import('../util/defer')} Defer */
 
 const _ = require('lodash');
 const RpcMessage = require('./rpc_message');

src/test/unit_tests/test_promise_utils.js

@@ -2,6 +2,7 @@
 'use strict';
 
 const P = require('../../util/promise');
+const Defer = require('../../util/defer');
 const mocha = require('mocha');
 const assert = require('assert');
 
@@ -91,22 +92,22 @@ mocha.describe('promise utils', function() {
 
     mocha.describe('P.defer', function() {
         mocha.it('resolves immediately', /** @this {Mocha.Context} */ async function() {
-            const defer = new P.Defer();
+            const defer = new Defer();
             defer.resolve(this.test.title);
             assert.strictEqual(await defer.promise, this.test.title);
         });
         mocha.it('resolves later', /** @this {Mocha.Context} */ async function() {
-            const defer = new P.Defer();
+            const defer = new Defer();
             setTimeout(() => defer.resolve(this.test.title), 12);
             assert.strictEqual(await defer.promise, this.test.title);
         });
         mocha.it('rejects immediately', /** @this {Mocha.Context} */ async function() {
-            const defer = new P.Defer();
+            const defer = new Defer();
             defer.reject(new Error(this.test.title));
             assert.rejects(defer.promise);
         });
         mocha.it('rejects later', /** @this {Mocha.Context} */ async function() {
-            const defer = new P.Defer();
+            const defer = new Defer();
             setTimeout(() => defer.reject(new Error(this.test.title)), 12);
             assert.rejects(defer.promise);
         });

src/util/barrier.js

@@ -3,6 +3,7 @@
 
 const _ = require('lodash');
 const P = require('../util/promise');
+const Defer = require('../util/defer');
 
 module.exports = Barrier;
 
@@ -49,7 +50,7 @@ Barrier.prototype.call = function(item) {
 
         // add the item to the pending barrier and assign a defer
         // that will be resolved/rejected per this item.
-        const defer = new P.Defer();
+        const defer = new Defer();
         self.barrier.items.push(item);
         self.barrier.defers.push(defer);
 

src/util/defer.js

@@ -0,0 +1,54 @@
+/* Copyright (C) 2016 NooBaa */
+'use strict';
+
+/**
+ * @deprecated LEGACY PROMISE UTILS - DEPRECATED IN FAVOR OF ASYNC-AWAIT
+ */
+class Defer {
+
+    constructor() {
+        this.isPending = true;
+        this.isResolved = false;
+        this.isRejected = false;
+        this.promise = new Promise((resolve, reject) => {
+            this._promise_resolve = resolve;
+            this._promise_reject = reject;
+        });
+        Object.seal(this);
+    }
+
+    // setting resolve and reject to assert that the current code assumes 
+    // the Promise ctor is calling the callback synchronously and not deferring it,
+    // otherwise we might have weird cases that we miss the caller's resolve/reject
+    // events, so we throw to assert 
+
+    /**
+     * @param {any} [res]
+     * @returns {void}
+     */
+    resolve(res) {
+        if (!this.isPending) {
+            return;
+        }
+        this.isPending = false;
+        this.isResolved = true;
+        Object.freeze(this);
+        this._promise_resolve(res);
+    }
+
+    /**
+     * @param {Error} err
+     * @returns {void}
+     */
+    reject(err) {
+        if (!this.isPending) {
+            return;
+        }
+        this.isPending = false;
+        this.isRejected = true;
+        Object.freeze(this);
+        this._promise_reject(err);
+    }
+}
+
+module.exports = Defer; // 13 occurrences

src/util/keys_lock.js

@@ -3,6 +3,7 @@
 
 const _ = require('lodash');
 const P = require('../util/promise');
+const Defer = require('../util/defer');
 const LinkedList = require('./linked_list');
 
 class KeysLock {
@@ -43,7 +44,7 @@ class KeysLock {
             return P.resolve();
         }
 
-        const defer = new P.Defer();
+        const defer = new Defer();
         lock_item.defer = defer;
         this._wait_list.push_back(lock_item);
         return defer.promise;

src/util/promise.js

@@ -209,56 +209,6 @@ async function retry({ attempts, delay_ms, func, error_logger }) {
 /////////////////////////////////////
 /////////////////////////////////////
 
-/**
- * @deprecated LEGACY PROMISE UTILS - DEPRECATED IN FAVOR OF ASYNC-AWAIT
- */
-class Defer {
-
-    constructor() {
-        this.isPending = true;
-        this.isResolved = false;
-        this.isRejected = false;
-        this.promise = new Promise((resolve, reject) => {
-            this._promise_resolve = resolve;
-            this._promise_reject = reject;
-        });
-        Object.seal(this);
-    }
-
-    // setting resolve and reject to assert that the current code assumes 
-    // the Promise ctor is calling the callback synchronously and not deferring it,
-    // otherwise we might have weird cases that we miss the caller's resolve/reject
-    // events, so we throw to assert 
-
-    /**
-     * @param {any} [res]
-     * @returns {void}
-     */
-    resolve(res) {
-        if (!this.isPending) {
-            return;
-        }
-        this.isPending = false;
-        this.isResolved = true;
-        Object.freeze(this);
-        this._promise_resolve(res);
-    }
-
-    /**
-     * @param {Error} err
-     * @returns {void}
-     */
-    reject(err) {
-        if (!this.isPending) {
-            return;
-        }
-        this.isPending = false;
-        this.isRejected = true;
-        Object.freeze(this);
-        this._promise_reject(err);
-    }
-}
-
 /**
  * Callback is a template typedef to help propagate types correctly
  * when using nodejs callback functions.
@@ -366,5 +316,4 @@ exports.fromCallback = fromCallback; // 44 occurrences
 exports.fcall = fcall; // 59 occurrences
 exports.ninvoke = ninvoke; // 30 occurrences
 exports.wait_until = wait_until; // 20 occurrences
-exports.Defer = Defer; // 13 occurrences
 exports.pwhile = pwhile; // 15 occurrences