@node-red/runtime 3.1.0-beta.2 → 3.1.0-beta.4

package/lib/flows/Flow.js

@@ -14,19 +14,20 @@
  * limitations under the License.
  **/
 
-var clone = require("clone");
-var redUtil = require("@node-red/util").util;
+const clone = require("clone");
+const redUtil = require("@node-red/util").util;
 const events = require("@node-red/util").events;
-var flowUtil = require("./util");
+const flowUtil = require("./util");
 const context = require('../nodes/context');
 const hooks = require("@node-red/util").hooks;
 const credentials = require("../nodes/credentials");
 
-var Subflow;
-var Log;
+let Subflow;
+let Log;
+let Group;
 
-var nodeCloseTimeout = 15000;
-var asyncMessageDelivery = true;
+let nodeCloseTimeout = 15000;
+let asyncMessageDelivery = true;
 
 /**
  * This class represents a flow within the runtime. It is responsible for
@@ -52,6 +53,8 @@ class Flow {
             this.isGlobalFlow = false;
         }
         this.id = this.flow.id || "global";
+        this.groups = {}
+        this.groupOrder = []
         this.activeNodes = {};
         this.subflowInstanceNodes = {};
         this.catchNodes = [];
@@ -59,6 +62,11 @@ class Flow {
         this.path = this.id;
         // Ensure a context exists for this flow
         this.context = context.getFlowContext(this.id,this.parent.id);
+        
+        // env is an array of env definitions
+        // _env is an object for direct lookup of env name -> value
+        this.env = this.flow.env
+        this._env = {}
     }
 
     /**
@@ -136,7 +144,7 @@ class Flow {
      * @param  {[type]} msg [description]
      * @return {[type]}     [description]
      */
-    start(diff) {
+    async start(diff) {
         this.trace("start "+this.TYPE+" ["+this.path+"]");
         var node;
         var newNode;
@@ -145,6 +153,52 @@ class Flow {
         this.statusNodes = [];
         this.completeNodeMap = {};
 
+
+        if (this.isGlobalFlow) {
+            // This is the global flow. It needs to go find the `global-config`
+            // node and extract any env properties from it
+            const configNodes = Object.keys(this.flow.configs);
+            for (let i = 0; i < configNodes.length; i++) {
+                const node = this.flow.configs[configNodes[i]]
+                if (node.type === 'global-config' && node.env) {
+                    const nodeEnv = await flowUtil.evaluateEnvProperties(this, node.env, credentials.get(node.id))
+                    this._env = { ...this._env, ...nodeEnv }
+                }
+            }
+        }
+
+        if (this.env) {
+            this._env = { ...this._env, ...await flowUtil.evaluateEnvProperties(this, this.env, credentials.get(this.id)) }
+        }
+
+        // Initialise the group objects. These must be done in the right order
+        // starting from outer-most to inner-most so that the parent hierarchy
+        // is maintained.
+        this.groups = {}
+        this.groupOrder = []
+        const groupIds = Object.keys(this.flow.groups || {})
+        while (groupIds.length > 0) {
+            const id = groupIds.shift()
+            const groupDef = this.flow.groups[id]
+            if (!groupDef.g || this.groups[groupDef.g]) {
+                // The parent of this group is available - either another group
+                // or the top-level flow (this)
+                const parent = this.groups[groupDef.g] || this
+                this.groups[groupDef.id] = new Group(parent, groupDef)
+                this.groupOrder.push(groupDef.id)
+            } else {
+                // Try again once we've processed the other groups
+                groupIds.push(id)
+            }
+        }
+
+        for (let i = 0; i < this.groupOrder.length; i++) {
+            // Start the groups in the right order so they
+            // can setup their env vars knowning their parent
+            // will have been started
+            await this.groups[this.groupOrder[i]].start()
+        }
+
         var configNodes = Object.keys(this.flow.configs);
         var configNodeAttempts = {};
         while (configNodes.length > 0) {
@@ -177,7 +231,7 @@ class Flow {
                         }
                     }
                     if (readyToCreate) {
-                        newNode = flowUtil.createNode(this,node);
+                        newNode = await flowUtil.createNode(this,node);
                         if (newNode) {
                             this.activeNodes[id] = newNode;
                         }
@@ -203,7 +257,7 @@ class Flow {
                 if (node.d !== true) {
                     if (!node.subflow) {
                         if (!this.activeNodes[id]) {
-                            newNode = flowUtil.createNode(this,node);
+                            newNode = await flowUtil.createNode(this,node);
                             if (newNode) {
                                 this.activeNodes[id] = newNode;
                             }
@@ -221,7 +275,7 @@ class Flow {
                                     node
                                 );
                                 this.subflowInstanceNodes[id] = subflow;
-                                subflow.start();
+                                await subflow.start();
                                 this.activeNodes[id] = subflow.node;
 
                                 // this.subflowInstanceNodes[id] = nodes.map(function(n) { return n.id});
@@ -404,8 +458,7 @@ class Flow {
      * @return {Node}   group node
      */
     getGroupNode(id) {
-        const groups = this.global.groups;
-        return groups[id];
+        return this.groups[id];
     }
 
     /**
@@ -416,95 +469,8 @@ class Flow {
         return this.activeNodes;
     }
 
-    /*!
-     * Get value of environment variable defined in group node.
-     * @param {String} group - group node
-     * @param {String} name - name of variable
-     * @return {Object} object containing the value in val property or null if not defined
-     */
-    getGroupEnvSetting(node, group, name) {
-        if (group) {
-            if (name === "NR_GROUP_NAME") {
-                return [{
-                    val: group.name
-                }, null];
-            }
-            if (name === "NR_GROUP_ID") {
-                return [{
-                    val: group.id
-                }, null];
-            }
-
-            if (group.credentials === undefined) {
-                group.credentials = credentials.get(group.id) || {};
-            }
-            if (!name.startsWith("$parent.")) {
-                if (group.env) {
-                    if (!group._env) {
-                        const envs = group.env;
-                        const entries = envs.map((env) => {
-                            if (env.type === "cred") {
-                                const cred = group.credentials;
-                                if (cred.hasOwnProperty(env.name)) {
-                                    env.value = cred[env.name];
-                                }
-                            }
-                            return [env.name, env];
-                        });
-                        group._env = Object.fromEntries(entries);
-                    }
-                    const env = group._env[name];
-                    if (env) {
-                        let value = env.value;
-                        const type = env.type;
-                        if ((type !== "env") ||
-                            (value !== name)) {
-                            if (type === "env") {
-                                value = value.replace(new RegExp("\\${"+name+"}","g"),"${$parent."+name+"}");
-                            }
-                            if (type === "bool") {
-                                const val
-                                      = ((value === "true") ||
-                                         (value === true));
-                                return [{
-                                    val: val
-                                }, null];
-                            }
-                            if (type === "cred") {
-                                return [{
-                                    val: value
-                                }, null];
-                            }
-                            try {
-                                var val = redUtil.evaluateNodeProperty(value, type, node, null, null);
-                                return [{
-                                    val: val
-                                }, null];
-                            }
-                            catch (e) {
-                                this.error(e);
-                                return [null, null];
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                name = name.substring(8);
-            }
-            if (group.g) {
-                const parent = this.getGroupNode(group.g);
-                return this.getGroupEnvSetting(node, parent, name);
-            }
-        }
-        return [null, name];
-    }
-
-
     /**
-     * Get a flow setting value. This currently automatically defers to the parent
-     * flow which, as defined in ./index.js returns `process.env[key]`.
-     * This lays the groundwork for Subflow to have instance-specific settings
+     * Get a flow setting value.
      * @param  {[type]} key [description]
      * @return {[type]}     [description]
      */
@@ -516,54 +482,14 @@ class Flow {
         if (key === "NR_FLOW_ID") {
             return flow.id;
         }
-        if (flow.credentials === undefined) {
-            flow.credentials = credentials.get(flow.id) || {};
-        }
-        if (flow.env) {
-            if (!key.startsWith("$parent.")) {
-                if (!flow._env) {
-                    const envs = flow.env;
-                    const entries = envs.map((env) => {
-                        if (env.type === "cred") {
-                            const cred = flow.credentials;
-                            if (cred.hasOwnProperty(env.name)) {
-                                env.value = cred[env.name];
-                            }
-                        }
-                        return [env.name, env]
-                    });
-                    flow._env = Object.fromEntries(entries);
-                }
-                const env = flow._env[key];
-                if (env) {
-                    let value = env.value;
-                    const type = env.type;
-                    if ((type !== "env") || (value !== key)) {
-                        if (type === "env") {
-                            value = value.replace(new RegExp("\\${"+key+"}","g"),"${$parent."+key+"}");
-                        }
-                        try {
-                            if (type === "bool") {
-                                const val = ((value === "true") ||
-                                             (value === true));
-                                return val;
-                            }
-                            if (type === "cred") {
-                                return value;
-                            }
-                            var val = redUtil.evaluateNodeProperty(value, type, null, null, null);
-                            return val;
-                        }
-                        catch (e) {
-                            this.error(e);
-                        }
-                    }
-                }
+        if (!key.startsWith("$parent.")) {
+            if (this._env.hasOwnProperty(key)) {
+                return this._env[key]
             }
-            else {
+        } else {
                 key = key.substring(8);
-            }
         }
+        // Delegate to the parent flow.
         return this.parent.getSetting(key);
     }
 
@@ -601,15 +527,40 @@ class Flow {
             // Delegate status to any nodes using this config node
             for (let userNode in node.users) {
                 if (node.users.hasOwnProperty(userNode)) {
-                    node.users[userNode]._flow.handleStatus(node,statusMessage,node.users[userNode],true);
+                    handled = node.users[userNode]._flow.handleStatus(node,statusMessage,node.users[userNode],true) || handled;
                 }
             }
-            handled = true;
         } else {
-            this.statusNodes.forEach(function(targetStatusNode) {
-                if (targetStatusNode.scope && targetStatusNode.scope.indexOf(reportingNode.id) === -1) {
+            const candidateNodes = [];
+            this.statusNodes.forEach(targetStatusNode => {
+                if (targetStatusNode.g && targetStatusNode.scope === 'group' && !reportingNode.g) {
+                    // Status node inside a group, reporting node not in a group - skip it
+                    return
+                }
+                if (Array.isArray(targetStatusNode.scope) && targetStatusNode.scope.indexOf(reportingNode.id) === -1) {
                     return;
                 }
+                let distance = 0
+                if (reportingNode.g) {
+                    // Reporting node inside a group. Calculate the distance between it and the status node
+                    let containingGroup = this.groups[reportingNode.g]
+                    while (containingGroup && containingGroup.id !== targetStatusNode.g) {
+                        distance++
+                        containingGroup = this.groups[containingGroup.g]
+                    }
+                    if (!containingGroup && targetStatusNode.g && targetStatusNode.scope === 'group') {
+                        // This status node is in a group, but not in the same hierachy
+                        // the reporting node is in
+                        return
+                    }
+                }
+                candidateNodes.push({ d: distance, n: targetStatusNode })
+            })
+            candidateNodes.sort((A,B) => {
+                return A.d - B.d
+            })
+            candidateNodes.forEach(candidate => {
+                const targetStatusNode = candidate.n
                 var message = {
                     status: clone(statusMessage)
                 }
@@ -662,26 +613,50 @@ class Flow {
             // Delegate status to any nodes using this config node
             for (let userNode in node.users) {
                 if (node.users.hasOwnProperty(userNode)) {
-                    node.users[userNode]._flow.handleError(node,logMessage,msg,node.users[userNode]);
+                    handled = node.users[userNode]._flow.handleError(node,logMessage,msg,node.users[userNode]) || handled;
                 }
             }
-            handled = true;
         } else {
-            var handledByUncaught = false;
-
-            this.catchNodes.forEach(function(targetCatchNode) {
-                if (targetCatchNode.scope && targetCatchNode.scope.indexOf(reportingNode.id) === -1) {
+            const candidateNodes = [];
+            this.catchNodes.forEach(targetCatchNode => {
+                if (targetCatchNode.g && targetCatchNode.scope === 'group' && !reportingNode.g) {
+                    // Catch node inside a group, reporting node not in a group - skip it
+                    return
+                }
+                if (Array.isArray(targetCatchNode.scope) && targetCatchNode.scope.indexOf(reportingNode.id) === -1) {
+                    // Catch node has a scope set and it doesn't include the reporting node
                     return;
                 }
-                if (!targetCatchNode.scope && targetCatchNode.uncaught && !handledByUncaught) {
+                let distance = 0
+                if (reportingNode.g) {
+                    // Reporting node inside a group. Calculate the distance between it and the catch node
+                    let containingGroup = this.groups[reportingNode.g]
+                    while (containingGroup && containingGroup.id !== targetCatchNode.g) {
+                        distance++
+                        containingGroup = this.groups[containingGroup.g]
+                    }
+                    if (!containingGroup && targetCatchNode.g && targetCatchNode.scope === 'group') {
+                        // This catch node is in a group, but not in the same hierachy
+                        // the reporting node is in
+                        return
+                    }
+                }
+                candidateNodes.push({ d: distance, n: targetCatchNode })
+            })
+            candidateNodes.sort((A,B) => {
+                return A.d - B.d
+            })
+            let handledByUncaught = false
+            candidateNodes.forEach(candidate => {
+                const targetCatchNode = candidate.n
+                if (targetCatchNode.uncaught && !handledByUncaught) {
+                    // This node only wants errors that haven't already been handled
                     if (handled) {
-                        // This has been handled by a !uncaught catch node
-                        return;
+                        return
                     }
-                    // This is an uncaught error
-                    handledByUncaught = true;
+                    handledByUncaught = true
                 }
-                var errorMessage;
+                let errorMessage;
                 if (msg) {
                     errorMessage = redUtil.cloneMessage(msg);
                 } else {
@@ -808,7 +783,7 @@ function handlePreRoute(flow, sendEvent, reportError) {
             return;
         } else if (err !== false) {
             sendEvent.destination.node = flow.getNode(sendEvent.destination.id);
-            if (sendEvent.destination.node) {
+            if (sendEvent.destination.node && typeof sendEvent.destination.node === 'object') {
                 if (sendEvent.cloneMessage) {
                     sendEvent.msg = redUtil.cloneMessage(sendEvent.msg);
                 }
@@ -858,9 +833,10 @@ module.exports = {
         asyncMessageDelivery = !runtime.settings.runtimeSyncDelivery
         Log = runtime.log;
         Subflow = require("./Subflow");
+        Group = require("./Group").Group
     },
     create: function(parent,global,conf) {
-        return new Flow(parent,global,conf);
+        return new Flow(parent,global,conf)
     },
     Flow: Flow
 }

package/lib/flows/Group.js

@@ -0,0 +1,55 @@
+const flowUtil = require("./util");
+const credentials = require("../nodes/credentials");
+
+/**
+ * This class represents a group within the runtime.
+ */
+class Group {
+
+    /**
+     * Create a Group object.
+     * @param {[type]} parent     The parent flow/group
+     * @param {[type]} groupDef   This group's definition
+     */
+    constructor(parent, groupDef) {
+        this.TYPE = 'group'
+        this.name = groupDef.name
+        this.parent = parent
+        this.group = groupDef
+        this.id = this.group.id
+        this.g = this.group.g
+        this.env = this.group.env
+        this._env = {}
+    }
+
+    async start() {
+        if (this.env) {
+            this._env = await flowUtil.evaluateEnvProperties(this, this.env, credentials.get(this.id))
+        }
+    }
+    /**
+     * Get a group setting value.
+     * @param  {[type]} key [description]
+     * @return {[type]}     [description]
+     */
+    getSetting(key) {
+        if (key === "NR_GROUP_NAME") {
+            return this.name;
+        }
+        if (key === "NR_GROUP_ID") {
+            return this.id;
+        }
+        if (!key.startsWith("$parent.")) {
+            if (this._env.hasOwnProperty(key)) {
+                return this._env[key]
+            }
+        } else {
+            key = key.substring(8);
+        }
+        return this.parent.getSetting(key);
+    }
+}
+
+module.exports = {
+    Group
+}

package/lib/flows/Subflow.js

@@ -119,7 +119,7 @@ class Subflow extends Flow {
         this.templateCredentials = credentials.get(subflowDef.id) || {};
         this.instanceCredentials = credentials.get(id) || {};
 
-        var env = [];
+        var env = {};
         if (this.subflowDef.env) {
             this.subflowDef.env.forEach(e => {
                 env[e.name] = e;
@@ -145,7 +145,7 @@ class Subflow extends Flow {
                 }
             });
         }
-        this.env = env;
+        this.env = Object.values(env);
     }
 
     /**
@@ -156,7 +156,7 @@ class Subflow extends Flow {
      * @param  {[type]} diff [description]
      * @return {[type]}      [description]
      */
-    start(diff) {
+    async start(diff) {
         var self = this;
         // Create a subflow node to accept inbound messages and route appropriately
         var Node = require("../nodes/Node");
@@ -310,7 +310,7 @@ class Subflow extends Flow {
                 }
             }
         }
-        super.start(diff);
+        return super.start(diff);
     }
 
     /**
@@ -335,68 +335,35 @@ class Subflow extends Flow {
     }
     /**
      * Get environment variable of subflow
-     * @param {String}   name   name of env var
+     * @param {String}   key   name of env var
      * @return {Object}  val    value of env var
      */
-    getSetting(name) {
-        if (!/^\$parent\./.test(name)) {
-            var env = this.env;
-            if (env && env.hasOwnProperty(name)) {
-                var val = env[name];
-                // If this is an env type property we need to be careful not
-                // to get into lookup loops.
-                // 1. if the value to lookup is the same as this one, go straight to parent
-                // 2. otherwise, check if it is a compound env var ("foo $(bar)")
-                //    and if so, substitute any instances of `name` with $parent.name
-                // See https://github.com/node-red/node-red/issues/2099
-                if (val.type !== 'env' || val.value !== name) {
-                    let value = val.value;
-                    var type = val.type;
-                    if (type === 'env') {
-                        value = value.replace(new RegExp("\\${"+name+"}","g"),"${$parent."+name+"}");
-                    }
-                    try {
-                        return evaluateInputValue(value, type, this.node);
-                    }
-                    catch (e) {
-                        this.error(e);
-                        return undefined;
-                    }
-                } else {
-                    // This _is_ an env property pointing at itself - go to parent
-                }
-            }
-        } else {
-            // name starts $parent. ... so delegate to parent automatically
-            name = name.substring(8);
-        }
+    getSetting(key) {
         const node = this.subflowInstance;
         if (node) {
-            if (name === "NR_NODE_NAME") {
+            if (key === "NR_NODE_NAME" || key === "NR_SUBFLOW_NAME") {
                 return node.name;
             }
-            if (name === "NR_NODE_ID") {
+            if (key === "NR_NODE_ID" || key === "NR_SUBFLOW_ID") {
                 return node.id;
             }
-            if (name === "NR_NODE_PATH") {
+            if (key === "NR_NODE_PATH" || key === "NR_SUBFLOW_PATH") {
                 return node._path;
             }
         }
-        if (node.g) {
-            const group = this.getGroupNode(node.g);
-            const [result, newName] = this.getGroupEnvSetting(node, group, name);
-            if (result) {
-                return result.val;
+        if (!key.startsWith("$parent.")) {
+            if (this._env.hasOwnProperty(key)) {
+                return this._env[key]
             }
-            name = newName;
+        } else {
+            key = key.substring(8);
         }
-
-        var parent = this.parent;
-        if (parent) {
-            var val = parent.getSetting(name);
-            return val;
+        // Push the request up to the parent.
+        // Unlike a Flow, the parent of a Subflow could be a Group
+        if (node.g) {
+            return this.parent.getGroupNode(node.g).getSetting(key)
         }
-        return undefined;
+        return this.parent.getSetting(key)
     }
 
     /**