Add deployment types in runtime

- removes ui option as it needs work

public/index.html

@@ -32,14 +32,13 @@
 <div id="header">
     <span class="logo"><img src="node-red.png"> <span>Node-RED</span></span>
     <div class="pull-right">
-        <span class="deploy-button-group button-group">
+        <ul class="header-toolbar">
-            <a id="btn-deploy" class="action-deploy disabled" href="#"><i id="btn-icn-deploy" class="fa fa-download"></i> Deploy</a>
+            <li><span class="deploy-button-group button-group">
-            <a id="btn-deploy-options"  data-toggle="dropdown"  class="" href="#"><i class="fa fa-caret-down"></i></a>
+                    <a id="btn-deploy" class="action-deploy disabled" href="#"><i id="btn-icn-deploy" class="fa fa-download"></i> <span>Deploy</span></a>
-            <ul class="dropdown-menu" role="menu">
+                    <!-- <a id="btn-deploy-options"  data-toggle="dropdown"  class="" href="#"><i class="fa fa-caret-down"></i></a> -->
-             <li>Foo</li>
+                </span></li>
-            </ul>
+            <li><a id="btn-sidemenu" class="button" data-toggle="dropdown" href="#"><i class="fa fa-bars"></i></a></li>
-        </span>
+        <ul>
-        <a id="btn-sidemenu" class="button dropdown-toggle" data-toggle="dropdown" href="#"><i class="fa fa-bars"></i></a>
     </div>
 </div>
 <div id="main-container" class="sidebar-closed">

public/red/main.js

@@ -15,6 +15,14 @@
  **/
 var RED = (function() {
 
+    var deploymentTypes = {
+        "full":"Deploy",
+        "nodes":"Deploy changed nodes",
+        "flows":"Deploy changed flows"
+    }
+    var deploymentType = "full";
+    
+    
     function hideDropTarget() {
         $("#dropTarget").hide();
         RED.keyboard.remove(/* ESCAPE */ 27);
@@ -82,7 +90,10 @@ var RED = (function() {
                 url:"flows",
                 type: "POST",
                 data: JSON.stringify(nns),
-                contentType: "application/json; charset=utf-8"
+                contentType: "application/json; charset=utf-8",
+                headers: {
+                    "Node-RED-Deployment-Type":deploymentType
+                }
             }).done(function(data,textStatus,xhr) {
                 RED.notify("Successfully deployed","success");
                 RED.nodes.eachNode(function(node) {
@@ -280,6 +291,12 @@ var RED = (function() {
         dialog.modal();
     }
 
+    
+    function changeDeploymentType(type) {
+        deploymentType = type;
+        $("#btn-deploy span").text(deploymentTypes[type]);
+    }
+    
     $(function() {
         RED.menu.init({id:"btn-sidemenu",
             options: [
@@ -313,6 +330,15 @@ var RED = (function() {
             ]
         });
         
+        //RED.menu.init({id:"btn-deploy-options",
+        //    options: [
+        //        {id:"btn-deploy-select",label:"Select deployment type"},
+        //        {id:"btn-deploy-full",icon:null,label:"Full deploy",tip:"Deploys all nodes",onselect:function() { changeDeploymentType("full")}},
+        //        {id:"btn-deploy-node",icon:null,label:"Deploy changed nodes",tip:"Deploys all nodes that have been changed",onselect:function() { changeDeploymentType("nodes")}},
+        //        {id:"btn-deploy-flow",icon:null,label:"Deploy changed flows",tip:"Deploys all nodes in flows that contain changes",onselect:function() { changeDeploymentType("flows")}}
+        //    ]
+        //});
+
         RED.keyboard.add(/* ? */ 191,{shift:true},function(){showHelp();d3.event.preventDefault();});
         loadSettings();
         RED.comms.connect();

public/red/nodes.js

@@ -394,7 +394,7 @@ RED.nodes = (function() {
             var wires = links.filter(function(d) { return d.source === p });
             for (var i=0;i<wires.length;i++) {
                 var w = wires[i];
-                if (w.target.id != p.id) {
+                if (w.target.type != "subflow") {
                     nIn.wires.push({id:w.target.id})
                 }
             }

public/red/ui/menu.js

@@ -47,8 +47,8 @@ RED.menu = (function() {
             item = $('<li></li>');
             var link = $('<a '+(opt.id?'id="'+opt.id+'" ':'')+'tabindex="-1" href="#">'+
                 (opt.toggle?'<i class="fa fa-check pull-right"></i>':'')+
-                (opt.icon?'<i class="'+opt.icon+'"></i> ':'')+
+                (opt.icon!==undefined?'<i class="'+(opt.icon?opt.icon:'" style="display: inline-block;"')+'"></i> ':"")+
-                opt.label+
+                '<span class="menu-label">'+opt.label+'</span>'+
                 '</a>').appendTo(item);
 
             menuItems[opt.id] = opt;
@@ -67,6 +67,11 @@ RED.menu = (function() {
                 setState();
             } else if (opt.href) {
                 link.attr("target","_blank").attr("href",opt.href);
+            } else if (!opt.options) {
+                item.addClass("disabled");
+                link.click(function(event) {
+                    event.preventDefault();
+                });
             }
             if (opt.options) {
                 item.addClass("dropdown-submenu pull-left");
@@ -79,6 +84,17 @@ RED.menu = (function() {
             if (opt.disabled) {
                 item.addClass("disabled");
             }
+            if (opt.tip) {
+                item.popover({
+                    placement:"left",
+                    trigger: "hover",
+                    delay: { show: 350, hide: 20 },
+                    html: true,
+                    container:'body',
+                    content: opt.tip
+                });
+            }
+            
         }
 
 
@@ -89,7 +105,7 @@ RED.menu = (function() {
 
         var button = $("#"+options.id);
         
-        var topMenu = $("<ul/>",{class:"dropdown-menu"}).insertAfter(button);
+        var topMenu = $("<ul/>",{id:options.id+"-submenu", class:"dropdown-menu pull-right"}).insertAfter(button);
 
         for (var i=0;i<options.options.length;i++) {
             var opt = options.options[i];

public/style.css

@@ -74,6 +74,19 @@ span.logo span {
 span.logo img {
     height: 18px;
 }
+#header ul.header-toolbar {
+    padding: 0;
+    margin: 0;
+    list-style: none;
+}
+
+#header ul.header-toolbar > li {
+    display: inline-block;
+    padding: 0;
+    margin: 0;
+    position: relative;
+}
+
 .button {
    -webkit-user-select: none;
    -khtml-user-select: none;
@@ -83,6 +96,8 @@ span.logo img {
 }
 
 #header .button {
+    min-width: 20px;
+    text-align: center;
     line-height: 22px;
     display: inline-block;
     font-size: 14px;
@@ -90,7 +105,7 @@ span.logo img {
     text-decoration: none;
     border-radius: 3px;
     color: #ccc;
-    margin: auto 10px;
+    margin: auto 5px;
     vertical-align: middle;
 }
 #header .button:not(.disabled):hover {

red/api/flows.js

@@ -28,11 +28,13 @@ module.exports = {
     },
     post: function(req,res) {
         var flows = req.body;
-        redNodes.setFlows(flows).then(function() {
+        var deploymentType = req.get("Node-RED-Deployment-Type")||"full";
+        redNodes.setFlows(flows,deploymentType).then(function() {
             res.send(204);
         }).otherwise(function(err) {
             util.log("[red] Error saving flows : "+err);
             res.send(500,err.message);
+            console.log(err.stack);
         });
     }
 }

red/nodes/Flow.js

@@ -0,0 +1,638 @@
+/**
+ * Copyright 2014 IBM Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ **/
+
+var util = require("util");
+var when = require("when");
+var clone = require("clone");
+
+var typeRegistry = require("./registry");
+var credentials = require("./credentials");
+var redUtil = require("../util");
+var events = require("../events");
+
+function getID() {
+    return (1+Math.random()*4294967295).toString(16);
+}
+
+function createNode(type,config) {
+    var nn = null;
+    var nt = typeRegistry.get(type);
+    if (nt) {
+        try {
+            nn = new nt(clone(config));
+        }
+        catch (err) {
+            util.log("[red] "+type+" : "+err);
+        }
+    } else {
+        util.log("[red] unknown type: "+type);
+    }
+    return nn;
+}
+
+
+function createSubflow(sf,sfn,subflows) {
+    //console.log("CREATE SUBFLOW",sf.config.id,sfn.id);
+    var nodes = [];
+    var node_map = {};
+    var newNodes = [];
+    var node;
+    var wires;
+    var i,j,k;
+    
+    // Clone all of the subflow node definitions and give them new IDs
+    for (i=0;i<sf.nodes.length;i++) {
+        node = clone(sf.nodes[i].config);
+        var nid = getID();
+        node_map[node.id] = node;
+        node._alias = node.id;
+        node.id = nid;
+        newNodes.push(node);
+    }
+    // Update all subflow interior wiring to reflect new node IDs
+    for (i=0;i<newNodes.length;i++) {
+        node = newNodes[i];
+        var outputs = node.wires;
+        
+        for (j=0;j<outputs.length;j++) {
+            wires = outputs[j];
+            for (k=0;k<wires.length;k++) {
+                outputs[j][k] = node_map[outputs[j][k]].id
+            }
+        }
+    }
+    
+    // Create a subflow node to accept inbound messages and route appropriately
+    var Node = require("./Node");
+    var subflowInstance = {
+        id: sfn.id,
+        type: sfn.type,
+        name: sfn.name,
+        wires: []
+    }
+    if (sf.config.in) {
+        subflowInstance.wires = sf.config.in.map(function(n) { return n.wires.map(function(w) { return node_map[w.id].id;})})
+        subflowInstance._originalWires = clone(subflowInstance.wires);
+    }
+    var subflowNode = new Node(subflowInstance);
+    
+    subflowNode.on("input", function(msg) { this.send(msg);});
+    
+    
+    subflowNode._updateWires = subflowNode.updateWires;
+    
+    subflowNode.updateWires = function(newWires) {
+        // Wire the subflow outputs
+        if (sf.config.out) {
+            var node,wires,i,j;
+            // Restore the original wiring to the internal nodes
+            
+            subflowInstance.wires = clone(subflowInstance._originalWires);
+            
+            for (i=0;i<sf.config.out.length;i++) {
+                wires = sf.config.out[i].wires;
+                for (j=0;j<wires.length;j++) {
+                    if (wires[j].id != sf.config.id) {
+                        node = node_map[wires[j].id];
+                        if (node._originalWires) {
+                            node.wires = clone(node._originalWires);
+                        }
+                    }
+                }
+            }
+            
+            var modifiedNodes = {};
+            var subflowInstanceModified = false;
+            
+            for (i=0;i<sf.config.out.length;i++) {
+                wires = sf.config.out[i].wires;
+                for (j=0;j<wires.length;j++) {
+                    if (wires[j].id === sf.config.id) {
+                        subflowInstance.wires[wires[j].port] = subflowInstance.wires[wires[j].port].concat(newWires[i]);
+                        subflowInstanceModified = true;
+                    } else {
+                        node = node_map[wires[j].id];
+                        node.wires[wires[j].port] = node.wires[wires[j].port].concat(newWires[i]);
+                        modifiedNodes[node.id] = node;
+                    }
+                }
+            }
+        }
+        Object.keys(modifiedNodes).forEach(function(id) {
+            var node = modifiedNodes[id];
+            subflowNode.instanceNodes[id].updateWires(node.wires);
+        });
+        if (subflowInstanceModified) {
+            subflowNode._updateWires(subflowInstance.wires);
+        }
+    }
+    
+    nodes.push(subflowNode);
+
+    // Wire the subflow outputs
+    if (sf.config.out) {
+        var modifiedNodes = {};
+        for (i=0;i<sf.config.out.length;i++) {
+            wires = sf.config.out[i].wires;
+            for (j=0;j<wires.length;j++) {
+                if (wires[j].id === sf.config.id) {
+                    // A subflow input wired straight to a subflow output
+                    subflowInstance.wires[wires[j].port] = subflowInstance.wires[wires[j].port].concat(sfn.wires[i])
+                    subflowNode._updateWires(subflowInstance.wires);
+                } else {
+                    node = node_map[wires[j].id];
+                    modifiedNodes[node.id] = node;
+                    if (!node._originalWires) {
+                        node._originalWires = clone(node.wires);
+                    }
+                    node.wires[wires[j].port] = node.wires[wires[j].port].concat(sfn.wires[i]);
+                }
+            }
+        }
+    }
+    
+    // Instantiate the nodes
+    for (i=0;i<newNodes.length;i++) {
+        node = newNodes[i];
+        var type = node.type;
+        
+        var m = /^subflow:(.+)$/.exec(type);
+        if (!m) {
+            nodes.push(createNode(type,node));
+        } else {
+            var subflowId = m[1];
+            nodes = nodes.concat(createSubflow(subflows[subflowId],node,subflows));
+        }
+    }
+    
+    subflowNode.instanceNodes = {};
+    
+    nodes.forEach(function(node) {
+       subflowNode.instanceNodes[node.id] = node;   
+    });
+    
+    return nodes;
+}
+
+
+function diffNodeConfigs(oldNode,newNode) {
+    if (oldNode == null) {
+        return true;
+    } else {
+        for (var p in newNode) {
+            if (newNode.hasOwnProperty(p) && p != "x" && p != "y" && p != "wires") {
+                if (!redUtil.compareObjects(oldNode[p],newNode[p])) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+
+var subflowInstanceRE = /^subflow:(.+)$/;
+
+function Flow(config) {
+    this.activeNodes = {};
+    this.subflowInstanceNodes = {};
+
+    this.parseConfig(config);
+    
+    
+}
+
+Flow.prototype.parseConfig = function(config) {
+    var i;
+    this.config = config;
+    
+    
+    this.allNodes = {};
+    
+    this.nodes = {};
+    this.subflows = {};
+    
+    var unknownTypes = {};
+    
+    for (i=0;i<this.config.length;i++) {
+        var nodeConfig = this.config[i];
+        var nodeType = nodeConfig.type;
+        if (nodeType == "subflow") {
+            this.subflows[nodeConfig.id] = {
+                type: "subflow",
+                config: nodeConfig,
+                nodes: []
+            }
+        }
+        
+    }
+    //console.log("Known subflows:",Object.keys(this.subflows));
+    
+    for (i=0;i<this.config.length;i++) {
+        var nodeConfig = this.config[i];
+        
+        this.allNodes[nodeConfig.id] = nodeConfig;
+        
+        var nodeType = nodeConfig.type;
+        
+        if (nodeConfig.credentials) {
+            credentials.extract(nodeConfig);
+            delete nodeConfig.credentials;
+        }
+        
+        if (nodeType != "tab" && nodeType != "subflow") {
+            var m = subflowInstanceRE.exec(nodeType);
+            if ((m && !this.subflows[m[1]]) || (!m && !typeRegistry.get(nodeType))) {
+                // This is an unknown subflow or an unknown type
+                unknownTypes[nodeType] = true;
+            } else {
+                var nodeInfo = {
+                    type: nodeType,
+                    config:nodeConfig
+                }
+                if (m) {
+                    nodeInfo.subflow = m[1];
+                }
+                if (this.subflows[nodeConfig.z]) {
+                    this.subflows[nodeConfig.z].nodes.push(nodeInfo);
+                } else {
+                    this.nodes[nodeConfig.id] = nodeInfo;
+                }
+            }
+        }
+    }
+    
+    //console.log("NODES");
+    //for (i in this.nodes) {
+    //    if (this.nodes.hasOwnProperty(i)) {
+    //        console.log(" ",i,this.nodes[i].type,this.nodes[i].config.name||"");
+    //    }
+    //}
+    //console.log("SUBFLOWS");
+    //for (i in this.subflows) {
+    //    if (this.subflows.hasOwnProperty(i)) {
+    //        console.log(" ",i,this.subflows[i].type,this.subflows[i].config.name||"");
+    //        for (var j=0;j<this.subflows[i].nodes.length;j++) {
+    //            console.log("     ",this.subflows[i].nodes[j].config.id,this.subflows[i].nodes[j].type,this.subflows[i].nodes[j].config.name||"");
+    //        }
+    //    }
+    //}
+    
+    this.missingTypes = Object.keys(unknownTypes);    
+}
+
+Flow.prototype.start = function() {
+    if (this.missingTypes.length > 0) {
+        throw new Error("missing types");
+    }
+    
+    events.emit("nodes-starting");
+
+    for (var id in this.nodes) {
+        if (this.nodes.hasOwnProperty(id)) {
+            var node = this.nodes[id];
+            if (!node.subflow) {
+                if (!this.activeNodes[id]) {
+                    this.activeNodes[id] = createNode(node.type,node.config);
+                    //console.log(id,"created");
+                } else {
+                    //console.log(id,"already running");
+                }
+            } else {
+                if (!this.subflowInstanceNodes[id]) {
+                    var nodes = createSubflow(this.subflows[node.subflow],node.config,this.subflows);
+                    this.subflowInstanceNodes[id] = nodes.map(function(n) { return n.id});
+                    for (var i=0;i<nodes.length;i++) {
+                        this.activeNodes[nodes[i].id] = nodes[i];
+                    }
+                    //console.log(id,"(sf) created");
+                } else {
+                    //console.log(id,"(sf) already running");
+                }
+            }
+        }
+    }
+    credentials.clean(this.config);
+    events.emit("nodes-started");
+}
+
+Flow.prototype.stop = function(nodeList) {
+    nodeList = nodeList || Object.keys(this.activeNodes);
+    var flow = this;
+    return when.promise(function(resolve) {
+        events.emit("nodes-stopping");
+        var promises = [];
+        for (var i=0;i<nodeList.length;i++) {
+            var node = flow.activeNodes[nodeList[i]];
+            if (node) {
+                try {
+                    var p = node.close();
+                    if (p) {
+                        promises.push(p);
+                    }
+                } catch(err) {
+                    node.error(err);
+                }
+                delete flow.subflowInstanceNodes[nodeList[i]];
+                delete flow.activeNodes[nodeList[i]];
+            }
+        }
+        when.settle(promises).then(function() {
+            events.emit("nodes-stopped");
+            resolve();
+        });
+    });
+}
+
+Flow.prototype.getMissingTypes = function() { 
+    return this.missingTypes;
+}
+
+Flow.prototype.typeRegistered = function(type) {
+    if (this.missingTypes.length > 0) {
+        var i = this.missingTypes.indexOf(type);
+        if (i != -1) {
+            this.missingTypes.splice(i,1);
+            if (this.missingTypes.length === 0) {
+                this.start();
+            }
+        }
+    }
+    
+}
+
+Flow.prototype.getNode = function(id) {
+    return this.activeNodes[id];
+}
+
+Flow.prototype.getFlow = function() {
+    //console.log(this.config);
+    return this.config;
+}
+
+Flow.prototype.applyConfig = function(config,type) {
+    var diff = this.diffFlow(config);
+    //console.log(diff);
+    //var diff = {
+    //    deleted:[]
+    //    changed:[]
+    //    linked:[]
+    //    wiringChanged: []
+    //}
+    
+    var nodesToStop = [];
+    var nodesToCreate = [];
+    var nodesToRewire = diff.wiringChanged;
+    
+    if (type == "nodes") {
+        nodesToStop = diff.deleted.concat(diff.changed);
+        nodesToCreate = diff.changed;
+    } else if (type == "flows") {
+        nodesToStop = diff.deleted.concat(diff.changed).concat(diff.linked);
+        nodesToCreate = diff.changed.concat(diff.linked);
+    }
+    var activeNodesToStop = [];
+    
+    for (var i=0;i<nodesToStop.length;i++) {
+        var id = nodesToStop[i];
+        if (this.subflowInstanceNodes[id]) {
+            activeNodesToStop = activeNodesToStop.concat(this.subflowInstanceNodes[id]);
+        } else if (this.activeNodes[id]) {
+            activeNodesToStop.push(id);
+        }
+    }
+    
+    //console.log(activeNodesToStop);
+    
+    var flow = this;
+    return this.stop(activeNodesToStop).then(function() {
+        flow.parseConfig(config);
+        for (var i=0;i<nodesToRewire.length;i++) {
+            var node = flow.activeNodes[nodesToRewire[i]];
+            if (node) {
+                node.updateWires(flow.allNodes[node.id].wires);
+            }
+        }
+        flow.start();
+    })
+}
+
+Flow.prototype.diffFlow = function(config) {
+    var flow = this;
+    var configNodes = {};
+    var changedNodes = {};
+    var deletedNodes = {};
+    var linkChangedNodes = {};
+    
+    var activeLinks = {};
+    var newLinks = {};
+    
+    var changedSubflowStack = [];
+    var changedSubflows = {};
+    
+    var buildNodeLinks = function(nodeLinks,n,nodes) {
+        nodeLinks[n.id] = nodeLinks[n.id] || [];
+        if (n.wires) {
+            for (var j=0;j<n.wires.length;j++) {
+                var wires = n.wires[j];
+                for (var k=0;k<wires.length;k++) {
+                    nodeLinks[n.id].push(wires[k]);
+                    var nn = nodes[wires[k]];
+                    if (nn) {
+                        nodeLinks[nn.id] = nodeLinks[nn.id] || [];
+                        nodeLinks[nn.id].push(n.id);
+                    }
+                }
+            }
+        }
+    }
+    
+    config.forEach(function(node) {
+        configNodes[node.id] = node;
+    });
+    
+    config.forEach(function(node) {
+        var changed = false;
+        if (node.credentials) {
+            changed = true;
+            delete node.credentials;
+        } else {
+            changed = diffNodeConfigs(flow.allNodes[node.id],node);
+            if (!changed) {
+                if (configNodes[node.z] && configNodes[node.z].type == "subflow") {
+                    var originalNode = flow.allNodes[node.id];
+                    if (originalNode && !redUtil.compareObjects(originalNode.wires,node.wires)) {
+                        // This is a node in a subflow whose wiring has changed. Mark subflow as changed
+                        changed = true;
+                    }
+                }
+            }
+        }
+        if (changed) {
+            changedNodes[node.id] = node;
+        }
+    });
+    
+    this.config.forEach(function(node) {
+        if (!configNodes[node.id]) {
+            deletedNodes[node.id] = node;
+        }
+        buildNodeLinks(activeLinks,node,flow.allNodes);
+    });
+    
+    this.config.forEach(function(node) {
+        for (var prop in node) {
+            if (node.hasOwnProperty(prop) && prop != "z") {
+                // This node has a property that references a changed node
+                // Assume it is a config node change and mark this node as
+                // changed.
+                if (changedNodes[node[prop]]) {
+                    changedNodes[node.id] = node;
+                }
+            }
+        }
+            
+    });
+    
+    var checkSubflowMembership = function(nodes,id) {
+        var node = nodes[id];
+        if (node) {
+            if (node.type == "subflow") {
+                changedSubflows[id] = node;
+                changedSubflowStack.push(id);
+            } else if (nodes[node.z] && nodes[node.z].type == "subflow") {
+                if (!changedSubflows[node.z]) {
+                    changedSubflows[node.z] = nodes[node.z];
+                    changedSubflowStack.push(node.z);
+                }
+            }
+        }
+    };
+    
+    Object.keys(changedNodes).forEach(function(n) { checkSubflowMembership(configNodes,n)});
+    Object.keys(deletedNodes).forEach(function(n) { checkSubflowMembership(flow.allNodes,n)});
+    
+    while (changedSubflowStack.length > 0) {
+        var subflowId = changedSubflowStack.pop();
+        
+        config.forEach(function(node) {
+            if (node.type == "subflow:"+subflowId) {
+                if (!changedNodes[node.id]) {
+                    changedNodes[node.id] = node;
+                    checkSubflowMembership(configNodes,node.id);
+                }
+            }
+        });
+        
+    }
+    
+    config.forEach(function(node) {
+        buildNodeLinks(newLinks,node,configNodes);
+    });
+    
+    var markLinkedNodes = function(linkChanged,changedNodes,linkMap,allNodes) {
+        var stack = Object.keys(changedNodes);
+        var visited = {};
+        
+        while(stack.length > 0) {
+            var id = stack.pop();
+                
+            var linkedNodes = linkMap[id];
+            if (linkedNodes) {
+                for (var i=0;i<linkedNodes.length;i++) {
+                    linkedNodeId = linkedNodes[i];
+                    if (changedNodes[linkedNodeId] || linkChanged[linkedNodeId]) {
+                        // Do nothing - this linked node is already marked as changed, so will get done
+                    } else {
+                        linkChanged[linkedNodeId] = true;
+                        stack.push(linkedNodeId);
+                    }
+                }
+            }
+        }
+    }
+    
+    markLinkedNodes(linkChangedNodes,changedNodes,newLinks,configNodes);
+    markLinkedNodes(linkChangedNodes,deletedNodes,activeLinks,flow.allNodes);
+    
+    
+    var modifiedLinkNodes = {};
+    
+    config.forEach(function(node) {
+        if (!changedNodes[node.id]) {
+            // only concerned about unchanged nodes whose wiring may have changed
+            var newNodeLinks = newLinks[node.id];
+            var oldNodeLinks = activeLinks[node.id];
+            
+            var newLinkMap = {};
+            newNodeLinks.forEach(function(l) { newLinkMap[l] = (newLinkMap[l]||0)+1;});
+            
+            var oldLinkMap = {};
+            oldNodeLinks.forEach(function(l) { oldLinkMap[l] = (oldLinkMap[l]||0)+1;});
+            
+            newNodeLinks.forEach(function(link) {
+                if (newLinkMap[link] != oldLinkMap[link]) {
+                    modifiedLinkNodes[node.id] = node;
+                    modifiedLinkNodes[link] = configNodes[link];
+                    linkChangedNodes[node.id] = node;
+                    linkChangedNodes[link] = configNodes[link];
+                }
+            });
+            
+            oldNodeLinks.forEach(function(link) {
+                if (newLinkMap[link] != oldLinkMap[link]) {
+                    modifiedLinkNodes[node.id] = node;
+                    modifiedLinkNodes[link] = configNodes[link];
+                    linkChangedNodes[node.id] = node;
+                    linkChangedNodes[link] = configNodes[link];
+                }
+            });
+        }
+    });
+    
+    markLinkedNodes(linkChangedNodes,modifiedLinkNodes,newLinks,configNodes);
+    
+    
+    //config.forEach(function(n) {
+    //    console.log((changedNodes[n.id]!=null)?"[C]":"[ ]",(linkChangedNodes[n.id]!=null)?"[L]":"[ ]","[ ]",n.id,n.type,n.name);
+    //});
+    
+    //Object.keys(deletedNodes).forEach(function(id) {
+    //    var n = flow.allNodes[id];
+    //    console.log("[ ] [ ] [D]",n.id,n.type);
+    //});
+    
+    var diff = {
+        deleted: Object.keys(deletedNodes),
+        changed: Object.keys(changedNodes),
+        linked: Object.keys(linkChangedNodes),
+        wiringChanged: []
+    }
+    
+    config.forEach(function(n) {
+        if (!configNodes[n.z] || configNodes[n.z].type != "subflow") {
+            var originalNode = flow.allNodes[n.id];
+            if (originalNode && !redUtil.compareObjects(originalNode.wires,n.wires)) {
+                diff.wiringChanged.push(n.id);
+            }
+        }
+    });
+       
+    return diff;
+    
+}
+
+module.exports = Flow;

red/nodes/Node.js

@@ -25,12 +25,19 @@ var comms = require("../comms");
 
 function Node(n) {
     this.id = n.id;
-    flows.add(this);
     this.type = n.type;
     if (n.name) {
         this.name = n.name;
     }
-    this.wires = n.wires || [];
+    flows.add(this);
+    this.updateWires(n.wires);
+}
+
+util.inherits(Node, EventEmitter);
+
+Node.prototype.updateWires = function(wires) {
+    this.wires = wires || [];
+    delete this._wire;
     
     var wc = 0;
     this.wires.forEach(function(w) {
@@ -40,14 +47,16 @@ function Node(n) {
     if (wc === 0) {
         // With nothing wired to the node, no-op send
         this.send = function(msg) {}
-    } else if (this.wires.length === 1 && this.wires[0].length === 1) {
+    } else {
+        this.send = Node.prototype.send;
+        if (this.wires.length === 1 && this.wires[0].length === 1) {
             // Single wire, so we can shortcut the send when
             // a single message is sent
             this._wire = this.wires[0][0];
         }
     }
 
-util.inherits(Node, EventEmitter);
+}
 
 Node.prototype._on = Node.prototype.on;
 
@@ -75,6 +84,7 @@ Node.prototype.close = function() {};
 
 
 Node.prototype.send = function(msg) {
+    console.log(this.id,this.type,this.wires);
     var msgSent = false;
     var node;
     

red/nodes/credentials.js

@@ -111,15 +111,18 @@ module.exports = {
 
     /**
      * Deletes any credentials for nodes that no longer exist
-     * @param getNode a function that can return a node for a given id
+     * @param config a flow config
      * @return a promise for the saving of credentials to storage
      */
-    clean: function (getNode) {
+    clean: function (config) {
+        var existingIds = {};
+        config.forEach(function(n) {
+            existingIds[n.id] = true;     
+        });
         var deletedCredentials = false;
         for (var c in credentialCache) {
             if (credentialCache.hasOwnProperty(c)) {
-                var n = getNode(c);
+                if (!existingIds[c]) {
-                if (!n) {
                     deletedCredentials = true;
                     delete credentialCache[c];
                 }
@@ -164,7 +167,6 @@ module.exports = {
             
             var dashedType = nodeType.replace(/\s+/g, '-');
             var definition = credentialsDef[dashedType];
-            
             if (!definition) {
                 util.log('Credential Type ' + nodeType + ' is not registered.');
                 return;

red/nodes/flows.js

@@ -20,235 +20,28 @@ var when = require("when");
 
 var typeRegistry = require("./registry");
 var credentials = require("./credentials");
+var Flow = require("./Flow");
 var log = require("../log");
 var events = require("../events");
 var redUtil = require("../util");
-
 var storage = null;
 
+
+var activeFlow = null;
+
 var nodes = {};
 var subflows = {};
 var activeConfig = [];
 var activeConfigNodes = {};
 
-var missingTypes = [];
-
 events.on('type-registered',function(type) {
-        if (missingTypes.length > 0) {
+    if (activeFlow) {
-            var i = missingTypes.indexOf(type);
+        if (activeFlow.typeRegistered(type)) {
-            if (i != -1) {
-                missingTypes.splice(i,1);
             util.log("[red] Missing type registered: "+type);
-                if (missingTypes.length === 0) {
-                    parseConfig();
-                }
         }
     }
 });
 
-function getID() {
-    return (1+Math.random()*4294967295).toString(16);
-}
-
-function createSubflow(sf,sfn) {
-    var node_map = {};
-    var newNodes = [];
-    var node;
-    var wires;
-    var i,j,k;
-    
-    // Clone all of the subflow node definitions and give them new IDs
-    for (i=0;i<sf.nodes.length;i++) {
-        node = clone(sf.nodes[i]);
-        var nid = getID();
-        node_map[node.id] = node;
-        node.id = nid;
-        newNodes.push(node);
-    }
-    // Update all subflow interior wiring to reflect new node IDs
-    for (i=0;i<newNodes.length;i++) {
-        node = newNodes[i];
-        var outputs = node.wires;
-        
-        for (j=0;j<outputs.length;j++) {
-            wires = outputs[j];
-            for (k=0;k<wires.length;k++) {
-                outputs[j][k] = node_map[outputs[j][k]].id
-            }
-        }
-    }
-    
-    // Create a subflow node to accept inbound messages and route appropriately
-    var Node = require("./Node");
-    var subflowInstance = {
-        id: sfn.id,
-        type: sfn.type,
-        name: sfn.name,
-        wires: []
-    }
-    if (sf.in) {
-        subflowInstance.wires = sf.in.map(function(n) { return n.wires.map(function(w) { return node_map[w.id].id;})})
-    }
-    var subflowNode = new Node(subflowInstance);
-    subflowNode.on("input", function(msg) { this.send(msg);});
-
-    // Wire the subflow outputs
-    if (sf.out) {
-        for (i=0;i<sf.out.length;i++) {
-            wires = sf.out[i].wires;
-            for (j=0;j<wires.length;j++) {
-                if (wires[j].id === sf.id) {
-                    node = subflowNode;
-                    delete subflowNode._wire;
-                } else {
-                    node = node_map[wires[j].id];
-                }
-                node.wires[wires[j].port] = node.wires[wires[j].port].concat(sfn.wires[i]);
-            }
-        }
-    }
-    
-    // Instantiate the nodes
-    for (i=0;i<newNodes.length;i++) {
-        node = newNodes[i];
-        var nn = null;
-        var type = node.type;
-        
-        var m = /^subflow:(.+)$/.exec(type);
-        if (!m) {
-            var nt = typeRegistry.get(type);
-            if (nt) {
-                try {
-                    nn = new nt(node);
-                }
-                catch (err) {
-                    util.log("[red] "+type+" : "+err);
-                }
-            }
-            if (nn === null) {
-                util.log("[red] unknown type: "+type);
-            }
-        } else {
-            var subflowId = m[1];
-            createSubflow(subflows[subflowId],node);
-        }
-    }
-    
-}
-
-/**
- * Parses the current activeConfig and creates the required node instances
- */ 
-function parseConfig() {
-    var i;
-    var nt;
-    var type;
-    var subflow;
-    missingTypes = [];
-    activeConfigNodes = {};
-    
-    // Scan the configuration for any unknown node types
-    for (i=0;i<activeConfig.length;i++) {
-        type = activeConfig[i].type;
-        // TODO: remove workspace in next release+1
-        if (type != "workspace" && type != "tab" && !/^subflow($|:.+$)/.test(type)) {
-            nt = typeRegistry.get(type);
-            if (!nt && missingTypes.indexOf(type) == -1) {
-                missingTypes.push(type);
-            }
-        }
-    }
-    // Abort if there are any missing types
-    if (missingTypes.length > 0) {
-        util.log("[red] Waiting for missing types to be registered:");
-        for (i=0;i<missingTypes.length;i++) {
-            util.log("[red]  - "+missingTypes[i]);
-        }
-        return;
-    }
-
-    util.log("[red] Starting flows");
-    events.emit("nodes-starting");
-
-    for (i=0;i<activeConfig.length;i++) {
-        type = activeConfig[i].type;
-        if (type === "subflow") {
-            subflow = activeConfig[i];
-            subflow.nodes = [];
-            subflow.instances = [];
-            subflows[subflow.id] = subflow;
-            
-        }
-    }
-    
-    for (i=0;i<activeConfig.length;i++) {
-        if (subflows[activeConfig[i].z]) {
-            subflow = subflows[activeConfig[i].z];
-            subflow.nodes.push(activeConfig[i]);
-        }
-    }
-    var subflowNameRE = /^subflow:(.+)$/;
-    
-    // Instantiate each node in the flow
-    for (i=0;i<activeConfig.length;i++) {
-        activeConfigNodes[activeConfig[i].id] = activeConfig[i];
-        var nn = null;
-        type = activeConfig[i].type;
-        
-        var m = subflowNameRE.exec(type);
-        if (!m) {
-            // TODO: remove workspace in next release+1
-            if (type != "workspace" && type != "tab" && type != "subflow" && !subflows[activeConfig[i].z]) {
-                nt = typeRegistry.get(type);
-                if (nt) {
-                    try {
-                        nn = new nt(activeConfig[i]);
-                    }
-                    catch (err) {
-                        util.log("[red] "+type+" : "+err);
-                    }
-                }
-                if (nn === null) {
-                    util.log("[red] unknown type: "+type);
-                }
-            }
-        } else {
-            var subflowId = m[1];
-            createSubflow(subflows[subflowId],activeConfig[i]);
-        }
-    }
-    // Clean up any orphaned credentials
-    credentials.clean(flowNodes.get);
-    events.emit("nodes-started");
-}
-
-/**
- * Stops the current activeConfig
- */
-function stopFlows() {
-    if (activeConfig&&activeConfig.length > 0) {
-        util.log("[red] Stopping flows");
-    }
-    return flowNodes.clear();
-}
-
-
-function diffNodes(oldNode,newNode) {
-    if (oldNode == null) {
-        return true;
-    } else {
-        for (var p in newNode) {
-            if (newNode.hasOwnProperty(p) && p != "x" && p != "y") {
-                if (!redUtil.compareObjects(oldNode[p],newNode[p])) {
-                    return true;
-                    break;
-                }
-            }
-        }
-    }
-    return false;
-}
-
 var flowNodes = module.exports = {
     init: function(_storage) {
         storage = _storage;
@@ -261,13 +54,12 @@ var flowNodes = module.exports = {
     load: function() {
         return storage.getFlows().then(function(flows) {
             return credentials.load().then(function() {
-                activeConfig = flows;
+                activeFlow = new Flow(flows);
-                if (activeConfig && activeConfig.length > 0) {
+                flowNodes.startFlows();
-                    parseConfig();
-                }
             });
         }).otherwise(function(err) {
             util.log("[red] Error loading flows : "+err);
+            console.log(err.stack);
         });
     },
     
@@ -276,7 +68,7 @@ var flowNodes = module.exports = {
      * @param n the node to add
      */
     add: function(n) {
-        nodes[n.id] = n;
+        //console.log("ADDED NODE:",n.id,n.type,n.name||"");
         n.on("log",log.log);
     },
     
@@ -286,196 +78,114 @@ var flowNodes = module.exports = {
      * @return the node
      */
     get: function(i) {
-        return nodes[i];
+        return activeFlow.getNode(i);
     },
     
     /**
      * Stops all active nodes and clears the active set
      * @return a promise for the stopping of all active nodes
      */
-    clear: function() {
+    //clear: function(nodesToStop) {
-        return when.promise(function(resolve) {
+    //    var stopList;
-            events.emit("nodes-stopping");
+    //    if (nodesToStop == null) {
-            var promises = [];
+    //        stopList = Object.keys(nodes);
-            for (var n in nodes) {
+    //    } else {
-                if (nodes.hasOwnProperty(n)) {
+    //        stopList = Object.keys(nodesToStop);
-                    try {
+    //    }
-                        var p = nodes[n].close();
+    //    console.log(stopList);
-                        if (p) {
+    //    return when.promise(function(resolve) {
-                            promises.push(p);
+    //        events.emit("nodes-stopping");
-                        }
+    //        var promises = [];
-                    } catch(err) {
+    //        console.log("running nodes:",Object.keys(nodes).length);
-                        nodes[n].error(err);
+    //        for (var i=0;i<stopList.length;i++) {
-                    }
+    //            var node = nodes[stopList[i]];
-                }
+    //            if (node) {
-            }
+    //                try {
-            when.settle(promises).then(function() {
+    //                    var p = node.close();
-                events.emit("nodes-stopped");
+    //                    if (p) {
-                nodes = {};
+    //                        promises.push(p);
-                resolve();
+    //                    }
-            });
+    //                } catch(err) {
-        });
+    //                    node.error(err);
-    },
+    //                }
-    
+    //                delete nodes[stopList[i]];
-    /**
+    //                delete activeConfigNodes[stopList[i]];
-     * Provides an iterator over the active set of nodes
+    //            }
-     * @param cb a function to be called for each node in the active set
+    //        }
-     */
+    //        console.log("running nodes:",Object.keys(nodes).length);
-    each: function(cb) {
+    //        when.settle(promises).then(function() {
-        for (var n in nodes) {
+    //            events.emit("nodes-stopped");
-            if (nodes.hasOwnProperty(n)) {
+    //            resolve();
-                cb(nodes[n]);
+    //        });
-            }
+    //    });
-        }
+    //},
-    },
 
     /**
      * @return the active configuration
      */
     getFlows: function() {
-        return activeConfig;
+        return activeFlow.getFlow();
     },
     
     /**
      * Sets the current active config.
      * @param config the configuration to enable
+     * @param type the type of deployment to do: full (default), nodes, flows
      * @return a promise for the starting of the new flow
      */
-    setFlows: function (config) {
+    setFlows: function (config,type) {
-        //TODO: identify the deleted nodes
-        var newNodes = {};
-        var changedNodeStack = [];
-        var changedSubflowsObj = {};
-        var visited = {};
         
-        var nodeLinks = {};
+        type = type||"full";
-        var changedNodes = {};
-        var linkChangedNodes = {};
-        var deletedNodes = [];
         
-        for (var i=0; i<config.length; i++) {
+        var credentialsChanged = false;
-            var node = config[i];
+        
-            newNodes[node.id] = node;
+        var credentialSavePromise = null;
-            var changed = false;
+        
-            // Extract any credential updates
+        config.forEach(function(node) {
             if (node.credentials) {
                 credentials.extract(node);
+                credentialsChanged = true;
+            }
+        });
         
-                changed = true;
+        if (credentialsChanged) {
-                delete node.credentials;
+            credentialsSavePromise = credentials.save();
         } else {
-                // Check for any changes on the node
+            credentialSavePromise = when.resolve();
-                changed = diffNodes(activeConfigNodes[node.id],node);
         }
         
-            if (changed) {
-                changedNodes[node.id] = node;
-                changedNodeStack.push(node.id);
-                // If this is part of a subflow, mark the subflow as changed
-                if (activeConfigNodes[node.z] && activeConfigNodes[node.z].type == "subflow") {
-                    changedSubflowsObj[node.z] = true;
-                }
-            }
-        }
         
-        activeConfig.forEach(function(n) {
+        if (type=="full") {
-            if (!newNodes[n.id]) {
+            return credentialSavePromise
-                deletedNodes.push(n.id);
-                // Upstream nodes will be flagged as changed as their wires
-                // array will be different.
-                // Need to flag downstream nodes
-                if (n.wires) {
-                    for (var j=0;j<n.wires.length;j++) {
-                        var wires = n.wires[j];
-                        for (var k=0;k<wires.length;k++) {
-                            var nn = newNodes[wires[k]];
-                            if (nn) {
-                                linkChangedNodes[wires[k]] = nn;
-                            }
-                        }
-                    }
-                }
-            }
-        });
-        
-        // For all changed subflows, mark any instances as changed
-        // If the subflow instance exists in a subflow, recursively mark them all
-        var changedSubflows = Object.keys(changedSubflowsObj);
-        while (changedSubflows.length > 0) {
-            var newChangedSubflowsObj = {};
-            changedSubflows.forEach(function(id) {
-                changedNodes[id] = newNodes[id];
-            });
-            
-            var subflowNameRE = /^subflow:(.*)$/;
-            config.forEach(function(n) {
-                var m = subflowNameRE.exec(n.type);
-                if (m && changedSubflowsObj[m[1]]) {
-                    // This is an instance of a changed subflow
-                    changedNodes[n.id] = n;
-                    if (activeConfigNodes[n.z] && activeConfigNodes[n.z].type == "subflow" && !changedNodes[n.z]) {
-                        // This instance is itself in a subflow that has not yet been dealt with
-                        newChangedSubflowsObj[n.z] = true;
-                    }
-                }
-            });
-            changedSubflowsObj = newChangedSubflowsObj;
-            changedSubflows = Object.keys(newChangedSubflowsObj);
-        }
-        
-        // Build the list of what each node is connected to
-        config.forEach(function(n) {
-            nodeLinks[n.id] = nodeLinks[n.id] || [];
-            if (n.wires) {
-                for (var j=0;j<n.wires.length;j++) {
-                    var wires = n.wires[j];
-                    for (var k=0;k<wires.length;k++) {
-                        nodeLinks[n.id].push(wires[k]);
-                        var nn = newNodes[wires[k]];
-                        if (nn) {
-                            nodeLinks[nn.id] = nodeLinks[nn.id] || [];
-                            nodeLinks[nn.id].push(n.id);
-                        }
-                    }
-                }
-            }
-        });
-        
-        // For all of the changed nodes, mark all downstream and upstream
-        // nodes as linkChanged, and add them to the stack to propagate
-        while(changedNodeStack.length > 0) {
-            var nid = changedNodeStack.pop();
-            var n = newNodes[nid];
-            if (!visited[nid]) {
-                visited[nid] = true;
-                if (nodeLinks[nid]) {
-                    nodeLinks[nid].forEach(function(id) {
-                        var nn = newNodes[id];
-                        if (!changedNodes[id]) {
-                            linkChangedNodes[id] = nn;
-                            changedNodeStack.push(nn.id);
-                        }
-                    });
-                }
-            }
-        }
-
-        config.forEach(function(n) {
-            if (changedNodes[n.id]|| linkChangedNodes[n.id]) {
-                console.log(changedNodes[n.id]!=null,linkChangedNodes[n.id]!=null,n.id,n.type,n.name);
-            }
-        });
-        deletedNodes.forEach(function(n) {
-            console.log("Deleted:",n);
-        });
-        
-        return credentials.save()
                     .then(function() { return storage.saveFlows(config);})
-            .then(function() { return stopFlows();})
+                    .then(function() { return flowNodes.stopFlows(); })
-            .then(function () {
+                    .then(function() { activeFlow = new Flow(config); flowNodes.startFlows();});
-                activeConfig = config;
+        } else {
-                parseConfig();
+            return credentialSavePromise
-            });
+                    .then(function() { return storage.saveFlows(config);})
+                    .then(function() { return activeFlow.applyConfig(config,type); });
+        }
     },
-    stopFlows: stopFlows
+    startFlows: function() {
+        util.log("[red] Starting flows");
+        try {
+            activeFlow.start();
+        } catch(err) {
+            var missingTypes = activeFlow.getMissingTypes();
+            if (missingTypes.length > 0) {
+                util.log("[red] Waiting for missing types to be registered:");
+                for (i=0;i<missingTypes.length;i++) {
+                    util.log("[red]  - "+missingTypes[i]);
+                }
+            }
+        }
+        
+    },
+    stopFlows: function() {
+        util.log("[red] Stopping flows");
+        return activeFlow.stop();
+    }
 };
+
+var activeFlow = null;
+

red/nodes/index.js

@@ -39,8 +39,13 @@ function registerType(type,constructor,opts) {
  */
 function createNode(node,def) {
     Node.call(node,def);
-    var creds = credentials.get(node.id);
+    var id = node.id;
+    if (def._alias) {
+        id = def._alias;
+    }
+    var creds = credentials.get(id);
     if (creds) {
+        //console.log("Attaching credentials to ",node.id);
         node.credentials = creds;
     }
 }
@@ -57,7 +62,8 @@ function checkTypeInUse(id) {
         throw new Error("Unrecognised id: "+id);
     } else {
         var inUse = {};
-        flows.each(function(n) {
+        var config = flows.getFlows();
+        config.forEach(function(n) {
             inUse[n.type] = (inUse[n.type]||0)+1;
         });
         var nodesInUse = [];