Fixed #1938 - an issue with the queue causing an uncaught exception.

Author: beatfactor

lib/core/asynctree.js

@@ -33,21 +33,10 @@ class AsyncTree {
   }
 
   traverse() {
-    const childNode = AsyncTree.getNextChild(this.currentNode);
+    const childNode = AsyncTree.getNextChildNode(this.currentNode);
 
     if (childNode) {
-      return this.runChildNode(childNode).then(result => {
-        let abortOnFailure = false;
-        if (result instanceof Error) {
-          abortOnFailure = result.abortOnFailure || Utils.isUndefined(result.abortOnFailure);
-        }
-
-        if (abortOnFailure) {
-          return this.done(result);
-        }
-
-        return this.traverse();
-      });
+      return this.runChildNode(childNode);
     }
 
     if (this.currentNode.childNodes.length > 0 && this.currentNode.needsPromise) {
@@ -62,20 +51,15 @@ class AsyncTree {
   walkUp() {
     if (this.currentNode.childNodes.length > 0 && !this.currentNode.done) {
       // if the current node has childNodes that have not finished yet
-      return new Promise((resolve, reject) => {
-        this.currentNode.result
-          .then(_=> resolve())
-          .catch(err => reject(err));
+      return this.currentNode.result.catch(err => {
+        console.error(err);
+        throw err;
       });
     }
 
     if (!this.currentNode.done) {
       // if the current node hasn't finished yet
-      return new Promise((resolve, reject) => {
-        this.currentNode.result
-          .then(_=> resolve())
-          .catch(err => reject(err));
-      }).then(_ => this.walkUp());
+      return this.currentNode.result
     }
 
     this.currentNode = this.currentNode.parent;
@@ -86,17 +70,23 @@ class AsyncTree {
   runChildNode(node) {
     this.currentNode = node;
     this.currentNode.started = true;
-    Logger.log(`\n ${Logger.colors.green('→')} Running command: ${Logger.colors.light_green(node.name)} (${AsyncTree.printArguments(node)})`);
+    Logger.log(`\n ${Logger.colors.green('→')} Running command: ${Logger.colors.light_green(node.fullName)} (${AsyncTree.printArguments(node)})`);
 
     return node.run()
       .then(result => {
-        Logger.log(`${Logger.colors.green('→')} Completed command ${Logger.colors.light_green(node.name)}` +
+        Logger.log(`${Logger.colors.green('→')} Completed command ${Logger.colors.light_green(node.fullName)}` +
           ` (${AsyncTree.printArguments(node)}) (${node.elapsedTime}ms)`);
 
-        return result;
-      })
-      .catch(err => {
-        return err;
+        let abortOnFailure = false;
+        if (result instanceof Error) {
+          abortOnFailure = result.abortOnFailure || Utils.isUndefined(result.abortOnFailure);
+        }
+
+        if (abortOnFailure) {
+          return this.done(result);
+        }
+
+        return this.traverse();
       });
   }
 
@@ -124,17 +114,22 @@ class AsyncTree {
   ///////////////////////////////////////////////////////////////////////////
   // STATIC
   ///////////////////////////////////////////////////////////////////////////
-  static getNextChild(node) {
+  static getNextChildNode(node) {
+    let childNode;
     for (let i = 0; i < node.childNodes.length; i++) {
       if (!node.childNodes[i].started) {
         return node.childNodes[i];
       }
 
       if (node.childNodes[i].childNodes.length > 0) {
-        return AsyncTree.getNextChild(node.childNodes[i]);
+        childNode = node.childNodes[i];
       }
     }
 
+    if (childNode) {
+      //return AsyncTree.getNextChildNode(childNode);
+    }
+
     return false;
   }
 

lib/core/queue.js

@@ -19,6 +19,15 @@ class CommandQueue extends EventEmitter {
     return this.tree.rootNode.started;
   }
 
+  shouldStartQueue() {
+    const childNodes = this.currentNode.childNodes;
+    const allChildNodesDone = childNodes.every(function(node) {
+      return node.done;
+    });
+
+    return this.currentNode.started && allChildNodesDone;
+  }
+
   add(nodeName, commandFn, context, args, stackTrace, namespace) {
     const node = new Node({
       name       : nodeName,
@@ -28,19 +37,27 @@ class CommandQueue extends EventEmitter {
     });
     node.setCommand(commandFn, context, args);
 
+    const initialChildNode = this.shouldStartQueue();
+
     this.tree.addNode(node);
 
-    if (this.tree.inProgress) {
-      this.scheduleTraverse();
+    if (this.currentNode.done || !this.currentNode.started || initialChildNode) {
+      this.scheduleTraverse(node);
     }
   }
 
-  scheduleTraverse() {
+  scheduleTraverse(node) {
     if (this.scheduleTimeoutId) {
       clearTimeout(this.scheduleTimeoutId);
     }
 
-    this.scheduleTimeoutId = setTimeout(() => this.traverse(), 0);
+    this.scheduleTimeoutId = setTimeout(() => {
+      this.tree
+        .traverse()
+        .catch(err => {
+          return err;
+        });
+    }, 0);
   }
 
   clearScheduled() {

lib/core/treenode.js

@@ -18,6 +18,14 @@ class TreeNode {
     return this.__instance;
   }
 
+  get fullName() {
+    if (!this.namespace || !Utils.isString(this.namespace)) {
+      return this.name;
+    }
+
+    return `${this.namespace}.${this.name}`;
+  }
+
   /**
    *
    * @param {function} commandFn
@@ -51,6 +59,9 @@ class TreeNode {
 
   run() {
     return this.runCommand()
+      .catch(err => {
+        return err;
+      })
       .then(result => {
         this.done = true;
         this.elapsedTime = new Date().getTime() - this.startTime;
@@ -77,21 +88,20 @@ class TreeNode {
   runCommand() {
     this.started = true;
     this.startTime = new Date().getTime();
+    this.result = null;
 
     try {
-      this.result = this.execute();
+      this.result = this.execute().catch(err => {
+        err.message = `Error while running "${this.name}" command: ${err.message}`;
+        err.abortOnFailure = err.abortOnFailure || err.abortOnFailure === undefined;
 
-      return this.result
-        .catch(err => {
-          err.message = `Error while running "${this.name}" command: ${err.message}`;
-          err.abortOnFailure = err.abortOnFailure || err.abortOnFailure === undefined;
+        if (err.abortOnFailure) {
+          throw err;
+        }
 
-          if (err.abortOnFailure) {
-            throw err;
-          }
+        return err;
+      });
 
-          return err;
-        });
     } catch (err) {
       let originalError = err.stack;
 
@@ -101,8 +111,10 @@ class TreeNode {
 
       err.message = `Error while running "${this.name}" command: "${originalError.split('\n')[0]}"`;
 
-      return Promise.reject(err);
+      this.result = Promise.reject(err);
     }
+
+    return this.result;
   }
 
   handleCommandResult() {