remove domain dependency

Author: yunjinlxp

README-EN.md

@@ -13,6 +13,8 @@
 
 
 ## Version Feature Updates
+- Version: 5.6.0
+  - Remove domain dependency.
 - Version: 5.5.1
   - Bug fix in _parseSearchHit function.
 - Version: 5.5.0

README.md

@@ -13,6 +13,8 @@
 
 
 ## 版本特性
+- 版本: 5.6.0
+  - Remove domain dependency.
 - 版本: 5.5.1
   - Bug fix in _parseSearchHit function.
 - 版本: 5.5.0

lib/request.js

@@ -1,6 +1,5 @@
 var TableStore = require('./core');
 var inherit = TableStore.util.inherit;
-var domain = TableStore.util.nodeRequire('domain');
 
 var hardErrorStates = { success: 1, error: 1, complete: 1 };
 
@@ -13,28 +12,32 @@ function AcceptorStateMachine(states, state) {
   this.states = states || {};
 }
 
-AcceptorStateMachine.prototype.runTo = function runTo(finalState, done, bindObject, inputError) {
+AcceptorStateMachine.prototype.runTo = async function runTo(finalState, done, bindObject, inputError) {
   if (typeof finalState === 'function') {
     inputError = bindObject; bindObject = done;
     done = finalState; finalState = null;
   }
 
-  var self = this;
-  var state = self.states[self.currentState];
-  state.fn.call(bindObject || self, inputError, function (err) {
-    if (err) {
-      if (bindObject.logger) bindObject.logger.log(self.currentState, '->', state.fail, err);
-      if (state.fail) self.currentState = state.fail;
-      else return done ? done(err) : null;
-    } else {
-      if (bindObject.logger) bindObject.logger.log(self.currentState, '->', state.accept);
-      if (state.accept) self.currentState = state.accept;
-      else return done ? done() : null;
-    }
-    if (self.currentState === finalState) return done ? done(err) : null;
+  try {
+    var self = this;
+    var state = self.states[self.currentState];
+    await state.fn.call(bindObject || self, inputError, async (err) => {
+      if (err) {
+        if (bindObject.logger) bindObject.logger.log(self.currentState, '->', state.fail, err);
+        if (state.fail) self.currentState = state.fail;
+        else return done ? done(err) : null;
+      } else {
+        if (bindObject.logger) bindObject.logger.log(self.currentState, '->', state.accept);
+        if (state.accept) self.currentState = state.accept;
+        else return done ? done() : null;
+      }
+      if (self.currentState === finalState) return done ? done(err) : null;
 
-    self.runTo(finalState, done, bindObject, err);
-  });
+      await self.runTo(finalState, done, bindObject, err);
+    });
+  } catch (err) {
+    if (done) done(err);
+  }
 };
 
 AcceptorStateMachine.prototype.addState = function addState(name, acceptState, failState, fn) {
@@ -51,31 +54,33 @@ AcceptorStateMachine.prototype.addState = function addState(name, acceptState, f
 
 var fsm = new AcceptorStateMachine();
 fsm.setupStates = function () {
-  var transition = function transition(_, done) {
+  var transition = async function transition(_, done) {
     var self = this;
     var origError = self.response.error;
-    self.emit(self._asm.currentState, function (err) {
-      if (err) {
-        if (isTerminalState(self)) {
-          if (domain && self.domain instanceof domain.Domain) {
-            err.domainEmitter = self;
-            err.domain = self.domain;
-            err.domainThrown = false;
-            self.domain.emit('error', err);
-          } else {
+    try {
+      await self.emit(self._asm.currentState, async (err) => {
+        if (err) {
+          if (isTerminalState(self)) {
             throw err;
+          } else {
+            self.response.error = err;
+            done(err);
           }
         } else {
-          self.response.error = err;
-          done(err);
+          done(self.response.error);
         }
+      });
+    } catch (err) {
+      if (isTerminalState(self)) {
+        throw err;
       } else {
-        done(self.response.error);
+        self.response.error = err;
+        done(err);
       }
-    });
+    }
   };
 
-  this.addState('restart', 'build', 'error', function (err, done) {
+  this.addState('restart', 'build', 'error', async function (err, done) {
     err = this.response.error;
     if (!err) return done();
     err.retryable = TableStore.DefaultRetryPolicy.shouldRetry(this.response.retryCount, this.response.error, this.response.request.operation);
@@ -122,8 +127,6 @@ TableStore.Request = inherit({
     if (config.maxRetries !== undefined) {
       TableStore.DefaultRetryPolicy.maxRetryTimes = config.maxRetries;
     }
-    //如果在sdk外部包装了一层domain，就把它传到this.domain
-    this.domain = domain && domain.active;
     this.operation = operation;
     this.params = params || {};
     this.httpRequest = new TableStore.HttpRequest(endpoint, region);
@@ -156,23 +159,23 @@ TableStore.Request = inherit({
    *     request = client.listTable({Bucket: 'bucket', Key: 'key'});
    *     request.send(function(err, data) { console.log(err, data); });
    */
-  send: function send(callback) {
+  send: async function send(callback) {
     if (callback) {
       this.on('complete', function (resp) {
         callback.call(resp, resp.error, resp.data);
       });
     }
-    this.runTo();
+    await this.runTo();
 
     return this.response;
   },
 
-  build: function build(callback) {
-    return this.runTo('send', callback);
+  build: async function build(callback) {
+    await this.runTo('send', callback);
   },
 
-  runTo: function runTo(state, done) {
-    this._asm.runTo(state, done, this);
+  runTo: async function runTo(state, done) {
+    await this._asm.runTo(state, done, this);
     return this;
   },
 
@@ -181,15 +184,19 @@ TableStore.Request = inherit({
    *   or an array of args to send to the event.
    * @api private
    */
-  emitEvent: function emit(eventName, args, done) {
+  emitEvent: async function emit(eventName, args, done) {
     if (typeof args === 'function') { done = args; args = null; }
-    if (!done) done = function () { }//this.unhandledErrorCallback;
+    if (!done) done = function () { };
     if (!args) args = this.eventParameters(eventName, this.response);
     var origEmit = TableStore.SequentialExecutor.prototype.emit;
-    origEmit.call(this, eventName, args, function (err) {
-      if (err) this.response.error = err;
-      done.call(this, err);
-    });
+    try {
+      await origEmit.call(this, eventName, args, async (err) => {
+        if (err) this.response.error = err;
+        done.call(this, err);
+      });
+    } catch (err) {
+      if (done) done(err);
+    }
   },
 
   /**
@@ -225,4 +232,4 @@ TableStore.Response = inherit({
     this.httpResponse = new TableStore.HttpResponse();
   }
 
-});
+});

lib/sequential_executor.js

@@ -1,5 +1,4 @@
 var TableStore = require('./core');
-var domain = TableStore.util.nodeRequire('domain');
 
 /**
  * @!method on(eventName, callback)
@@ -14,7 +13,6 @@ var domain = TableStore.util.nodeRequire('domain');
 TableStore.SequentialExecutor = TableStore.util.inherit({
 
   constructor: function SequentialExecutor() {
-    this.domain = domain && domain.active;
     this._events = {};
   },
 
@@ -68,54 +66,59 @@ TableStore.SequentialExecutor = TableStore.util.inherit({
   /**
    * @api private
    */
-  emit: function emit(eventName, eventArgs, doneCallback) {
+  emit: async function emit(eventName, eventArgs, doneCallback) {
     if (!doneCallback) doneCallback = this.unhandledErrorCallback;
-    if (domain && this.domain instanceof domain.Domain)
-      this.domain.enter();
 
-    if(process.env.DEBUG == 'aliyun') {
+    if (process.env.DEBUG == 'aliyun') {
       console.log('emit', eventName);
     }
+
     var listeners = this.listeners(eventName);
     var count = listeners.length;
-    this.callListeners(listeners, eventArgs, doneCallback);
+
+    try {
+      await this.callListeners(listeners, eventArgs, doneCallback);
+    } catch (err) {
+      doneCallback.call(this, err);
+    }
+
     return count > 0;
   },
 
   /**
    * @api private
    */
-  callListeners: function callListeners(listeners, args, doneCallback) {
+  callListeners: async function callListeners(listeners, args, doneCallback) {
     if (listeners.length === 0) {
       doneCallback.call(this);
-      if (domain && this.domain instanceof domain.Domain)
-        this.domain.exit();
     } else {
       var listener = listeners.shift();
       if (listener._isAsync) {
 
         // asynchronous listener
-        var callNextListener = function(err) {
-          if (err) {
-            doneCallback.call(this, err);
-            if (domain && this.domain instanceof domain.Domain)
-              this.domain.exit();
-          } else {
-            this.callListeners(listeners, args, doneCallback);
-          }
-        }.bind(this);
-        listener.apply(this, args.concat([callNextListener]));
+        try {
+          await new Promise((resolve, reject) => {
+            listener.apply(this, args.concat([function(err) {
+              if (err) {
+                reject(err);
+              } else {
+                resolve();
+              }
+            }]));
+          });
+          await this.callListeners(listeners, args, doneCallback);
+        } catch (err) {
+          doneCallback.call(this, err);
+        }
 
       } else {
 
         // synchronous listener
         try {
           listener.apply(this, args);
-          this.callListeners(listeners, args, doneCallback);
+          await this.callListeners(listeners, args, doneCallback);
         } catch (err) {
           doneCallback.call(this, err);
-          if (domain && this.domain instanceof domain.Domain)
-            this.domain.exit();
         }
 
       }
@@ -230,7 +233,7 @@ TableStore.SequentialExecutor = TableStore.util.inherit({
 });
 
 /**
- * {on} is the prefered method.
+ * {on} is the preferred method.
  * @api private
  */
 TableStore.SequentialExecutor.prototype.addListener = TableStore.SequentialExecutor.prototype.on;

package.json

@@ -2,7 +2,7 @@
   "name": "tablestore",
   "main": "index.js",
   "description": "TableStore SDK for JavaScript",
-  "version": "5.5.1",
+  "version": "5.6.0",
   "devDependencies": {
     "mocha": "^3.2.0",
     "coveralls": "^2.13.1",

samples/domainError.js

@@ -1,19 +1,34 @@
-var client = require('./client');
-var domain = TableStore.util.nodeRequire('domain');
+const client = require('./client');
 
-//https://nodejs.org/api/domain.html#domain_domain_enter
-//https://shapeshed.com/uncaught-exceptions-in-node/
-domainSample = domain.create();
-domainSample.on('error', function (err) {
-    console.log('error:', err);
-    console.log('Exit your application!')
-})
-domainSample.run(function () {
-    client.listTable({}, function (err, data) {
-        if (err) {
-            console.log('error:', err);
-            return;
-        }
-        throw new Error('test')
+const listTablePromise = (params) => {
+  return new Promise((resolve, reject) => {
+    client.listTable(params, (err, data) => {
+      if (err) return reject(err);
+      resolve(data);
     });
-})
+  });
+};
+
+async function run() {
+  try {
+    const data = await listTablePromise({});
+    console.log('Data:', data);
+    throw new Error('test');
+  } catch (err) {
+    console.log('error:', err);
+    console.log('Exit your application!');
+    process.exit(1);
+  }
+}
+
+process.on('unhandledRejection', (err) => {
+  console.error('Unhandled Promise Rejection:', err);
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+  process.exit(1);
+});
+
+run();