v0.16.0

* WIP #824 Added extra logs

* WIP #824 Moved creation events to the local diff strategy

* WIP #824 Added deletion event to the local stored changes to apply

* WIP #824 Fixed variable name

* WIP #824 Fixed apply dependent creation changes

* WIP #824 Update local operation setAttr, getAttr

* WIP #824 Updated execpipeline save method

* WIP #824 Fixed code climate issue

I will probably remove all ArtifactFinder fn-ality

* WIP #824 Removed unused var

* WIP #824 update the meta on fast forward

.gitignore

@@ -33,3 +33,5 @@ node_modules
 tmp/
 test-tmp/
 blob-local-storage/
+src/seeds/nn/hash.txt
+src/seeds/pipeline/hash.txt

app.js

@@ -3,10 +3,16 @@
 
 var gmeConfig = require('./config'),
     webgme = require('webgme'),
+    path = require('path'),
+    rm_rf = require('rimraf'),
     myServer;
 
 webgme.addToRequireJsPaths(gmeConfig);
 
+// Clear seed hash info
+['nn', 'pipeline'].map(lib => path.join(__dirname, 'src', 'seeds', lib, 'hash.txt'))
+    .forEach(file => rm_rf.sync(file));
+
 myServer = new webgme.standaloneServer(gmeConfig);
 myServer.start(function (err) {
     if (err) {

bin/deepforge

@@ -117,7 +117,7 @@ var isLocalUri = function(protocol, uri) {
         uri.indexOf(protocol + '://127.0.0.1') === 0;
 };
 
-var checkMongo = function(args) {
+var checkMongo = function(args, notSilent) {
     // check the webgme config
     var gmeConfig = require('../config'),
         mongoUri = gmeConfig.mongo.uri;
@@ -129,15 +129,26 @@ var checkMongo = function(args) {
             console.log('MongoDB is already running!');
         } catch (e) {  // no pIds
             console.log('Starting MongoDB...');
-            startMongo(args, true);
+            var match = mongoUri.match(/:([0-9]+)/),
+                port = '80';
+
+            if (match) {
+                port = match[1];
+            }
+
+            startMongo(args, port, !notSilent);
         }
+    } else if (notSilent) {
+        console.log(`Cannot start remote mongo locally: ${mongoUri}`);
+    } else {
+        console.log(`Using remote mongo: ${mongoUri}`);
     }
 };
 
-var startMongo = function(args, silent) {
-    var job = rawSpawn('mongod', ['--dbpath', p(config.mongo.dir)], {
-        cwd: process.env.HOME
-    });
+var startMongo = function(args, port, silent) {
+    var opts = ['--dbpath', p(config.mongo.dir), '--port', port],
+        job = rawSpawn('mongod', opts, {cwd: process.env.HOME});
+
     if (!silent) {
         job.stdout.on('data',
             data => process.stdout.write(data.toString()));
@@ -293,7 +304,7 @@ program.command('start')
         }
 
         if (args.mongo) {
-            startMongo(args);
+            checkMongo(args, true);
         }
 
         if (!args.server && !args.worker && !args.mongo) {

config/components.json

@@ -16,7 +16,28 @@
         "cachePrefix": "deepforge-header"
     },
     "FloatingActionButton": {
-        "hideOnEmpty": true
+        "hideOnEmpty": true,
+        "pluginUIConfigs": {
+            "GenerateArchitecture": {
+                "icon": "description",
+                "hotkey": "shift enter",
+                "priority": -1
+            },
+            "ExecutePipeline": {
+                "icon": "play_arrow",
+                "hotkey": "shift enter",
+                "color": "green",
+                "priority": 1
+            },
+            "ImportTorch": {
+                "icon": "import_export",
+                "priority": -1
+            },
+            "GenerateExecFile": {
+                "icon": "play_for_work",
+                "priority": -1
+            }
+        }
     },
     "GenericUIProjectNavigatorController": {
         "rootMenuClass": "deepforge-logo",

config/config.base.js

@@ -19,7 +19,6 @@ config.plugin.allowBrowserExecution = true;
 config.plugin.allowServerExecution = true;
 
 config.executor.enable = true;
-config.executor.clearOldDataAtStartUp = true;
 
 config.visualization.extraCss.push('deepforge/styles/global.css');
 

config/config.local.js

@@ -7,7 +7,6 @@ var config = require('./config.default'),
 
 // Turn up the worker polling rate
 config.executor.workerRefreshInterval = 150;
-config.executor.clearOldDataAtStartUp = true,
 
 validateConfig(config);
 module.exports = config;

config/config.test.js

@@ -5,9 +5,11 @@
 
 'use strict';
 
-var config = require('./config.default');
+var config = require('./config.default'),
+    path = require('path');
 
 config.server.port = 9001;
 config.mongo.uri = 'mongodb://127.0.0.1:27017/webgme_tests';
+config.blob.fsDir = path.join(__dirname, '..', 'test-tmp', 'blob');
 
-module.exports = config;
+module.exports = config;

config/config.webgme.js

@@ -6,33 +6,34 @@
 var config = require('webgme/config/config.default'),
     validateConfig = require('webgme/config/validator');
 
-
 // The paths can be loaded from the webgme-setup.json
-config.plugin.basePaths.push('src/plugins');
-config.plugin.basePaths.push('node_modules/webgme-simple-nodes/src/plugins');
-config.visualization.layout.basePaths.push('node_modules/webgme-chflayout/src/layouts');
-config.visualization.decoratorPaths.push('src/decorators');
-config.visualization.decoratorPaths.push('node_modules/webgme-easydag/src/decorators');
-config.seedProjects.basePaths.push('src/seeds/nn');
-config.seedProjects.basePaths.push('src/seeds/devTests');
-config.seedProjects.basePaths.push('src/seeds/devUtilTests');
-config.seedProjects.basePaths.push('src/seeds/pipeline');
-config.seedProjects.basePaths.push('src/seeds/devPipelineTests');
-config.seedProjects.basePaths.push('src/seeds/project');
-config.seedProjects.basePaths.push('src/seeds/cifar10');
-config.seedProjects.basePaths.push('src/seeds/xor');
+config.plugin.basePaths.push(__dirname + '/../src/plugins');
+config.plugin.basePaths.push(__dirname + '/../node_modules/webgme-simple-nodes/src/plugins');
+config.visualization.layout.basePaths.push(__dirname + '/../node_modules/webgme-chflayout/src/layouts');
+config.visualization.decoratorPaths.push(__dirname + '/../src/decorators');
+config.visualization.decoratorPaths.push(__dirname + '/../node_modules/webgme-easydag/src/decorators');
+config.seedProjects.basePaths.push(__dirname + '/../src/seeds/nn');
+config.seedProjects.basePaths.push(__dirname + '/../src/seeds/devTests');
+config.seedProjects.basePaths.push(__dirname + '/../src/seeds/devUtilTests');
+config.seedProjects.basePaths.push(__dirname + '/../src/seeds/pipeline');
+config.seedProjects.basePaths.push(__dirname + '/../src/seeds/devPipelineTests');
+config.seedProjects.basePaths.push(__dirname + '/../src/seeds/project');
+config.seedProjects.basePaths.push(__dirname + '/../src/seeds/cifar10');
+config.seedProjects.basePaths.push(__dirname + '/../src/seeds/xor');
 
 
 
-config.visualization.panelPaths.push('node_modules/webgme-fab/src/visualizers/panels');
-config.visualization.panelPaths.push('node_modules/webgme-breadcrumbheader/src/visualizers/panels');
-config.visualization.panelPaths.push('node_modules/webgme-autoviz/src/visualizers/panels');
-config.visualization.panelPaths.push('node_modules/webgme-easydag/src/visualizers/panels');
-config.visualization.panelPaths.push('src/visualizers/panels');
+config.visualization.panelPaths.push(__dirname + '/../node_modules/webgme-fab/src/visualizers/panels');
+config.visualization.panelPaths.push(__dirname + '/../node_modules/webgme-breadcrumbheader/src/visualizers/panels');
+config.visualization.panelPaths.push(__dirname + '/../node_modules/webgme-autoviz/src/visualizers/panels');
+config.visualization.panelPaths.push(__dirname + '/../node_modules/webgme-easydag/src/visualizers/panels');
+config.visualization.panelPaths.push(__dirname + '/../src/visualizers/panels');
 
 
+config.rest.components['execution/logs'] = __dirname + '/../src/routers/JobLogsAPI/JobLogsAPI.js';
+
 // Visualizer descriptors
-config.visualization.visualizerDescriptors.push('./src/visualizers/Visualizers.json');
+config.visualization.visualizerDescriptors.push(__dirname + '/../src/visualizers/Visualizers.json');
 // Add requirejs paths
 config.requirejsPaths = {
   'EllipseDecorator': 'node_modules/webgme-easydag/src/decorators/EllipseDecorator',

install.sh

@@ -41,15 +41,9 @@ detect_profile() {
 }
 detect_profile
 
-command -v node >/dev/null 2>&1 || {
-    # No node! Install nvm
-    echo >&2 "NodeJS is not found. Installing (using nvm)...";
-    curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.1/install.sh | bash;
-    source $DETECTED_PROFILE
-    . $NVM_DIR/nvm.sh
-
+set_node_version() {
     # Install nodejs v6.2.0
-    echo "Installing nodejs v6.2.0"
+    echo "Installing NodeJS v6.2.0"
     nvm install v6.2.0
     nvm alias default v6.2.0
 
@@ -58,40 +52,21 @@ command -v node >/dev/null 2>&1 || {
 }
 
 command -v node >/dev/null 2>&1 || {
-    # No mongod!
-    echo >&2 "MongoDB is not found. Installing...";
-    if [[ `uname` == "Darwin" ]]; then
-        brew install mongodb
-    elif [[ "$(uname)" == 'Linux' ]]; then
+    # No node! Install nvm
+    echo >&2 "NodeJS is not found. Installing (using nvm)...";
+    curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.1/install.sh | bash;
+    source $DETECTED_PROFILE
+    . $NVM_DIR/nvm.sh
 
-        if [[ -r /etc/os-release ]]; then
-            # this will get the required information without dirtying any env state
-            DIST_VERS="$( ( . /etc/os-release &>/dev/null
-                            echo "$ID $VERSION_ID") )"
-            DISTRO="${DIST_VERS%% *}" # get our distro name
-            VERSION="${DIST_VERS##* }" # get our version number
-        elif [[ -r /etc/lsb-release ]]; then
-            DIST_VERS="$( ( . /etc/lsb-release &>/dev/null
-                            echo "${DISTRIB_ID,,} $DISTRIB_RELEASE") )"
-            DISTRO="${DIST_VERS%% *}" # get our distro name
-            VERSION="${DIST_VERS##* }" # get our version number
-        else # well, I'm out of ideas for now
-            echo '==> Failed to determine distro and version.'
-            exit 1
-        fi
+    set_node_version
+}
 
-        # Detect archlinux
-        if [[ "$DISTRO" = "arch" ]]; then
-            distribution="archlinux"
-            sudo pacman -S mongodb
-        # Detect Ubuntu
-        elif [[ "$DISTRO" = "ubuntu" ]]; then
-            export DEBIAN_FRONTEND=noninteractive
-            sudo apt-get install mongodb
-        else
-            NEEDS_MONGO=true
-        fi
-    fi
+# Check node version supports arrow fns and string templates
+node -e '() => console.log(`print "3": ${1+2}`)' >/dev/null 2>&1 || {
+    echo "Unsupported version of NodeJS."
+    echo ""
+    echo "Please update NodeJS to version 4.x.x or later (6.x.x recommended)"
+    exit 1
 }
 
 echo >&2 "Installing DeepForge...";

package.json

@@ -8,15 +8,16 @@
     "start-dev": "NODE_ENV=dev node app.js",
     "local": "node ./bin/start-local.js",
     "worker": "node ./bin/start-worker.js",
-    "test": "node ./node_modules/mocha/bin/mocha --recursive test",
+    "test": "mkdir ./test-tmp; node ./node_modules/mocha/bin/mocha --recursive test",
     "watch-test": "./node_modules/nodemon/bin/nodemon.js --exec 'node ./node_modules/mocha/bin/mocha --recursive test'",
     "build-nn": "node ./utils/nn-parser.js"
   },
-  "version": "0.14.1",
+  "version": "0.16.0",
   "dependencies": {
     "commander": "^2.9.0",
     "dotenv": "^2.0.0",
     "exists-file": "^2.1.0",
+    "express": "^4.14.0",
     "lodash.difference": "^4.1.2",
     "lodash.merge": "^4.5.1",
     "nodemon": "^1.9.2",

src/common/Constants.js

@@ -5,12 +5,27 @@ define({
     // DeepForge metadata creation in dist execution
     START_CMD: 'deepforge-cmd',
 
-    IMAGE: 'IMG',
+    IMAGE: {  // all prefixed w/ 'IMG' for simple upload detection
+        PREFIX: 'IMG',
+        BASIC: 'IMG-B',
+        CREATE: 'IMG-C',
+        UPDATE: 'IMG-U',
+        NAME: 'IMAGE-N'  // No upload required
+    },
 
     GRAPH_CREATE: 'GRAPH',
     GRAPH_PLOT: 'PLOT',
     GRAPH_CREATE_LINE: 'LINE',
 
     // Code Generation Constants
-    CTOR_ARGS_ATTR: 'ctor_arg_order'
+    CTOR_ARGS_ATTR: 'ctor_arg_order',
+
+    // Operation types
+    OP: {
+        INPUT: 'Input',
+        OUTPUT: 'Output'
+    },
+
+    // Job stdout update
+    STDOUT_UPDATE: 'stdout_update'
 });

src/common/JobLogsClient.js

@@ -0,0 +1,132 @@
+/* globals define */
+define([
+    'q',
+    'superagent'
+], function(
+    Q,
+    superagent
+) {
+    'use strict';
+
+    // Wrap the ability to read, update, and delete logs using the JobLogsAPI
+    var JobLogsClient = function(params) {
+        params = params || {};
+
+        this.logger = params.logger.fork('JobLogsClient');
+
+        // Get the server url
+        this.token = params.token;
+        this.origin = this._getServerUrl(params);
+        this.relativeUrl = '/execution/logs';
+        this.url = this.origin + this.relativeUrl;
+
+        this.logger.debug(`Setting url to ${this.url}`);
+
+        // Get the project, branch name
+        if (!(params.branchName && params.projectId)) {
+            throw Error('"branchName" and "projectId" required');
+        }
+        this.branch = params.branchName;
+        this.project = params.projectId;
+        this._modifiedJobs = [];
+
+        this.logger.debug(`Using <project>:<branch>: "${this.project}"/"${this.branch}"`);
+        this.logger.info('ctor finished');
+    };
+
+    JobLogsClient.prototype._getServerUrl = function(params) {
+        if (typeof window !== 'undefined') {
+            return window.location.origin;
+        }
+
+        // If not in browser, set using the params
+        var server = params.server || '127.0.0.1',
+            port = params.port || '80',
+            protocol = params.httpsecure ? 'https' : 'http';  // default is http
+
+        return params.origin || `${protocol}://${server}:${port}`;
+    };
+
+    // This method could be optimized - it could make a log of requests
+    JobLogsClient.prototype.fork = function(forkName) {
+        var jobIds = this._modifiedJobs,
+            deferred = Q.defer(),
+            url = [
+                this.url,
+                'migrate',
+                encodeURIComponent(this.project),
+                encodeURIComponent(this.branch),
+                encodeURIComponent(forkName)
+            ].join('/'),
+            req = superagent.post(url);
+
+        this.logger.info(`migrating ${jobIds.length} jobs from ${this.branch} to ${forkName} in ${this.project}`);
+        if (this.token) {
+            req.set('Authorization', 'Bearer ' + this.token);
+        }
+
+        req.send({jobs: jobIds})
+            .end((err, res) => {
+                if (err || res.status > 399) {
+                    return deferred.reject(err || res.status);
+                }
+
+                return deferred.resolve(res);
+            });
+
+        this.branch = forkName;
+        return deferred.promise;
+    };
+
+    JobLogsClient.prototype.getUrl = function(jobId) {
+        return [
+            this.url,
+            encodeURIComponent(this.project),
+            encodeURIComponent(this.branch),
+            encodeURIComponent(jobId)
+        ].join('/');
+    };
+
+    JobLogsClient.prototype._logRequest = function(method, jobId, content) {
+        var deferred = Q.defer(),
+            req = superagent[method](this.getUrl(jobId));
+
+        this.logger.info(`sending ${method} request to ${this.getUrl(jobId)}`);
+        if (this.token) {
+            req.set('Authorization', 'Bearer ' + this.token);
+        }
+
+        if (content) {
+            req = req.send(content);
+        }
+
+        req.end((err, res) => {
+            if (err || res.status > 399) {
+                return deferred.reject(err || res.status);
+            }
+
+            return deferred.resolve(res);
+        });
+
+        return deferred.promise;
+    };
+
+    JobLogsClient.prototype.appendTo = function(jobId, text) {
+        this._modifiedJobs.push(jobId);
+        this.logger.info(`Appending logs to ${jobId}`);
+        return this._logRequest('patch', jobId, {patch: text});
+    };
+
+    JobLogsClient.prototype.getLog = function(jobId) {
+        this.logger.info(`Getting logs for ${jobId}`);
+        return this._logRequest('get', jobId)
+            .then(res => res.text);
+    };
+
+    JobLogsClient.prototype.deleteLog = function(jobId) {
+        this.logger.info(`Deleting logs for ${jobId}`);
+        return this._logRequest('delete', jobId);
+    };
+
+    return JobLogsClient;
+});

src/common/plugin/LocalExecutor.js

@@ -2,14 +2,16 @@
 // This is an 'executor' containing the implementations of all local operations
 // These are all primitives in DeepForge
 define([
+    'deepforge/Constants'
 ], function(
+    CONSTANTS
 ) {
     'use strict';
     var LocalExecutor = function() {
     };
 
     // Should these be in lua?
-    LocalExecutor.prototype.ArtifactLoader = function(node) {
+    LocalExecutor.prototype[CONSTANTS.OP.INPUT] = function(node) {
         // Get the hash from the output node
         var hash;
         return this.core.loadChildren(node)
@@ -18,13 +20,13 @@ define([
                 var output = cntrs
                     .find(cntr => {
                         var metaNode = this.core.getMetaType(cntr),
-                            metaName = this.core.getAttribute(metaNode, 'name');
+                            metaName = this.getAttribute(metaNode, 'name');
                         return metaName === 'Outputs';
                     });
                 return this.core.loadChildren(output);
             })
             .then(dataNodes => {
-                hash = this.core.getAttribute(dataNodes[0], 'data');
+                hash = this.getAttribute(dataNodes[0], 'data');
                 return this.getOutputs(node);
             })
             .then(outputTuples => {
@@ -46,7 +48,7 @@ define([
         var hash,
             typeId = this.core.getPointerPath(node, 'type'),
             type,
-            artifactName = this.core.getAttribute(node, 'artifactName');
+            artifactName = this.getAttribute(node, 'artifactName');
 
         return this.core.loadByPath(this.rootNode, typeId)
             .then(_type => {
@@ -56,25 +58,20 @@ define([
             .then(saveDir => this.core.loadChildren(saveDir))
             .then(artifacts => {
                 return artifacts.find(artifact =>
-                    this.core.getAttribute(artifact, 'name') === artifactName &&
+                    this.getAttribute(artifact, 'name') === artifactName &&
                         this.isMetaTypeOf(artifact, type));
             })
             .then(matchingArtifact => {
-                hash = matchingArtifact && this.core.getAttribute(matchingArtifact, 'data');
+                hash = matchingArtifact && this.getAttribute(matchingArtifact, 'data');
                 // If no hash, just continue (the subsequent ops will receive 'nil')
                 if (!hash) {
                     return this.onOperationComplete(node);
                 } else {
                     return this.getOutputs(node)
                         .then(outputPairs => {
-                            var outputs = outputPairs.map(pair => pair[2]),
-                                paths;
-
-                            paths = outputs.map(output => this.core.getPath(output));
+                            var outputs = outputPairs.map(pair => pair[2]);
                             // Get the 'data' hash and store it in the output data ports
-                            this.logger.info(`Loading blob data (${hash}) to ${paths.map(p => `"${p}"`)}`);
-
-                            outputs.forEach(output => this.core.setAttribute(output, 'data', hash));
+                            outputs.forEach(output => this.setAttribute(output, 'data', hash));
 
                             this.onOperationComplete(node);
                         });
@@ -97,7 +94,7 @@ define([
 
                 if (containers.length > 1) {
                     saveDir = containers.find(c =>
-                        this.core.getAttribute(c, 'name').toLowerCase().indexOf('artifacts') > -1
+                        this.getAttribute(c, 'name').toLowerCase().indexOf('artifacts') > -1
                     ) || containers[0];
                 }
 
@@ -105,7 +102,7 @@ define([
             });
     };
 
-    LocalExecutor.prototype.Save = function(node) {
+    LocalExecutor.prototype[CONSTANTS.OP.OUTPUT] = function(node) {
         var parentNode,
             currNameHashPairs;
         
@@ -119,8 +116,8 @@ define([
             .then(artifacts => {
                 currNameHashPairs = artifacts
                     .map(node => [
-                        this.core.getAttribute(node, 'name'),
-                        this.core.getAttribute(node, 'data')
+                        this.getAttribute(node, 'name'),
+                        this.getAttribute(node, 'data')
                     ]);
                 return this.getInputs(node);
             })
@@ -140,9 +137,9 @@ define([
 
                 // Remove nodes that already exist
                 dataNodes = allDataNodes.filter(dataNode => {
-                    var hash = this.core.getAttribute(dataNode, 'data'),
+                    var hash = this.getAttribute(dataNode, 'data'),
                         name = this.core.getOwnAttribute(node, 'saveName') ||
-                            this.core.getAttribute(dataNode, 'name');
+                            this.getAttribute(dataNode, 'name');
 
                     return !(currNameHashPairs
                         .find(pair => pair[0] === name && pair[1] === hash));
@@ -154,10 +151,10 @@ define([
                         newName = this.core.getOwnAttribute(node, 'saveName');
                     if (newName) {
                         newNodes.forEach(node =>
-                            this.core.setAttribute(node, 'name', newName)
+                            this.setAttribute(node, 'name', newName)
                         );
                     }
-                    var hashes = dataNodes.map(n => this.core.getAttribute(n, 'data'));
+                    var hashes = dataNodes.map(n => this.getAttribute(n, 'data'));
                     this.logger.info(`saving hashes: ${hashes.map(h => `"${h}"`)}`);
                 } else if (allDataNodes.length === 0) {
                     this.logger.warn('No data nodes found!');

src/common/styles/global.css

@@ -1,22 +1,18 @@
-/* latin-ext */
-@font-face {
-  font-family: 'Audiowide';
-  font-style: normal;
-  font-weight: 400;
-  src: local('Audiowide'), local('Audiowide-Regular'), url(https://fonts.gstatic.com/s/audiowide/v4/7pSgz2MbVvTCvvm7vukSHxJtnKITppOI_IvcXXDNrsc.woff2) format('woff2');
-  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
-}
-/* latin */
-@font-face {
-  font-family: 'Audiowide';
-  font-style: normal;
-  font-weight: 400;
-  src: local('Audiowide'), local('Audiowide-Regular'), url(https://fonts.gstatic.com/s/audiowide/v4/8XtYtNKEyyZh481XVWfVOltXRa8TVwTICgirnJhmVJw.woff2) format('woff2');
-  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215, U+E0FF, U+EFFD, U+F000;
+li.deepforge-logo {
+    background-image: url(img/deepforge-logo.png);
+    background-repeat: no-repeat;
+    background-position: center;
+    width: 100px;
+    background-size: 95px;
 }
 
-.deepforge-logo .item-label {
-  font-family: 'Audiowide', cursive;
+li.deepforge-logo span {
+    visibility: hidden;
+}
+
+i.gme-icon {
+    background-image: url(img/deepforge-icon.png);
+    background-size: 15.20px 18px;
 }
 
 .create-node text {

src/common/utils.js

@@ -1,7 +1,13 @@
 /* globals define*/
-define([
-], function(
-) {
+(function(root, factory){
+    if(typeof define === 'function' && define.amd) {
+        define([], function(){
+            return (root.utils = factory());
+        });
+    } else if(typeof module === 'object' && module.exports) {
+        module.exports = (root.utils = factory());
+    }
+}(this, function() {
     var isBoolean = txt => {
         return typeof txt === 'boolean' || (txt === 'false' || txt === 'true');
     };
@@ -51,8 +57,37 @@ define([
         }
     };
 
+    // Resolving stdout
+    var resolveCarriageReturns = function(text) {
+        // resolve \r
+        var lines,
+            chars,
+            result,
+            i = 0;
+
+        text = text.replace(/\u0000/g, '');
+        lines = text.split('\n');
+        for (var l = lines.length-1; l >= 0; l--) {
+            i = 0;
+            chars = lines[l].split('');
+            result = [];
+
+            for (var c = 0; c < chars.length; c++) {
+                if (chars[c] === '\r') {
+                    i = 0;
+                }
+                result[i] = chars[c];
+                i++;
+            }
+            lines[l] = result.join('');
+        }
+        return lines;
+    };
+
+
     return {
         getSetterSchema: getSetterSchema,
+        resolveCarriageReturns: resolveCarriageReturns,
         abbr: abbr
     };
-});
+}));

src/common/viz/Execute.js

@@ -1,9 +1,11 @@
 /* globals define, WebGMEGlobal */
 // Mixin for executing jobs and pipelines
 define([
+    'q',
     'executor/ExecutorClient',
     'panel/FloatingActionButton/styles/Materialize'
 ], function(
+    Q,
     ExecutorClient,
     Materialize
 ) {
@@ -36,12 +38,20 @@ define([
         context.managerConfig.namespace = 'pipeline';
         context.managerConfig.activeNode = node.getId();
         method = opts.useSecondary ? 'runBrowserPlugin' : 'runServerPlugin';
+
+        if (method === 'runServerPlugin' &&
+            this.client.getBranchStatus() !== this.client.CONSTANTS.BRANCH_STATUS.SYNC) {
+
+            Materialize.toast('Cannot execute operations when client is out-of-sync', 2000);
+            return;
+        }
+
         this.client[method](pluginId, context, (err, result) => {
             var msg = err ? `${name} failed!` : `${name} executed successfully!`,
                 duration = err ? 4000 : 2000;
 
             // Check if it was canceled - if so, show that type of message
-            if (result) {
+            if (result && result.messages.length) {
                 msg = result.messages[0].message;
                 duration = 4000;
             }
@@ -75,13 +85,11 @@ define([
             job.getAttribute('secret') && job.getAttribute('jobId');
     };
 
-    Execute.prototype.stopJob = function(job) {
+    Execute.prototype.silentStopJob = function(job) {
         var jobHash,
-            jobId,
             secret;
 
         job = job || this.client.getNode(this._currentNodeId);
-        jobId = job.getId();
         jobHash = job.getAttribute('jobId');
         secret = job.getAttribute('secret');
         if (!jobHash || !secret) {
@@ -89,14 +97,95 @@ define([
             return;
         }
 
-        this.client.delAttributes(jobId, 'jobId');
-        this.client.delAttributes(jobId, 'secret');
-        this.client.setAttributes(jobId, 'status', 'canceled');
-
         return this._executor.cancelJob(jobHash, secret)
             .then(() => this.logger.info(`${jobHash} has been cancelled!`))
             .fail(err => this.logger.error(`Job cancel failed: ${err}`));
     };
 
+    Execute.prototype.stopJob = function(job, silent) {
+        var jobId;
+
+        job = job || this.client.getNode(this._currentNodeId);
+        jobId = job.getId();
+
+        this.silentStopJob(job);
+
+        if (!silent) {
+            this.client.startTransaction(`Stopping "${name}" job`);
+        }
+
+        this.client.delAttributes(jobId, 'jobId');
+        this.client.delAttributes(jobId, 'secret');
+        this.client.setAttributes(jobId, 'status', 'canceled');
+
+        if (!silent) {
+            this.client.completeTransaction();
+        }
+    };
+
+
+    Execute.prototype.loadChildren = function(id) {
+        var deferred = Q.defer(),
+            execNode = this.client.getNode(id || this._currentNodeId),
+            jobIds = execNode.getChildrenIds(),
+            jobsLoaded = !jobIds.length || this.client.getNode(jobIds[0]);
+
+        // May need to load the jobs...
+        if (!jobsLoaded) {
+            // Create a territory and load the nodes
+            var territory = {},
+                ui;
+
+            territory[id] = {children: 1};
+            ui = this.client.addUI(this, () => {
+                this.client.removeUI(ui);
+                deferred.resolve();
+            });
+            this.client.updateTerritory(ui, territory);
+        } else {
+            deferred.resolve();
+        }
+
+        return deferred.promise;
+    };
+
+    Execute.prototype.stopExecution = function(id, inTransaction) {
+        var execNode = this.client.getNode(id || this._currentNodeId);
+
+        return this.loadChildren(id)
+            .then(() => this._stopExecution(execNode, inTransaction));
+    };
+
+    Execute.prototype.silentStopExecution = function(id) {
+        var execNode = this.client.getNode(id || this._currentNodeId);
+
+        // Stop the execution w/o setting any attributes
+        return this.loadChildren(id)
+            .then(() => this._silentStopExecution(execNode));
+    };
+
+    Execute.prototype._stopExecution = function(execNode, inTransaction) {
+        var msg = `Canceling ${execNode.getAttribute('name')} execution`;
+
+        if (!inTransaction) {
+            this.client.startTransaction(msg);
+        }
+
+        this._silentStopExecution(execNode);
+        this.client.setAttributes(execNode.getId(), 'status', 'canceled');
+
+        if (!inTransaction) {
+            this.client.completeTransaction();
+        }
+    };
+
+    Execute.prototype._silentStopExecution = function(execNode) {
+        var jobIds = execNode.getChildrenIds();
+
+        jobIds.map(id => this.client.getNode(id))
+            .filter(job => this.isRunning(job))  // get running jobs
+            .forEach(job => this.silentStopJob(job));  // stop them
+    };
+
     return Execute;
 });

src/decorators/ArtifactOpDecorator/EasyDAG/ArtifactOpDecorator.EasyDAGWidget.js

@@ -1,12 +1,8 @@
 /*globals define, _*/
 /*jshint browser: true, camelcase: false*/
 
-/**
- * @author brollb / https://github.com/brollb
- */
-
 define([
-    'js/Constants',
+    'deepforge/Constants',
     'decorators/DcOpDecorator/EasyDAG/DcOpDecorator.EasyDAGWidget',
     'css!./ArtifactOpDecorator.EasyDAGWidget.css'
 ], function (
@@ -19,16 +15,17 @@ define([
     var ArtifactOpDecorator,
         DECORATOR_ID = 'ArtifactOpDecorator',
         CAST_OPTS = {
-            ArtifactLoader: {
-                ptr: 'artifact',
-                metaTgt: false
-            },
             ArtifactFinder: {
                 ptr: 'type',
                 metaTgt: true
             }
         };
 
+    CAST_OPTS[CONSTANTS.OP.INPUT] = {
+        ptr: 'artifact',
+        metaTgt: false
+    };
+
     // ArtifactOp nodes need to be able to...
     //     - dynamically change their outputs (downcast)
     ArtifactOpDecorator = function (options) {
@@ -74,7 +71,7 @@ define([
     };
 
     ArtifactOpDecorator.prototype.getDisplayName = function() {
-        var ptrName = this._node.baseName === 'ArtifactLoader' ? 'artifact' : 'type',
+        var ptrName = this._node.baseName === CONSTANTS.OP.INPUT ? 'artifact' : 'type',
             id = this._node.pointers[ptrName],
             name = this.nameFor[id] || this._node.name;
         return name;
@@ -91,7 +88,7 @@ define([
     ArtifactOpDecorator.prototype.updateTargetName = function(id, name) {
         DecoratorBase.prototype.updateTargetName.apply(this, arguments);
         // Update name
-        var ptrName = this._node.baseName === 'ArtifactLoader' ? 'artifact' : 'type';
+        var ptrName = this._node.baseName === CONSTANTS.OP.INPUT ? 'artifact' : 'type';
         if (this._node.pointers[ptrName] === id) {
             this._name = name;
             this.onResize();

src/decorators/JobDecorator/EasyDAG/JobDecorator.EasyDAGWidget.js

@@ -2,11 +2,13 @@
 /*jshint browser: true, camelcase: false*/
 
 define([
+    'deepforge/Constants',
     'decorators/EllipseDecorator/EasyDAG/EllipseDecorator.EasyDAGWidget',
     './PointerField.RO',
     './AttributeField.RO',
     'css!./JobDecorator.EasyDAGWidget.css'
 ], function (
+    CONSTANTS,
     EllipseDecorator,
     PointerField,
     AttributeField
@@ -49,12 +51,12 @@ define([
     JobDecorator.prototype.AttributeField = AttributeField;
     JobDecorator.prototype.PointerField = PointerField;
 
-    JobDecorator.prototype.isArtifactLoader = function() {
-        return this._node.name === 'ArtifactLoader';
+    JobDecorator.prototype.isInputOperation = function() {
+        return this._node.name === CONSTANTS.OP.INPUT;
     };
 
     JobDecorator.prototype.getDisplayName = function() {
-        if (this.isArtifactLoader()) {
+        if (this.isInputOperation()) {
             var id = this._node.pointers.artifact;
 
             // Try to look up the pointer name

src/plugins/CheckLibraries/CheckLibraries.js

@@ -0,0 +1,185 @@
+/*globals define*/
+/*jshint node:true, browser:true*/
+
+define([
+    'text!./metadata.json',
+    'module',
+    'path',
+    'fs',
+    'q',
+    'plugin/PluginBase'
+], function (
+    pluginMetadata,
+    module,
+    path,
+    fs,
+    Q,
+    PluginBase
+) {
+    'use strict';
+
+    pluginMetadata = JSON.parse(pluginMetadata);
+    var __dirname = path.dirname(module.uri),
+        SEEDS_DIR = path.join(__dirname, '..', '..', 'seeds');
+
+    /**
+     * Initializes a new instance of CheckLibraries.
+     * @class
+     * @augments {PluginBase}
+     * @classdesc This class represents the plugin CheckLibraries.
+     * @constructor
+     */
+    var CheckLibraries = function () {
+        // Call base class' constructor.
+        PluginBase.call(this);
+        this.pluginMetadata = pluginMetadata;
+        this.libraries = {};
+    };
+
+    /**
+     * Metadata associated with the plugin. Contains id, name, version, description, icon, configStructue etc.
+     * This is also available at the instance at this.pluginMetadata.
+     * @type {object}
+     */
+    CheckLibraries.metadata = pluginMetadata;
+
+    // Prototypical inheritance from PluginBase.
+    CheckLibraries.prototype = Object.create(PluginBase.prototype);
+    CheckLibraries.prototype.constructor = CheckLibraries;
+
+    /**
+     * Main function for the plugin to execute. This will perform the execution.
+     * Notes:
+     * - Always log with the provided logger.[error,warning,info,debug].
+     * - Do NOT put any user interaction logic UI, etc. inside this method.
+     * - callback always has to be called even if error happened.
+     *
+     * @param {function(string, plugin.PluginResult)} callback - the result callback
+     */
+    CheckLibraries.prototype.main = function (callback) {
+        var tuples;
+
+        return this.getAllLibraries()
+            .then(libs => {
+                tuples = libs.map(lib => {  // map to [name, version, dir]
+                    var version,
+                        hash,
+                        data,
+                        versionPath = this.getSeedVersionPath(lib);
+
+                    try {
+                        this.logger.info(`Checking for version info at ${versionPath}`);
+                        version = fs.readFileSync(versionPath, 'utf8');
+                        this.logger.debug(`${lib} version is ${version}`);
+                        data = fs.readFileSync(this.getSeedHashPath(lib), 'utf8').split(' ');
+                        if (data[1] === version) {
+                            hash = data[0];
+                            this.logger.debug(`${lib} hash is ${hash}`);
+                        }
+                    } catch (e) {
+                        if (!version) {
+                            this.logger.warn(`Could not find library version for ${lib}`);
+                        } else {
+                            this.logger.warn(`Could not find library hash for ${lib}`);
+                        }
+                    }
+
+                    return [lib, version, hash];
+                })
+                .filter(tuple => {
+                    var projVersion = this.getLoadedVersion(tuple[0]),
+                        latest = tuple[1].replace(/\s+/g, '');
+
+                    this.logger.info(`${tuple[0]} version info:\n${projVersion} ` +
+                        `(project)\n${latest} (latest)`);
+                    return latest !== projVersion;
+                });
+
+                return Q.all(tuples.map(tuple => this.uploadSeed.apply(this, tuple)));
+            })
+            .then(hashes => {
+                var name;
+
+                for (var i = hashes.length; i--;) {
+                    name = tuples[i][0];
+                    this.createMessage(this.libraries[name], `${name} ${hashes[i]}`);
+                }
+
+                this.logger.info(`Found ${hashes.length} out of date libraries`);
+                this.result.setSuccess(true);
+                callback(null, this.result);
+            })
+            .fail(err => {
+                this.logger.error(`Could not check the libraries: ${err}`);
+                callback(err, this.result);
+            });
+    };
+
+    CheckLibraries.prototype.getSeedDir = function (name) {
+        return path.join(SEEDS_DIR, name);
+    };
+
+    CheckLibraries.prototype.getSeedDataPath = function (name) {
+        return path.join(this.getSeedDir(name), name + '.webgmex');
+    };
+
+    CheckLibraries.prototype.getSeedHashPath = function (name) {
+        return path.join(this.getSeedDir(name), 'hash.txt');
+    };
+
+    CheckLibraries.prototype.getSeedVersionPath = function (name) {
+        return path.join(this.getSeedDir(name), 'version.txt');
+    };
+
+    CheckLibraries.prototype.uploadSeed = function (name, version, hash) {
+        if (!hash) {  // Upload the seed
+            // Get the data
+            return Q.nfcall(fs.readFile, this.getSeedDataPath(name))
+                .then(data => {
+                    this.logger.info(`Uploading new version of ${name} (${version})`);
+                    return this.blobClient.putFile(`${name}.webgmex`, data);
+                })
+                .then(newHash => {  // Store the new hash
+                    this.logger.info(`Upload of ${name} finished!`);
+                    hash = newHash;
+                    return Q.nfcall(
+                        fs.writeFile,
+                        this.getSeedHashPath(name),
+                        `${hash} ${version}`
+                    );
+                }).then(() => hash);
+        }
+        return hash;
+    };
+
+    CheckLibraries.prototype.getAllLibraries = function () {
+        var name,
+            names = [];
+
+        return this.core.loadChildren(this.rootNode)
+            .then(children => {
+                for (var i = children.length; i--;) {
+                    if (this.core.isLibraryRoot(children[i])) {
+                        name = this.core.getAttribute(children[i], 'name');
+                        this.libraries[name] = children[i];
+                        names.push(name);
+                    }
+                }
+                if (names.length) {
+                    this.logger.debug(`Found libraries: ${names.join(', ')}`);
+                } else {
+                    this.logger.debug('Found no libraries!');
+                }
+                return names;
+            });
+    };
+
+    CheckLibraries.prototype.getLoadedVersion = function (libName) {
+        var node = this.libraries[libName],
+            version = this.core.getAttribute(node, 'version');  // using library root hash
+
+        return version;
+    };
+
+    return CheckLibraries;
+});

src/plugins/CheckLibraries/metadata.json

@@ -0,0 +1,14 @@
+{
+  "id": "CheckLibraries",
+  "name": "CheckLibraries",
+  "version": "0.1.0",
+  "description": "",
+  "icon": {
+    "class": "glyphicon glyphicon-cog",
+    "src": ""
+  },
+  "disableServerSideExecution": false,
+  "disableBrowserSideExecution": true,
+  "writeAccessRequired": false,
+  "configStructure": []
+}

src/plugins/ExecuteJob/templates/deepforge.ejs

@@ -1,6 +1,13 @@
 -- Instantiate the deepforge object
 deepforge = {}
 
+function deepforge.initialize()
+    require 'nn'
+    require 'rnn'
+    require './classes/init'
+    require './custom-layers'
+end
+
 function deepforge.id()
     if __deepforge_id == nil then
         __deepforge_id = 0
@@ -16,7 +23,7 @@ function deepforge._cmd(...)
     for i=1,n do
         cmd = cmd .. ' ' .. tostring(arg[i])
     end
-    print(cmd)
+    print(cmd .. ' ')  -- guarantee ends w/ space
 end
 
 -- Graph support
@@ -46,7 +53,7 @@ function Graph:line(name, opts)
 end
 
 -- Image support
-function deepforge.image(name, tensor)
+local function saveImage(name, tensor)
     require 'image'
     require 'paths'
 
@@ -59,7 +66,32 @@ function deepforge.image(name, tensor)
     end
 
     image.save(path, tensor)
-    deepforge._cmd("<%= IMAGE %>", name)
+end
+
+function deepforge.image(name, tensor)
+    saveImage(name, tensor)
+    deepforge._cmd("<%= IMAGE.BASIC %>", deepforge.id(), name)
+end
+
+Image = torch.class('deepforge.Image')
+function Image:__init(name, tensor)
+    self.id = deepforge.id()
+    self.name = name
+
+    if tensor ~= nil then
+        saveImage(name, tensor)
+        deepforge._cmd('<%= IMAGE.CREATE %>', self.id, self.name)
+    end
+end
+
+function Image:update(tensor)
+    saveImage(self.name, tensor)
+    deepforge._cmd('<%= IMAGE.UPDATE %>', self.id, self.name)
+end
+
+function Image:title(name)
+    self.name = name
+    deepforge._cmd('<%= IMAGE.NAME %>', self.id, self.name)
 end
 
 return deepforge

src/plugins/ExecuteJob/templates/main.ejs

@@ -1,15 +1,12 @@
--- load custom layers
-require './custom-layers'
-
--- load custom class definitions
-require './classes'
+-- load custom layers and classes
+deepforge.initialize()
 
 -- input data<% inputs.forEach(function(pair) { var input = pair[0], isNil = pair[1];%>
-<%= isNil ? 'local ' : ''%><%= input %> = <% if (isNil) { %>nil<% } else { %>require './inputs/<%= input %>'<%}}); %>
+local <%= input %> = <% if (isNil) { %>nil<% } else { %>require './inputs/<%= input %>'<%}}); %>
 
 -- load references<% pointers.forEach(function(pair) { var pointer = pair[0], isNil = pair[1];%>
-<%= isNil ? 'local ' : ''%><%= pointer %> = <% if (isNil) { %>nil<% } else { %>require './pointers/<%= pointer %>'<%}}); %>
-attributes = require './attributes'
+local <%= pointer %> = <% if (isNil) { %>nil<% } else { %>require './pointers/<%= pointer %>'<%}}); %>
+local attributes = require './attributes'
 
 -- main operation code for <%= name %>
 <%= code %>

src/plugins/ExecuteJob/templates/start.ejs

@@ -12,7 +12,7 @@ var spawn = require('child_process').spawn,
 
 // Get the BlobClient...
 var COMMAND_PREFIX = '<%= START_CMD %>',
-    IMAGE = '<%= IMAGE %>',
+    IMAGE = '<%= IMAGE.PREFIX %>',
     requirejs = require('webgme').requirejs,
     remainingImageCount = 0,
     exitCode = null;
@@ -80,7 +80,7 @@ requirejs([
 
     var uploadImage = function(line) {
         var args = line.split(/\s+/),
-            name = args.slice(2).join(' ').replace(/\s+$/, ''),
+            name = args.slice(3).join(' ').replace(/\s+$/, ''),
             filename = 'metadata/' + name + '.png';
 
         // Upload the image from metadata/

src/plugins/ExecutePipeline/ExecutePipeline.js

@@ -4,6 +4,7 @@
 define([
     'plugin/CreateExecution/CreateExecution/CreateExecution',
     'plugin/ExecuteJob/ExecuteJob/ExecuteJob',
+    'deepforge/JobLogsClient',
     'common/storage/constants',
     'common/core/constants',
     'q',
@@ -12,6 +13,7 @@ define([
 ], function (
     CreateExecution,
     ExecuteJob,
+    JobLogsClient,
     STORAGE_CONSTANTS,
     CONSTANTS,
     Q,
@@ -34,6 +36,10 @@ define([
         this.pluginMetadata = pluginMetadata;
 
         this._currentSave = Q();
+        this.changes = {};
+        this.creations = {};
+        this.deletions = [];
+        this.createIdToMetadataId = {};
         this.initRun();
     };
 
@@ -94,17 +100,14 @@ define([
      * @param {function(string, plugin.PluginResult)} callback - the result callback
      */
     ExecutePipeline.prototype.main = function (callback) {
-        // This will probably need to execute the operations, too, because the
-        // inputs for the next operation cannot be created until the inputs have
-        // been generated
+        var startPromise;
 
         this.initRun();
-        var startPromise;
         if (this.core.isTypeOf(this.activeNode, this.META.Pipeline)) {
             // If starting with a pipeline, we will create an Execution first
             startPromise = this.createExecution(this.activeNode)
                 .then(execNode => {
-                    this.logger.debug(`Finished creating execution "${this.core.getAttribute(execNode, 'name')}"`);
+                    this.logger.debug(`Finished creating execution "${this.getAttribute(execNode, 'name')}"`);
                     this.activeNode = execNode;
                 });
         } else if (this.core.isTypeOf(this.activeNode, this.META.Execution)) {
@@ -114,6 +117,13 @@ define([
             return callback('Current node is not a Pipeline or Execution!', this.result);
         }
 
+        // Get the gmeConfig...
+        this.logManager = new JobLogsClient({
+            logger: this.logger,
+            port: this.gmeConfig.server.port,
+            branchName: this.branchName,
+            projectId: this.projectId
+        });
         this._callback = callback;
         this.currentForkName = null;
 
@@ -123,7 +133,7 @@ define([
             var children = subtree
                 .filter(n => this.core.getParent(n) === this.activeNode);
 
-            this.pipelineName = this.core.getAttribute(this.activeNode, 'name');
+            this.pipelineName = this.getAttribute(this.activeNode, 'name');
             this.logger.debug(`Loaded subtree of ${this.pipelineName}. About to build cache`);
             this.buildCache(subtree);
             this.logger.debug('Parsing execution for job inter-dependencies');
@@ -142,11 +152,13 @@ define([
         // before continuing
         this._currentSave = this._currentSave
             .then(() => this.updateForkName(this.pipelineName))
+            .then(() => this.applyModelChanges())
             .then(() => CreateExecution.prototype.save.call(this, msg))
             .then(result => {
                 var msg;
                 if (result.status === STORAGE_CONSTANTS.FORKED) {
                     this.currentForkName = result.forkName;
+                    this.logManager.fork(result.forkName);
                     msg = `"${this.pipelineName}" execution has forked to "${result.forkName}"`;
                     this.sendNotification(msg);
                 } else if (result.status === STORAGE_CONSTANTS.MERGED) {
@@ -159,8 +171,8 @@ define([
         return this._currentSave;
     };
 
-    ExecutePipeline.prototype.updateNodes = function () {
-        var result = ExecuteJob.prototype.updateNodes.call(this);
+    ExecutePipeline.prototype.updateNodes = function (hash) {
+        var result = ExecuteJob.prototype.updateNodes.call(this, hash);
         return result.then(() => this.updateCache());
     };
 
@@ -195,14 +207,14 @@ define([
         nodes.filter(node => this.core.isTypeOf(node, this.META.Job))
             .forEach(node => {
                 this.recordOldMetadata(node);
-                this.core.setAttribute(node, 'status', 'pending');
+                this.setAttribute(node, 'status', 'pending');
             });
 
         // Set the status of the execution to 'running'
-        this.core.setAttribute(this.activeNode, 'status', 'running');
+        this.setAttribute(this.activeNode, 'status', 'running');
         this.logger.info('Setting all jobs status to "pending"');
         this.logger.debug(`Making a commit from ${this.currentHash}`);
-        this.core.setAttribute(this.activeNode, 'startTime', Date.now());
+        this.setAttribute(this.activeNode, 'startTime', Date.now());
         this.core.delAttribute(this.activeNode, 'endTime');
         return this.save(`Initializing ${this.pipelineName} for execution`);
     };
@@ -294,24 +306,24 @@ define([
     ExecutePipeline.prototype.onOperationFail = function(node, err) {
         var job = this.core.getParent(node),
             id = this.core.getPath(node),
-            name = this.core.getAttribute(node, 'name');
+            name = this.getAttribute(node, 'name');
 
         this.logger.debug(`Operation ${name} (${id}) failed: ${err}`);
-        this.core.setAttribute(job, 'status', 'fail');
+        this.setAttribute(job, 'status', 'fail');
         this.clearOldMetadata(job);
         this.onPipelineComplete(err);
     };
 
     ExecutePipeline.prototype.onOperationCanceled = function(op) {
         var job = this.core.getParent(op);
-        this.core.setAttribute(job, 'status', 'canceled');
+        this.setAttribute(job, 'status', 'canceled');
         this.runningJobs--;
-        this.logger.debug(`${this.core.getAttribute(job, 'name')} has been canceled`);
+        this.logger.debug(`${this.getAttribute(job, 'name')} has been canceled`);
         this.onPipelineComplete();
     };
 
     ExecutePipeline.prototype.onPipelineComplete = function(err) {
-        var name = this.core.getAttribute(this.activeNode, 'name'),
+        var name = this.getAttribute(this.activeNode, 'name'),
             msg = `"${this.pipelineName}" `;
 
         if (err) {
@@ -341,19 +353,56 @@ define([
             msg += 'finished!';
         }
 
-        this.logger.debug(`Pipeline "${name}" complete!`);
-        this.core.setAttribute(this.activeNode, 'endTime', Date.now());
-        this.core.setAttribute(this.activeNode, 'status',
-            (this.pipelineError ? 'failed' : (this.canceled ? 'canceled' : 'success')));
+        this.isDeleted().then(isDeleted => {
+            if (!isDeleted) {
 
-        this._finished = true;
-        this.resultMsg(msg);
-        this.save('Pipeline execution finished')
-            .then(() => {
+                this.logger.debug(`Pipeline "${name}" complete!`);
+                this.setAttribute(this.activeNode, 'endTime', Date.now());
+                this.setAttribute(this.activeNode, 'status',
+                    (this.pipelineError ? 'failed' :
+                    (this.canceled ? 'canceled' : 'success')
+                    )
+                );
+
+                this._finished = true;
+                this.resultMsg(msg);
+                this.save('Pipeline execution finished')
+                    .then(() => {
+                        this.result.setSuccess(!this.pipelineError);
+                        this._callback(this.pipelineError || null, this.result);
+                    })
+                    .fail(e => this.logger.error(e));
+            } else {  // deleted!
+                this.logger.debug('Execution has been deleted!');
                 this.result.setSuccess(!this.pipelineError);
                 this._callback(this.pipelineError || null, this.result);
+            }
+        });
+
+    };
+
+    ExecutePipeline.prototype.isDeleted = function () {
+        var activeId = this.core.getPath(this.activeNode);
+
+        // Check if the current execution has been deleted
+        return this.project.getBranchHash(this.branchName)
+            .then(hash => this.updateNodes(hash))
+            .then(() => this.core.loadByPath(this.rootNode, activeId))
+            .then(node => {
+                var deleted = node === null,
+                    msg = `Verified that execution is ${deleted ? '' : 'not '}deleted`;
+
+                this.logger.debug(msg);
+                return deleted;
             })
-            .fail(e => this.logger.error(e));
+            .fail(err => this.logger.error(err));
+    };
+
+    ExecutePipeline.prototype.onPipelineDeleted = function () {
+        var msg = `${this.pipelineName} has been deleted`;
+        this.resultMsg(msg);
+        this.result.setSuccess(true);
+        this._callback(null, this.result);
     };
 
     ExecutePipeline.prototype.executeReadyOperations = function () {
@@ -386,7 +435,7 @@ define([
     };
 
     ExecutePipeline.prototype.onOperationComplete = function (opNode) {
-        var name = this.core.getAttribute(opNode, 'name'),
+        var name = this.getAttribute(opNode, 'name'),
             nextPortIds = this.getOperationOutputIds(opNode),
             jNode = this.core.getParent(opNode),
             resultPorts,
@@ -396,7 +445,7 @@ define([
         // Set the operation to 'success'!
         this.clearOldMetadata(jNode);
         this.runningJobs--;
-        this.core.setAttribute(jNode, 'status', 'success');
+        this.setAttribute(jNode, 'status', 'success');
         this.logger.info(`Setting ${jobId} status to "success"`);
         this.logger.info(`There are now ${this.runningJobs} running jobs`);
         this.logger.debug(`Making a commit from ${this.currentHash}`);
@@ -415,11 +464,11 @@ define([
                     .forEach(pair => {  // [ resultPort, nextPort ]
                         var result = pair[0],
                             next = pair[1],
-                            hash = this.core.getAttribute(result, 'data');
+                            hash = this.getAttribute(result, 'data');
                         
                         this.logger.info(`forwarding data (${hash}) from ${this.core.getPath(result)} ` +
                             `to ${this.core.getPath(next)}`);
-                        this.core.setAttribute(next, 'data', hash);
+                        this.setAttribute(next, 'data', hash);
                         this.logger.info(`Setting ${jobId} data to ${hash}`);
                     });
 

src/plugins/GenerateArchitecture/GenerateArchitecture.js

@@ -46,7 +46,7 @@ define([
         this.addCustomLayersToMeta();
         this.LayerDict = createLayerDict(this.core, this.META);
         this.uniqueId = 2;
-        this.varnames = {};
+        this.varnames = {net: true};
         return PluginBase.prototype.main.apply(this, arguments);
     };
 
@@ -247,17 +247,27 @@ define([
             base = layer[Constants.BASE],
             desc,
             fn,
-            layerCode;
+            layerCode,
+            args,
+            i;
 
         this.logger.debug(`Creating arg string for ${layer.name}`);
-        layerCode = '(' + this.LayerDict[layer.name].args
-            .map(arg => this.getValue(arg.name, layer))
-            .filter(GenerateArchitecture.isSet)
+        args = this.LayerDict[layer.name].args
+            .map(arg => this.getValue(arg.name, layer));
+
+        for (i = args.length; i--;) {
+            if (GenerateArchitecture.isSet(args[i])) {
+                break;
+            }
+            args.pop();
+        }
+
+        layerCode = '(' + args.map(arg => GenerateArchitecture.isSet(arg) ? arg : 'nil')
             .join(', ') + ')';
 
         // Add any setters
         // For each setter, check if it has been changed (and needs to be set)
-        for (var i = setterNames.length; i--;) {
+        for (i = setterNames.length; i--;) {
             desc = setters[setterNames[i]];
             if (desc.setterType === 'const') {
                 // if the value is not the default, add the given fn

src/plugins/UpdateLibrarySeed/UpdateLibrarySeed.js

@@ -0,0 +1,139 @@
+/*globals define*/
+/*jshint node:true, browser:true*/
+
+define([
+    'text!./metadata.json',
+    'child_process',
+    'path',
+    'q',
+    'fs',
+    'module',
+    'plugin/PluginBase'
+], function (
+    pluginMetadata,
+    childProcess,
+    path,
+    Q,
+    fs,
+    module,
+    PluginBase
+) {
+    'use strict';
+
+    pluginMetadata = JSON.parse(pluginMetadata);
+    var SEEDS_DIR = path.join(path.dirname(module.uri), '..', '..', 'seeds');
+
+    /**
+     * Initializes a new instance of UpdateLibrarySeed.
+     * @class
+     * @augments {PluginBase}
+     * @classdesc This class represents the plugin UpdateLibrarySeed.
+     * @constructor
+     */
+    var UpdateLibrarySeed = function () {
+        // Call base class' constructor.
+        PluginBase.call(this);
+        this.pluginMetadata = pluginMetadata;
+    };
+
+    /**
+     * Metadata associated with the plugin. Contains id, name, version, description, icon, configStructue etc.
+     * This is also available at the instance at this.pluginMetadata.
+     * @type {object}
+     */
+    UpdateLibrarySeed.metadata = pluginMetadata;
+
+    // Prototypical inheritance from PluginBase.
+    UpdateLibrarySeed.prototype = Object.create(PluginBase.prototype);
+    UpdateLibrarySeed.prototype.constructor = UpdateLibrarySeed;
+
+    /**
+     * Main function for the plugin to execute. This will perform the execution.
+     * Notes:
+     * - Always log with the provided logger.[error,warning,info,debug].
+     * - Do NOT put any user interaction logic UI, etc. inside this method.
+     * - callback always has to be called even if error happened.
+     *
+     * @param {function(string, plugin.PluginResult)} callback - the result callback
+     */
+    UpdateLibrarySeed.prototype.main = function (callback) {
+        // get the root hash
+        var name = this.projectName,
+            version;
+
+        // get the name and validate
+        return this.getLibraryVersion()
+            .then(vers => {
+                version = vers;
+                return this.checkForLibName(name);
+            })
+            .then(valid => {
+                if (!valid) {
+                    var err = `Invalid library name "${name}"`;
+                    this.logger.error(err);
+                    return callback(err, this.result);
+                }
+                return this.updateSeed(name);
+            })
+            .then(() => this.recordVersion(name, version))
+            .then(() => {
+                this.logger.info(`Finished updating library seed for ${name}`);
+                this.result.setSuccess(true);
+                callback(null, this.result);
+            })
+            .fail(err => callback(err, this.result));
+    };
+
+    UpdateLibrarySeed.prototype.getLibraryVersion = function () {
+        var version,
+            config = this.getCurrentConfig(),
+            vnames = ['major', 'minor', 'patch'],
+            bumpIndex,
+            newVersion;
+
+        version = (this.core.getAttribute(this.rootNode, 'version') || '0.0.0')
+            .split('.').map(num => parseInt(num));
+        bumpIndex = vnames.indexOf(config.releaseType);
+        version[bumpIndex]++;
+
+        newVersion = version.join('.');
+        this.core.setAttribute(this.rootNode, 'version', newVersion);
+        return this.save(`Bumped version to ${newVersion}`).then(() => newVersion);
+    };
+
+    UpdateLibrarySeed.prototype.checkForLibName = function (name) {
+        // check for the library name from the fs
+        return Q.nfcall(fs.readdir, SEEDS_DIR).then(seeds => seeds.indexOf(name) !== -1);
+    };
+
+    UpdateLibrarySeed.prototype.updateSeed = function (seedName) {
+        var deferred = Q.defer(),
+            err,
+            job = childProcess.spawn('webgme', ['new', 'seed', seedName], {
+                cwd: path.dirname(module.uri)
+            });
+
+        this.logger.info(`Updating ${seedName} seed`);
+        job.on('error', _err => {
+            err = _err;
+        });
+
+        job.on('exit', code => {
+            if (!code) {
+                deferred.resolve();
+            } else {
+                deferred.reject(err || code);
+            }
+        });
+
+        return deferred.promise;
+    };
+
+    UpdateLibrarySeed.prototype.recordVersion = function (seed, version) {
+        var versionPath = path.join(SEEDS_DIR, seed, 'version.txt');
+        this.logger.info(`Updating ${seed} version (${version})`);
+        return Q.nfcall(fs.writeFile, versionPath, version);
+    };
+
+    return UpdateLibrarySeed;
+});

src/plugins/UpdateLibrarySeed/metadata.json

@@ -0,0 +1,28 @@
+{
+  "id": "UpdateLibrarySeed",
+  "name": "UpdateLibrarySeed",
+  "version": "0.1.0",
+  "description": "",
+  "icon": {
+    "class": "glyphicon glyphicon-cog",
+    "src": ""
+  },
+  "disableServerSideExecution": false,
+  "disableBrowserSideExecution": true,
+  "writeAccessRequired": false,
+  "configStructure": [
+      {
+          "name": "releaseType",
+          "displayName": "Release Type",
+          "description": "Specify major, minor or patch release",
+          "value": "minor",
+          "valueItems": [
+              "major",
+              "minor",
+              "patch"
+          ],
+          "valueType": "string",
+          "readOnly": false
+      }
+  ]
+}

src/routers/JobLogsAPI/JobLogManager.js

@@ -0,0 +1,149 @@
+var path = require('path'),
+    Q = require('q'),
+    fs = require('fs'),
+    exists = require('exists-file'),
+    utils = require('../../common/utils'),
+    NO_LOG_FOUND = '';
+
+var JobLogManager = function(logger, config) {
+    this.rootDir = path.join(config.blob.fsDir, 'log-storage');
+    this.logger = logger.fork('JobLogManager');
+    this._onCopyFinished = {};
+};
+
+JobLogManager.prototype._getFilePath = function(jInfo) {
+    this.logger.info(`getting file path for ${jInfo.job} in ${jInfo.project} on ${jInfo.branch}`);
+    var jobId = jInfo.job.replace(/\//g, '_'),
+        filename = `${jobId}.txt`;
+
+    return path.join(this.rootDir, jInfo.project, jInfo.branch, filename);
+};
+
+JobLogManager.prototype.exists = function(jobInfo) {
+    var filename = this._getFilePath(jobInfo);
+    return Q.nfcall(exists, filename);
+};
+
+JobLogManager.prototype.mkdirIfNeeded = function(dir) {
+    return Q.nfcall(exists, dir).then(exist => {
+        if (!exist) {
+            this.logger.debug('making dir:', dir);
+            return Q.nfcall(fs.mkdir, dir)
+                .catch(() => this.logger.debug(`dir already created: ${dir}`));
+        }
+    });
+};
+
+JobLogManager.prototype._copyFile = function(src, dst) {
+    return Q.nfcall(exists, src).then(exists => {
+        if (!exists) {
+            this.logger.warn(`Cannot copy file from ${src}. File doesn't exist!`);
+            return;
+        }
+
+        return this.mkdirIfNeeded(path.dirname(dst)).then(() => {
+            var deferred = Q.defer(),
+                stream = fs.createReadStream(src).pipe(fs.createWriteStream(dst));
+
+            stream.on('error', deferred.reject);
+            stream.on('finish', deferred.resolve);
+
+            return deferred.promise;
+        });
+    });
+};
+
+// Copy one branch info to the next
+// Could optimize this to symlink until data appended...
+JobLogManager.prototype.migrate = function(migrationInfo, jobIds) {
+    // Recursively copy the srcBranch dir to the dstBranch dir
+    // Should probably use streams...
+    // Need to block appends to the given files so they are not written
+    // to until they have finished copying...
+    // TODO
+    var jobs,
+        src,
+        dst,
+        i;
+
+    for (i = jobIds.length; i--;) {
+        this._onCopyFinished[jobIds[i]] = [];
+    }
+
+    // Copy the job files and evaluate each of the finish functions
+    this.logger.info('migrating from ' + migrationInfo.srcBranch + ' to '+ migrationInfo.dstBranch);
+    return Q.all(jobIds.map(jobId => {
+        src = this._getFilePath({
+            project: migrationInfo.project,
+            branch: migrationInfo.srcBranch,
+            job: jobId
+        });
+        dst = this._getFilePath({
+            project: migrationInfo.project,
+            branch: migrationInfo.dstBranch,
+            job: jobId
+        });
+        return this._copyFile(src, dst).then(() => {
+            jobs = this._onCopyFinished[jobId];
+            for (var j = jobs.length; j--;) {
+                jobs[j]();
+            }
+        });
+    }));
+};
+
+JobLogManager.prototype._appendTo = function(filename, logs) {
+    return Q.nfcall(exists, filename).then(exists => {
+        var promise = Q().then(() => '');
+        if (exists) {
+            promise = Q.nfcall(fs.readFile, filename, 'utf8');
+        }
+
+        return promise.then(content => {
+            // This could be optimized to not re-read/write the whole file each time...
+            var lines = utils.resolveCarriageReturns(content + logs);
+            return Q.nfcall(fs.writeFile, filename, lines.join('\n'));
+        });
+    });
+};
+
+JobLogManager.prototype.appendTo = function(jobInfo, logs) {
+    var filename = this._getFilePath(jobInfo),
+        branchDirname = path.dirname(filename),
+        projDirname = path.dirname(branchDirname);
+
+    this.logger.info(`Appending content to ${filename}`);
+    // Make directory if needed
+    return this.mkdirIfNeeded(this.rootDir)
+        .then(() => this.mkdirIfNeeded(projDirname))
+        .then(() => this.mkdirIfNeeded(branchDirname))
+        .then(() => this._appendTo(filename, logs));
+};
+
+JobLogManager.prototype.getLog = function(jobInfo) {
+    var filename = this._getFilePath(jobInfo);
+
+    this.logger.info(`Getting log content to ${filename}`);
+    return this.exists(jobInfo)
+        .then(exists => {
+            if (exists) {
+                return Q.nfcall(fs.readFile, filename);
+            }
+            return NO_LOG_FOUND;
+        });
+};
+
+JobLogManager.prototype.delete = function(jobInfo) {
+    var filename = this._getFilePath(jobInfo);
+
+    return this.exists(jobInfo)
+        .then(exists => {
+            if (exists) {
+                this.logger.debug(`Removing file ${filename}`);
+                return Q.nfcall(fs.unlink, filename);
+            }
+            this.logger.info(`${filename} doesn't exist. No need to delete...`);
+        });
+};
+
+module.exports = JobLogManager;

src/routers/JobLogsAPI/JobLogsAPI.js

@@ -0,0 +1,93 @@
+/*jshint node:true*/
+
+'use strict';
+
+var express = require('express'),
+    JobLogManager = require('./JobLogManager'),
+    router = express.Router();
+
+/**
+ * Called when the server is created but before it starts to listening to incoming requests.
+ * N.B. gmeAuth, safeStorage and workerManager are not ready to use until the start function is called.
+ * (However inside an incoming request they are all ensured to have been initialized.)
+ *
+ * @param {object} middlewareOpts - Passed by the webgme server.
+ * @param {GmeConfig} middlewareOpts.gmeConfig - GME config parameters.
+ * @param {GmeLogger} middlewareOpts.logger - logger
+ * @param {function} middlewareOpts.ensureAuthenticated - Ensures the user is authenticated.
+ * @param {function} middlewareOpts.getUserId - If authenticated retrieves the userId from the request.
+ * @param {object} middlewareOpts.gmeAuth - Authorization module.
+ * @param {object} middlewareOpts.safeStorage - Accesses the storage and emits events (PROJECT_CREATED, COMMIT..).
+ * @param {object} middlewareOpts.workerManager - Spawns and keeps track of "worker" sub-processes.
+ */
+function initialize(middlewareOpts) {
+    var logger = middlewareOpts.logger.fork('JobLogsAPI'),
+        ensureAuthenticated = middlewareOpts.ensureAuthenticated,
+        gmeConfig = middlewareOpts.gmeConfig,
+        logManager = new JobLogManager(logger, gmeConfig);
+
+    logger.debug('initializing ...');
+
+    // Ensure authenticated can be used only after this rule.
+    router.use('*', function (req, res, next) {
+        // This header ensures that any failures with authentication won't redirect.
+        res.setHeader('X-WebGME-Media-Type', 'webgme.v1');
+        next();
+    });
+
+    // Use ensureAuthenticated if the routes require authentication. (Can be set explicitly for each route.)
+    router.use('*', ensureAuthenticated);
+
+    router.get('/:project/:branch/:job', function (req, res/*, next*/) {
+        // Retrieve the job logs for the given job
+        logManager.getLog(req.params).then(log => {
+            res.set('Content-Type', 'text/plain');
+            res.send(log);
+        });
+    });
+
+    router.patch('/:project/:branch/:job', function (req, res/*, next*/) {
+        var logs = req.body.patch;
+        logger.info(`Received append request for ${req.params.job} in ${req.params.project}`);
+        logManager.appendTo(req.params, logs)
+            .then(() => res.send('Append successful'))
+            .catch(err => logger.error(`Append failed: ${err}`));
+    });
+
+    router.delete('/:project/:branch/:job', function (req, res/*, next*/) {
+        logManager.delete(req.params).then(() => res.send('delete successful'));
+    });
+
+    router.post('/migrate/:project/:srcBranch/:dstBranch', function (req, res/*, next*/) {
+        var jobs = req.body.jobs;
+        logManager.migrate(req.params, jobs)
+            .then(() => res.send('migration successful'))
+            .fail(err => logger.error(err));
+    });
+
+    logger.debug('ready');
+}
+
+/**
+ * Called before the server starts listening.
+ * @param {function} callback
+ */
+function start(callback) {
+    callback();
+}
+
+/**
+ * Called after the server stopped listening.
+ * @param {function} callback
+ */
+function stop(callback) {
+    callback();
+}
+
+
+module.exports = {
+    initialize: initialize,
+    router: router,
+    start: start,
+    stop: stop
+};

src/seeds/nn/version.txt

@@ -0,0 +1 @@
+0.2.0

src/seeds/pipeline/version.txt

@@ -0,0 +1 @@
+0.3.0

src/visualizers/panels/ClassCodeEditor/ClassCodeEditorControl.js

@@ -117,7 +117,7 @@ define([
             }
         }
 
-        TextEditorControl.prototype.saveTextFor.call(this, id, text);
+        TextEditorControl.prototype.saveTextFor.call(this, id, text, true);
         this._client.completeTransaction();
     };
 

src/visualizers/panels/ExecutionIndex/ExecutionIndexControl.js

@@ -56,7 +56,7 @@ define([
             // Refresh the other lines visible
             otherLines = Object.keys(this.displayedExecutions)
                 .filter(eId => this.displayedExecutions[eId] && (eId !== id))
-                .map(id => this._linesForExecution[id])
+                .map(id => this._linesForExecution[id] || [])
                 .reduce((l1, l2) => l1.concat(l2), []);
 
             this._updateLines(otherLines, false);
@@ -70,7 +70,8 @@ define([
         var action = added ? 'addNode' : 'removeNode';
 
         // If removing, just get the ids
-        lines = !added ? lines : lines.map(line => this._getObjectDescriptor(line));
+        lines = !added ? lines : lines.map(line => this._getObjectDescriptor(line))
+            .filter(line => !!line);
 
         // update the given lines
         for (var i = lines.length; i--;) {
@@ -160,7 +161,9 @@ define([
                 desc.abbr = this.getUniqAbbreviation(desc);
 
                 // Create a territory for this origin and update it!
-                this._selfPatterns[desc.originId] = {children: 0};
+                if (desc.originId) {
+                    this._selfPatterns[desc.originId] = {children: 0};
+                }
                 setTimeout(() => this._client.updateTerritory(this._territoryId, this._selfPatterns), 0);
             } else if (type === 'Line') {
                 desc = this.getLineDesc(node);

src/visualizers/panels/Footer/FilteredNotificationWidget.js

@@ -0,0 +1,28 @@
+/* globals define */
+// A notification widget which filters out stdout update notifications
+define([
+    'deepforge/Constants',
+    'js/Widgets/Notification/NotificationWidget'
+], function(
+    CONSTANTS,
+    GmeNotificationWidget
+) {
+    var NotificationWidget = function() {
+        GmeNotificationWidget.apply(this, arguments);
+    };
+
+    NotificationWidget.prototype = Object.create(GmeNotificationWidget.prototype);
+
+    NotificationWidget.prototype.isUserNotication = function(data) {
+        return data.message.indexOf(CONSTANTS.STDOUT_UPDATE) === -1;
+    };
+
+    NotificationWidget.prototype._refreshNotifications = function(eventData) {
+
+        if (this.isUserNotication(eventData)) {
+            GmeNotificationWidget.prototype._refreshNotifications.call(this, eventData);
+        }
+    };
+
+    return NotificationWidget;
+});

src/visualizers/panels/Footer/FooterPanel.js

@@ -1,8 +1,5 @@
 /*globals define, _, WebGMEGlobal, $ */
 /*jshint browser: true*/
-/**
- * @author rkereskenyi / https://github.com/rkereskenyi
- */
 
 define([
     'js/PanelBase/PanelBase',
@@ -10,13 +7,15 @@ define([
     'js/Widgets/BranchStatus/BranchStatusWidget',
     'js/Widgets/BranchSelector/BranchSelectorWidget',
     'js/Widgets/KeyboardManager/KeyboardManagerWidget',
-    'js/Widgets/Notification/NotificationWidget'
-], function (PanelBase,
-             NetworkStatusWidget,
-             BranchStatusWidget,
-             BranchSelectorWidget,
-             KeyboardManagerWidget,
-             NotificationWidget) {
+    './FilteredNotificationWidget'
+], function (
+    PanelBase,
+    NetworkStatusWidget,
+    BranchStatusWidget,
+    BranchSelectorWidget,
+    KeyboardManagerWidget,
+    NotificationWidget
+) {
 
     'use strict';
 

src/visualizers/panels/ForgeActionButton/Actions.js

@@ -252,18 +252,7 @@ define([
                     return this.isRunning();
                 },
                 action: function() {
-                    // Stop every running job
-                    var execNode = this.client.getNode(this._currentNodeId),
-                        jobIds = execNode.getChildrenIds(),
-                        msg = `Canceling ${execNode.getAttribute('name')} execution`;
-
-                    this.client.startTransaction(msg);
-                    jobIds.map(id => this.client.getNode(id))
-                        .filter(job => this.isRunning(job))  // get running jobs
-                        .forEach(job => this.stopJob(job));  // stop them
-
-                    this.client.setAttributes(execNode.getId(), 'status', 'canceled');
-                    this.client.completeTransaction();
+                    this.stopExecution();
                 }
             }
         ],

src/visualizers/panels/ForgeActionButton/ForgeActionButton.js

@@ -13,7 +13,6 @@ define([
     'js/RegistryKeys',
     'js/Panels/MetaEditor/MetaEditorConstants',
     'q',
-    'text!./PluginConfig.json',
     'deepforge/globals'
 ], function (
     BlobClient,
@@ -27,7 +26,6 @@ define([
     REGISTRY_KEYS,
     META_CONSTANTS,
     Q,
-    PluginConfig,
     DeepForge
 ) {
     'use strict';
@@ -35,7 +33,6 @@ define([
     var NEW_OPERATION_ID = '__NEW_OPERATION__';
     var ForgeActionButton= function (layoutManager, params) {
         PluginButton.call(this, layoutManager, params);
-        this._pluginConfig = JSON.parse(PluginConfig);
         this._client = this.client;
         this._actions = [];
         this._blobClient = new BlobClient({

src/visualizers/panels/ForgeActionButton/PluginConfig.json

@@ -1,21 +0,0 @@
-{
-    "GenerateArchitecture": {
-        "icon": "description",
-        "hotkey": "shift enter",
-        "priority": -1
-    },
-    "ExecutePipeline": {
-        "icon": "play_arrow",
-        "hotkey": "shift enter",
-        "color": "green",
-        "priority": 1
-    },
-    "ImportTorch": {
-        "icon": "import_export",
-        "priority": -1
-    },
-    "GenerateExecFile": {
-        "icon": "play_for_work",
-        "priority": -1
-    }
-}

src/visualizers/panels/LayerEditor/LayerEditorControl.js

@@ -32,6 +32,8 @@ define([
     LayerEditorControl.prototype._getObjectDescriptor = function (nodeId) {
         var desc = TextEditorControl.prototype._getObjectDescriptor.call(this, nodeId),
             node = this._client.getNode(nodeId),
+            baseId = node.getBaseId(),
+            base = this._client.getNode(baseId),
             hasCode = node.getValidAttributeNames().indexOf('code') > -1,
             template;
 
@@ -50,7 +52,16 @@ define([
         }
 
         if (template) {
-            desc.text = _.template(template)(desc);
+            var baseTorchType = 'nn.Module';
+            // If the base type is 'Criterion', set the base type to nn.Criterion
+            if (base.getAttribute('name') === 'Criterion') {
+                baseTorchType = 'nn.Criterion';
+            }
+
+            desc.text = _.template(template)({
+                name: desc.name,
+                baseTorchType: baseTorchType
+            });
         }
         return desc;
     };
@@ -82,7 +93,7 @@ define([
 
         this._client.startTransaction(msg);
 
-        TextEditorControl.prototype.saveTextFor.call(this, id, text);
+        TextEditorControl.prototype.saveTextFor.call(this, id, text, true);
         this._client.setAttributes(id, 'name', layerSchema.name);
 
         this._logger.debug(`Setting ctor args to ${ctorAttrs.join(',')}`);

src/visualizers/panels/LogViewer/LogViewerControl.js

@@ -2,9 +2,18 @@
 /*jshint browser: true*/
 
 // This is a read-only view of the 'stdout' attribute for a Job node
+// if the job is running, get the logs from the log-storage
 define([
+    'q',
+    'deepforge/JobLogsClient',
+    'js/Constants',
+    'deepforge/Constants',
     'panels/TextEditor/TextEditorControl'
 ], function (
+    Q,
+    JobLogsClient,
+    GME_CONSTANTS,
+    CONSTANTS,
     TextEditorControl
 ) {
 
@@ -19,11 +28,68 @@ define([
 
     _.extend(LogViewerControl.prototype, TextEditorControl.prototype);
 
+    LogViewerControl.prototype.getFullDescriptor = function (id) {
+        var desc = LogViewerControl.prototype._getObjectDescriptor.call(this, id);
+
+        return this._getRunningLogs(id).then(text => {
+            // Use attribute or running log if none
+            desc.text = desc.text || text;
+            return desc;
+        });
+    };
+
+    LogViewerControl.prototype.getUpdatedJobId = function (msg) {
+        // verify that it is the given notification type
+        if (msg.indexOf(CONSTANTS.STDOUT_UPDATE) !== -1) {
+            return msg.replace(/^[^\/]*\//, '');
+        }
+    };
+
+    LogViewerControl.prototype.selectedObjectChanged = function (id) {
+        TextEditorControl.prototype.selectedObjectChanged.call(this, id);
+        // Listen for notifications about updated logs
+        this.removeNotificationHandler();
+        this.notificationHandler = (sender, data) => {
+            var nodeId = this.getUpdatedJobId(data.message);
+            if (nodeId === id) {
+                this._onUpdate(id);
+            }
+        };
+        this._client.addEventListener(GME_CONSTANTS.CLIENT.NOTIFICATION, this.notificationHandler);
+    };
+
+    LogViewerControl.prototype.removeNotificationHandler = function () {
+        // Remove the notifications listener
+        if (this.notificationHandler) {
+            this._client.removeEventListener();
+            this.notificationHandler = null;
+        }
+    };
+
+    LogViewerControl.prototype.destroy = function () {
+        TextEditorControl.prototype.destroy.call(this);
+        this.removeNotificationHandler();
+    };
+
+    LogViewerControl.prototype._onLoad = function (id) {
+        this.getFullDescriptor(id).then(desc => this._widget.addNode(desc));
+    };
+
     LogViewerControl.prototype._onUpdate = function (id) {
         if (id === this._currentNodeId) {
-            TextEditorControl.prototype._onUpdate.call(this, id);
+            this.getFullDescriptor(id).then(desc => this._widget.updateNode(desc));
         }
     };
 
+    LogViewerControl.prototype._getRunningLogs = function (id) {
+        var logManager = new JobLogsClient({
+            logger: this._logger,
+            projectId: this._client.getActiveProjectId(),
+            branchName: this._client.getActiveBranchName()
+        });
+
+        return logManager.getLog(id);
+    };
+
     return LogViewerControl;
 });

src/visualizers/panels/MainView/MainViewControl.js

@@ -4,14 +4,12 @@
 define([
     'blob/BlobClient',
     'js/Constants',
-    'js/Utils/GMEConcepts',
-    'js/NodePropertyNames',
+    'q',
     'deepforge/globals'
 ], function (
     BlobClient,
     CONSTANTS,
-    GMEConcepts,
-    nodePropertyNames,
+    Q,
     DeepForge
 ) {
 
@@ -22,15 +20,11 @@ define([
     MainViewControl = function (options) {
 
         this._logger = options.logger.fork('Control');
-
         this._client = options.client;
-
-        // Initialize core collections and variables
         this._widget = options.widget;
 
         this._currentNodeId = null;
         this._embedded = options.embedded;
-
         this.territory = {};
         this.ui = {};
         this._blobClient = new BlobClient({
@@ -67,12 +61,33 @@ define([
         };
 
         this._widget.toggleEmbeddedPanel = () => this.toggleEmbeddedPanel();
+        this._widget.updateLibraries = this.updateLibraries.bind(this);
+        this._widget.checkLibUpdates = this.checkLibUpdates.bind(this);
+        this._widget.getProjectName = this.getProjectName.bind(this);
+    };
+
+    MainViewControl.prototype.getProjectName = function () {
+        return this._client.getActiveProjectId().split('+')[1];
+    };
+
+    MainViewControl.prototype.checkLibUpdates = function () {
+        var pluginId = 'CheckLibraries',
+            context = this._client.getCurrentPluginContext(pluginId);
+
+        return Q.ninvoke(this._client, 'runServerPlugin', pluginId, context)
+            .then(res => {
+                return res.messages.map(msg => msg.message.split(' '));
+            });
+    };
+
+    MainViewControl.prototype.updateLibraries = function (libraries) {
+        var promises = libraries
+            .map(lib => Q.ninvoke(this._client, 'updateLibrary', lib[0], lib[1]));
+
+        return Q.all(promises);
     };
 
     /* * * * * * * * Visualizer content update callbacks * * * * * * * */
-    // One major concept here is with managing the territory. The territory
-    // defines the parts of the project that the visualizer is interested in
-    // (this allows the browser to then only load those relevant parts).
     MainViewControl.prototype.selectedObjectChanged = function (nodeId) {
         this._logger.debug('activeObject nodeId \'' + nodeId + '\'');
 

src/visualizers/panels/PipelineEditor/PipelineEditorControl.js

@@ -2,9 +2,11 @@
 /*jshint browser: true*/
 
 define([
+    'deepforge/Constants',
     'js/Constants',
     'panels/EasyDAG/EasyDAGControl',
     'deepforge/viz/PipelineControl',
+    'deepforge/viz/Execute',
     'deepforge/globals',
     'common/core/coreQ',
     'common/storage/constants',
@@ -12,8 +14,10 @@ define([
     'underscore'
 ], function (
     CONSTANTS,
+    GME_CONSTANTS,
     EasyDAGControl,
     PipelineControl,
+    Execute,
     DeepForge,
     Core,
     STORAGE_CONSTANTS,
@@ -29,26 +33,28 @@ define([
             DST: 'dst'
         },
         DECORATORS = {
-            ArtifactLoader: 'ArtifactOpDecorator',
             ArtifactFinder: 'ArtifactOpDecorator'
         },
         WIDGET_NAME = 'EasyDAG';
 
+    DECORATORS[CONSTANTS.OP.INPUT] = 'ArtifactOpDecorator';
+
     PipelineEditorControl = function (options) {
         EasyDAGControl.call(this, options);
+        Execute.call(this, this._client, this._logger);
         this.addedIds = {};
         this.executionTerritory = {};
         this.executionUI = null;
         this.invalidated = {};
-        this._widget.deleteNode = id => {
-            this._deleteNode(id);
-        };
+        this._widget.deleteExecution = this.deleteExecution.bind(this);
+        this._widget.isArchitecturePtr = this.isArchitecturePtr.bind(this);
     };
 
     _.extend(
         PipelineEditorControl.prototype,
         EasyDAGControl.prototype,
-        PipelineControl.prototype
+        PipelineControl.prototype,
+        Execute.prototype
     );
 
     PipelineEditorControl.prototype._getValidInitialNodes =
@@ -126,7 +132,7 @@ define([
         // Add arch/artifact dir to the territory
         // loading more than necessary.... can restrict it in the future
         // if perf is a problem
-        this._territories[CONSTANTS.PROJECT_ROOT_ID] = {children: 2};
+        this._territories[GME_CONSTANTS.PROJECT_ROOT_ID] = {children: 2};
 
         this._client.updateTerritory(this._territoryId, this._territories);
     };
@@ -498,7 +504,7 @@ define([
 
     PipelineEditorControl.prototype._getTargetDirs = function (typeIds) {
         // Find the directories containing these types
-        return this._client.getNode(CONSTANTS.PROJECT_ROOT_ID).getChildrenIds()
+        return this._client.getNode(GME_CONSTANTS.PROJECT_ROOT_ID).getChildrenIds()
             // No referencing data meta types
             .filter(id => {
                 var cMeta = this._client.getChildrenMeta(id),
@@ -543,11 +549,11 @@ define([
         // Handle events related to the associated executions
         for (var i = events.length; i--;) {
             event = events[i];
-            if (event.etype === CONSTANTS.TERRITORY_EVENT_LOAD) {
+            if (event.etype === GME_CONSTANTS.TERRITORY_EVENT_LOAD) {
                 this.onExecLoad(event.eid);
-            } else if (event.etype === CONSTANTS.TERRITORY_EVENT_UPDATE) {
+            } else if (event.etype === GME_CONSTANTS.TERRITORY_EVENT_UPDATE) {
                 this.onExecUpdate(event.eid);
-            } else if (event.etype === CONSTANTS.TERRITORY_EVENT_UNLOAD) {
+            } else if (event.etype === GME_CONSTANTS.TERRITORY_EVENT_UNLOAD) {
                 this.onExecUnload(event.eid);
             }
         }
@@ -595,6 +601,42 @@ define([
         }
     };
 
+    PipelineEditorControl.prototype._deleteTag = function (tagName) {
+        // Check if the tag exists and delete it if so!
+        var projectId = this._client.getActiveProjectId();
+
+        this._client.deleteTag(projectId, tagName, err => {
+            if (err) {
+                this.logger.error(`Tag deletion failed: ${err}`);
+            }
+        });
+    };
+
+    PipelineEditorControl.prototype.deleteExecution = function (id) {
+        var node = this._client.getNode(id),
+            name = '',
+            msg;
+
+        if (node) {
+            name = node && node.getAttribute('name');
+        }
+
+        msg = `Deleted ${name} (${id}) execution`;
+
+        // Stop the execution w/o setting any attributes on the execution
+        this._client.startTransaction(msg);
+        this._deleteTag(name);  // Remove execution tag
+        if (this.isRunning(node)) {
+            this.silentStopExecution(id, true).then(() => {
+                this._client.delMoreNodes([id]);
+                this._client.completeTransaction();
+            });
+        } else {
+            this._client.delMoreNodes([id]);
+            this._client.completeTransaction();
+        }
+    };
+
     PipelineEditorControl.prototype.updateThumbnail = function (svg) {
         var node = this._client.getNode(this._currentNodeId),
             name,
@@ -641,7 +683,19 @@ define([
         } else {
             return EasyDAGControl.prototype._getValidTargetsFor.apply(this, arguments);
         }
+    };
 
+    PipelineEditorControl.prototype.isArchitecturePtr = function (id, ptr) {
+        var ptrMeta = this._client.getPointerMeta(id, ptr),
+            targets;
+
+        // Check if ptr of the given id is referencing an architecture
+        if (ptrMeta.items) {
+            targets = ptrMeta.items.map(item => this._client.getNode(item.id));
+            return !!targets.find(node => node.getAttribute('name') === 'Architecture');
+        }
+
+        return false;
     };
 
     return PipelineEditorControl;

src/visualizers/panels/PipelineEditor/PipelineEditorPanel.js

@@ -1,17 +1,17 @@
 /*globals define, $, _, WebGMEGlobal*/
 /*jshint browser: true*/
-/**
- * Generated by VisualizerGenerator 1.7.0 from webgme on Thu May 19 2016 14:04:47 GMT-0500 (CDT).
- */
 
-define(['js/PanelBase/PanelBaseWithHeader',
+define([
+    'js/PanelBase/PanelBaseWithHeader',
     'js/PanelManager/IActivePanel',
     'widgets/PipelineEditor/PipelineEditorWidget',
     './PipelineEditorControl'
-], function (PanelBaseWithHeader,
-             IActivePanel,
-             PipelineEditorWidget,
-             PipelineEditorControl) {
+], function (
+    PanelBaseWithHeader,
+    IActivePanel,
+    PipelineEditorWidget,
+    PipelineEditorControl
+) {
     'use strict';
 
     var PipelineEditorPanel;

src/visualizers/panels/PipelineIndex/PipelineIndexControl.js

@@ -33,12 +33,33 @@ define([
         this._widget.deletePipeline = id => {
             var node = this._client.getNode(id),
                 name = node.getAttribute('name'),
-                msg = `Deleting pipeline "${name}"`;
+                msg = `Deleting pipeline "${name}"`,
+                delTerritory = {},
+                delUI,
+                ids = [id];
 
-            // Change the current active object
-            this._client.startTransaction(msg);
-            this._client.delMoreNodes([id]);
-            this._client.completeTransaction();
+            // Delete all associated executions
+            ids = node.getMemberIds('executions');
+            for (var i = ids.length; i--;) {
+                delTerritory[ids[i]] = {children: 0};
+            }
+
+            delUI = this._client.addUI(this, events => {
+                var ids = [id];
+
+                for (i = events.length; i--;) {
+                    if (events[i].eid && events[i].etype === CONSTANTS.TERRITORY_EVENT_LOAD) {
+                        ids.push(events[i].eid);
+                    }
+                }
+
+                this._client.startTransaction(msg);
+                this._client.delMoreNodes(ids);
+                this._client.completeTransaction();
+
+                this._client.removeUI(delUI);
+            });
+            this._client.updateTerritory(delUI, delTerritory);
         };
 
         this._widget.setName = (id, name) => {

src/visualizers/panels/TextEditor/TextEditorControl.js

@@ -47,14 +47,18 @@ define([
         this._widget.setName = this.setName.bind(this);
     };
 
-    TextEditorControl.prototype.saveTextFor = function (id, text) {
+    TextEditorControl.prototype.saveTextFor = function (id, text, inTransaction) {
         var node = this._client.getNode(this._currentNodeId),
             name = node.getAttribute('name'),
             msg = `Updating ${this.ATTRIBUTE_NAME} of ${name} (${id})`;
 
-        this._client.startTransaction(msg);
+        if (!inTransaction) {
+            this._client.startTransaction(msg);
+        }
         this._client.setAttributes(id, this.ATTRIBUTE_NAME, text);
-        this._client.completeTransaction();
+        if (!inTransaction) {
+            this._client.completeTransaction();
+        }
     };
 
     TextEditorControl.prototype.setName = function (name) {

src/visualizers/widgets/ExecutionView/SelectionManager.js

@@ -3,10 +3,12 @@
 define([
     'widgets/EasyDAG/SelectionManager',
     'widgets/EasyDAG/Buttons',
+    'deepforge/Constants',
     'underscore'
 ], function(
     EasyDAGSelectionManager,
     Buttons,
+    CONSTANTS,
     _
 ) {
     'use strict';
@@ -18,16 +20,19 @@ define([
     _.extend(SelectionManager.prototype, EasyDAGSelectionManager.prototype);
 
     SelectionManager.prototype.createActionButtons = function(width/*, height*/) {
-        // Add 'watch' and 'jumpToDef' buttons
-        // TODO
-        new Buttons.Enter({
-            context: this._widget,
-            $pEl: this.$selection,
-            item: this.selectedItem,
-            icon: 'monitor',
-            x: width,
-            y: 0
-        });
+        var jobName = this.selectedItem.desc.name;
+
+        // Check if it is an Input or Output job
+        if (jobName !== CONSTANTS.OP.INPUT && jobName !== CONSTANTS.OP.OUTPUT) {
+            new Buttons.Enter({
+                context: this._widget,
+                $pEl: this.$selection,
+                item: this.selectedItem,
+                icon: 'monitor',
+                x: width,
+                y: 0
+            });
+        }
     };
 
     return SelectionManager;

src/visualizers/widgets/ImageViewer/ImageViewerWidget.js

@@ -82,7 +82,6 @@ define([
 
     ImageViewerWidget.prototype.updateImage = function (url) {
         url = url || NO_IMAGE_URL;
-        this.zoom = 1;
         this.$image.attr('src', url);
     };
 

src/visualizers/widgets/LineGraph/lib/nv.d3.min.css.map

@@ -0,0 +1 @@
+{"version":3,"sources":["build/nv.d3.css"],"names":[],"mappings":"AAqBA,oBAfA,oBAgBI,KAAM,KAkXN,gBAAiB,WAhFrB,kBA+DA,uBAlWA,oBAfA,oBAkYI,gBAAiB,WAmErB,UAAW,UAJX,mBAtcA,eAqbA,uBA8BA,uCACI,eAAgB,KA+DpB,WA7QA,aAoRI,QAAS,MAST,sBAAuB,KAEvB,mBAAoB,KAriBxB,eAEI,QAAS,EAuCb,2BA2JA,0DACI,QAAS,EAhMb,oBAEI,OAAQ,KACR,eAAgB,IAIpB,2BACI,eAAgB,IAGpB,gCACI,eAAgB,EAGpB,oBAEI,OAAQ,QAIZ,0BACI,0BACA,eAAgB,IAGpB,mCACI,YAAa,IAGjB,sCACA,uCACA,uCACI,YAAa,OAOjB,oBACI,aAAc,IAEd,WAAY,aAAa,MAAM,OAC/B,gBAAiB,aAAa,MAAM,OACpC,mBAAoB,aAAa,MAAM,OAG3C,0BACI,aAAc,EAGlB,2BACI,KAAM,QAGV,oBACI,KAAM,YAGV,2BACI,KAAM,cAKV,sCAFA,mCACA,6CAEI,eAAgB,EAEhB,WAAY,aAAa,MAAM,OAC/B,gBAAiB,aAAa,MAAM,OACpC,mBAAoB,aAAa,MAAM,OAK3C,8CACA,4CAHA,yCACA,mDAGI,aAAc,EAGlB,sCACA,6CACI,YAAa,IACb,KAAM,cACN,OAAQ,YAIZ,yBACE,aAAc,GAGhB,+BAIA,6BAHE,aAAc,EAOhB,6BACE,OAAQ,KAGV,uBACE,aAAc,MAGhB,gBAAkB,KAAM,KAAK,WAC7B,4BAA8B,aAAc,GAC5C,kCAAoC,aAAc,EAClD,2BAA6B,OAAQ,KAAM,aAAc,IACzD,mCAAqC,OAAQ,KAAM,KAAM,KAAM,aAAc,MAC7E,8BAAgC,OAAQ,KAAM,aAAc,KAC5D,gCAAkC,KAAM,KACxC,gCAAkC,KAAM,KACxC,gCAAkC,KAAM,KACxC,0BAA4B,UAAW,KAAM,YAAa,IAC1D,6BAA+B,KAAM,KAGrC,0BACI,KAAM,QACN,aAAc,GAElB,gCACI,aAAc,GAGlB,2CACI,aAAc,IAGlB,iDACI,aAAc,IAGlB,yDACI,OAAQ,QACR,KAAM,QAGV,yDACI,OAAQ,QACR,KAAM,QAGV,wDACI,WAAY,aAAa,MAAM,OAAQ,eAAe,MAAM,OAC5D,gBAAiB,aAAa,MAAM,OAAQ,eAAe,MAAM,OACjE,mBAAoB,aAAa,MAAM,OAAQ,eAAe,MAAM,OAIxE,uCACI,OAAQ,KAIZ,eACE,OAAQ,KACR,aAAc,MAEhB,eACE,OAAQ,KACR,eAAgB,GAElB,oBACE,aAAc,EAOhB,4BACI,aAAa,EACb,aAAa,EAGjB,8BACI,aAAa,EACb,aAAa,EAGjB,qDACI,aAAa,EACb,eAAe,EAQnB,kCACI,aAAc,IAGlB,wCACI,aAAc,EAElB,8BACI,KAAM,KAGV,8BACI,OAAQ,KAGZ,oDACI,aAAc,EACd,eAAgB,EAGpB,sDACI,aAAc,aACd,eAAgB,aAIpB,6CACI,WAAY,aAAa,MAAM,OAAQ,eAAe,MAAM,OAC5D,gBAAiB,aAAa,MAAM,OAAQ,eAAe,MAAM,OACjE,mBAAoB,aAAa,MAAM,OAAQ,eAAe,MAAM,OAKxE,iCADA,4CAEI,aAAc,IACd,aAAc,cACd,eAAgB,cAIpB,2BACI,OAAQ,KACR,eAAgB,EAChB,KAAM,KACN,aAAc,EAKlB,oBACI,OAAQ,UAUZ,aAEI,oBAAqB,KAErB,gBAAiB,KACjB,iBAAkB,KAClB,YAAa,KAEb,MAAM,KACN,OAAO,KAMX,0BAA2B,2BACvB,gBAAiB,EAAE,IAAI,KAAK,eAC5B,mBAAoB,EAAE,IAAI,KAAK,eAC/B,WAAY,EAAE,IAAI,KAAK,eAEvB,sBAAuB,IACvB,mBAAoB,IACpB,cAAe,IAInB,WACI,KAAM,IAAO,KAAK,MAGtB,aACI,KAAM,IAAK,KAAK,MAGpB,qBACI,KAAM,KACN,aAAc,EAGlB,gBACI,UAAW,KACX,YAAa,IAQjB,kBACI,aAAc,KAIlB,uBACI,KAAM,KACN,OAAQ,KAQZ,4BACI,OAAQ,QAGZ,qCACI,aAAc,EAIlB,wBACI,aAAc,YAGlB,+BACI,OAAQ,KACR,aAAc,GACd,KAAM,KACN,aAAc,GAOlB,aACE,WACE,aAAc,EACd,aAAc,GAIlB,oCACI,aAAc,IAGlB,0CACI,aAAc,IAGlB,6CACI,OAAQ,QAGZ,6CACI,OAAQ,QAIZ,uBACI,KAAM,KACN,OAAQ,KACR,eAAgB,GAIpB,uBACI,KAAM,KACN,eAAgB,GAGpB,4CAEI,KAAM,KACN,aAAc,GACd,OAAQ,KACR,gBAAiB,WAGrB,qCACI,aAAc,EACjB,aAAc,IAIf,8BACE,KAAM,KACN,OAAQ,KACR,aAAc,EACd,eAAgB,EAChB,iBAAkB,EAAG,EAUvB,2BACI,UAAW,KACX,KAAM,qBAGV,4BACI,OAAQ,KACR,aAAc,EAGlB,kBAhBI,WAAY,aAAa,MAAM,OAAQ,aAAa,MAAM,OAAQ,eAAe,MAAM,OACvF,gBAAiB,aAAa,MAAM,OAAQ,aAAa,MAAM,OAAQ,eAAe,MAAM,OAC5F,mBAAoB,aAAa,MAAM,OAAQ,aAAa,MAAM,OAAQ,eAAe,MAAM,OAe/F,OAAQ,KACR,aAAc,IACd,eAAgB,EAIhB,aAAc,GAElB,yBACI,aAAc,EAKlB,4BACI,aAAc,EACd,eAAgB,EAIpB,iCACI,aAAc,KACd,eAAgB,GAGpB,kCACI,aAAc,EAWlB,wBACI,KAAM,KAOV,2CACI,OAAQ,KACR,aAAc,MAGlB,uBACA,yBACI,eAAgB,IAwLpB,+BAnIA,WAoII,eAAe,KAtLnB,oBACI,aAAc,EACd,eAAgB,EAGpB,kCACA,kCACI,aAAc,EACd,UAAW,KACX,YAAa,IAGjB,kCACI,OAAQ,KAGZ,oCACI,OAAQ,QACR,KAAM,QAGV,oCACI,OAAQ,QACR,KAAM,QAGV,wCACI,YAAa,IACb,UAAW,MAsEf,cAsCA,wBACI,YAAa,IA1GjB,kCACI,aAAc,GACd,eAAgB,EAChB,WAAY,aAAa,MAAM,OAAQ,eAAe,MAAM,OAC5D,gBAAiB,aAAa,MAAM,OAAQ,eAAe,MAAM,OACjE,mBAAoB,aAAa,MAAM,OAAQ,eAAe,MAAM,OAGxE,wCACI,aAAc,GAIlB,0CACI,eAAgB,EAChB,aAAc,EAIlB,WACI,SAAU,SAEV,MAAO,cACP,QAAS,IAET,QAAS,MAGT,YAAa,MACb,UAAW,KACX,WAAY,KAGZ,YAAa,OAGb,oBAAqB,KAErB,iBAAkB,KAClB,gBAAiB,KACjB,YAAa,KAIb,WAAY,qBACZ,OAAQ,IAAI,MAAM,eAClB,cAAe,IAqBnB,cAgBA,aACI,OAAQ,EAER,WAAY,OAlChB,4BAA6B,6BACzB,WAAY,QAAQ,KAAK,OACzB,gBAAiB,QAAQ,KAAK,OAC9B,mBAAoB,QAAQ,KAAK,OAEjC,iBAAkB,MAClB,sBAAuB,MACvB,yBAA0B,MAG9B,uBACA,uBACI,QAAS,IAGb,cAEI,QAAS,IAAI,KACb,YAAa,KAEb,iBAAkB,sBAClB,MAAO,cAGP,cAAe,IAAI,MAAM,QAEzB,sBAAuB,IAAI,IAAI,EAAE,EACjC,mBAAoB,IAAI,IAAI,EAAE,EAC9B,cAAe,IAAI,IAAI,EAAE,EAG7B,aAEI,QAAS,IAAI,KAIjB,gBACI,QAAS,aACT,OAAQ,IAAI,EAGhB,iBACI,OAAQ,IACR,eAAe,EAInB,oBACI,QAAS,IAAI,IAAI,IAAI,EACrB,eAAgB,OAMpB,8BACI,YAAa,IAEjB,0BACI,WAAY,MACZ,YAAa,IAGjB,iCACI,QAAS,IAAI,IAAI,IAAI,EACrB,oBAAqB,MACrB,oBAAqB,IACrB,iBAAkB,MAClB,iBAAkB,IAGtB,2CAGI,eAAgB,OAIhB,MAAO,KACP,OAAQ,KACR,OAAQ,IAAI,MAAM,KAGtB,mBACI,QAAS,IACT,WAAY,OAGhB,2BACI,eAAgB,KAChB,QAAS,KAUb,wBACI,OAAQ"}

src/visualizers/widgets/MainView/MainViewWidget.js

@@ -2,12 +2,14 @@
 /*jshint browser: true*/
 
 define([
+    'panel/FloatingActionButton/styles/Materialize',
     'deepforge/globals',
     'text!./NavBar.html',
     'text!./ListItem.ejs',
     'underscore',
     'css!./styles/MainViewWidget.css'
 ], function (
+    Materialize,
     DeepForge,
     NavBarHTML,
     ListItem,
@@ -24,12 +26,12 @@ define([
         ];
 
     MainViewWidget = function (logger, container) {
-        this._logger = logger.fork('Widget');
+        this.logger = logger.fork('Widget');
         this.$el = container;
         this.$el.addClass(WIDGET_CLASS);
         this.toggleIndex = 0;
         this.initialize();
-        this._logger.debug('ctor finished');
+        this.logger.debug('ctor finished');
     };
 
     MainViewWidget.prototype.initialize = function () {
@@ -66,6 +68,51 @@ define([
         this.$nav.on('click', '.dl-node', this.onDownloadNodeClick.bind(this));
 
         this.htmlFor = {};
+
+        setTimeout(() => this.checkLibraries(), 100);
+    };
+
+    MainViewWidget.prototype.checkLibraries = function () {
+
+        this.checkLibUpdates()
+            .then(updates => {
+                if (updates.length) {  // prompt about updates
+                    var names = updates.map(update => update[0]),
+                        projName = this.getProjectName(),
+                        content = $('<span>'),
+                        msg = `${projName} is out of date. Click to update.`;
+
+                    this.logger.info(`Updates available for ${names.join(', ')}`);
+
+                    if (names.indexOf('nn') !== -1) {
+                        msg = 'Newer nn library available. Click to update';
+                    } else if (names.indexOf('pipeline') !== -1) {
+                        msg = 'Execution updates available. Click to update';
+                    }
+
+                    content.text(msg);
+                    content.on('click', () => {
+                        // Remove the toast
+                        content.parent().fadeOut();
+
+                        // Create updating notification
+                        msg = 'Updating execution library...';
+                        if (names.indexOf('nn') !== -1) {
+                            msg = 'Updating nn library...';
+                        }
+
+                        content.text(msg);
+                        Materialize.toast(content, 8000);
+                        this.updateLibraries(updates).then(() => {
+                            content.parent().remove();
+                            Materialize.toast('Update complete!', 2000);
+                        });
+                    });
+
+                    Materialize.toast(content, 8000);
+                }
+            })
+            .fail(err => Materialize.toast(`Library update check failed: ${err}`, 2000));
     };
 
     MainViewWidget.prototype.width = function () {
@@ -189,11 +236,11 @@ define([
     };
 
     MainViewWidget.prototype.onActivate = function () {
-        this._logger.debug('MainViewWidget has been activated');
+        this.logger.debug('MainViewWidget has been activated');
     };
 
     MainViewWidget.prototype.onDeactivate = function () {
-        this._logger.debug('MainViewWidget has been deactivated');
+        this.logger.debug('MainViewWidget has been deactivated');
     };
 
     return MainViewWidget;

src/visualizers/widgets/PipelineEditor/PipelineEditorWidget.js

@@ -2,6 +2,7 @@
 /*jshint browser: true*/
 
 define([
+    'deepforge/Constants',
     'widgets/EasyDAG/AddNodeDialog',
     'widgets/EasyDAG/EasyDAGWidget',
     'deepforge/viz/PipelineControl',
@@ -13,6 +14,7 @@ define([
     'underscore',
     'css!./styles/PipelineEditorWidget.css'
 ], function (
+    CONSTANTS,
     AddNodeDialog,
     EasyDAGWidget,
     PipelineControl,
@@ -32,8 +34,7 @@ define([
         STATE = {
             DEFAULT: 'default',
             CONNECTING: 'connecting'
-        },
-        UPLOAD_ARTIFACT_ID = '__UPLOAD_ARTIFACT__';
+        };
 
     PipelineEditorWidget = function (logger, container, execCntr) {
         EasyDAGWidget.call(this, logger, container);
@@ -326,7 +327,7 @@ define([
             () => WebGMEGlobal.State.registerActiveObject(exec.id));
 
         // Add the remove icon
-        rmIcon.on('click', () => this.deleteNode(exec.id));
+        rmIcon.on('click', () => this.deleteExecution(exec.id));
         row.append(title, timestamp, rmIcon);
         row[0].className = className;
         return row;
@@ -339,36 +340,55 @@ define([
 
     ////////////////////////// Action Overrides //////////////////////////
     PipelineEditorWidget.prototype.selectTargetFor = function(itemId) {
-        // If it is an 'ArtifactLoader', then we will need to add 'upload artifact'
+        // If it is an input operation, then we will need to add 'upload artifact'
         // options
-        if (this.items[itemId].desc.baseName === 'ArtifactLoader') {
-            this.selectTargetForLoader.apply(this, arguments);
+        if (this.items[itemId].desc.baseName === CONSTANTS.OP.INPUT) {
+            return this.selectTargetForLoader.apply(this, arguments);
+        } else if (this.isArchitecturePtr.apply(this, arguments)) {
+            // Create new architecture from the "set ptr" dialog
+            return this.selectArchitectureTarget.apply(this, arguments);
         } else {
             return EasyDAGWidget.prototype.selectTargetFor.apply(this, arguments);
         }
     };
 
-    PipelineEditorWidget.prototype.selectTargetForLoader = function(itemId, ptr, filter) {
-        var validTargets = this.getValidTargetsFor(itemId, ptr, filter),
-            nodeId = validTargets.length ? validTargets[0].node.id : null,
-            uploadNode;
+    PipelineEditorWidget.prototype.addCreationNode = function(name, targets) {
+        var nodeId = targets.length ? targets[0].node.id : null,
+            creationNode;
 
-        // Add the 'Upload Artifact' option
-        uploadNode = {
+        creationNode = {
             node: {
-                id: UPLOAD_ARTIFACT_ID,
-                name: 'Upload Artifact',
+                id: `creation-node-${name}`,
+                name: name,
                 class: 'create-node',
                 attributes: {},
                 Decorator: this.getDecorator(nodeId)
             }
         };
-        validTargets.push(uploadNode);
 
+        targets.push(creationNode);
+        return creationNode.node.id;
+    };
+
+    PipelineEditorWidget.prototype.selectArchitectureTarget = function(itemId, ptr, filter) {
+        return this.selectTargetWithCreationNode('New Architecture',
+            DeepForge.create.Architecture, itemId, ptr, filter);
+    };
+
+    PipelineEditorWidget.prototype.selectTargetForLoader = function(itemId, ptr, filter) {
+        return this.selectTargetWithCreationNode('Upload Artifact',
+            DeepForge.create.Artifact, itemId, ptr, filter);
+    };
+
+    PipelineEditorWidget.prototype.selectTargetWithCreationNode = function(name, fn, itemId, ptr, filter) {
+        var validTargets = this.getValidTargetsFor(itemId, ptr, filter),
+            creationNodeId = this.addCreationNode(name, validTargets);
+
+        // Add the 'Upload Artifact' option
         AddNodeDialog.prompt(validTargets)
             .then(selected => {
-                if (selected.node.id === UPLOAD_ARTIFACT_ID) {
-                    DeepForge.create.Artifact();
+                if (selected.node.id === creationNodeId) {
+                    fn();
                 } else {
                     var item = this.items[itemId];
                     if (item.decorator.savePointer) {

src/visualizers/widgets/TextEditor/deepforge.json

@@ -1,6 +1,7 @@
 {
     "deepforge": [
         "Graph",
+        "initialize",
         "image"
     ],
     "torch": [

test/common/JobLogsClient.spec.js

@@ -0,0 +1,138 @@
+var testFixture = require('../globals'),
+    expect = testFixture.expect,
+    assert = require('assert'),
+    path = testFixture.path,
+    gmeConfig = testFixture.getGmeConfig(),
+    blobDir = gmeConfig.blob.fsDir,
+    server = testFixture.WebGME.standaloneServer(gmeConfig),
+    Logger = require('webgme/src/server/logger'),
+    logger = Logger.createWithGmeConfig('gme', gmeConfig, true),
+    JobLogsClient = testFixture.requirejs('deepforge/JobLogsClient'),
+    rm_rf = require('rimraf'),
+    exists = require('exists-file');
+
+describe('JobLogsClient', function() {
+    var logClient = new JobLogsClient({
+            logger: logger,
+            origin: server.getUrl(),
+            projectId: 'testProject',
+            branchName: 'master'
+        }),
+        jobId = '/4/q/l',
+        firstLog = 'hello world';
+
+    before(function(done) {
+        testFixture.mkdir(blobDir);
+        server.start(done);
+    });
+
+    after(function(done) {
+        rm_rf.sync(blobDir);
+        server.stop(done);
+    });
+
+    describe('appendTo', function() {
+
+        before(function(done) {
+            logClient.appendTo(jobId, firstLog)
+                .then(() => done())
+                .catch(err => done(err));
+        });
+
+        it('should create job-logs directory', function() {
+            assert(exists.sync(path.join(blobDir, 'log-storage')));
+        });
+
+        describe('getLog', function() {
+            it('should return the logs from the job', function(done) {
+                logClient.getLog(jobId).then(log => {
+                    expect(log).to.contain(firstLog);
+                    done();
+                });
+            });
+
+            it('should append additional logs to the file', function(done) {
+                var secondLog = 'goodbye world';
+                logClient.appendTo(jobId, secondLog)
+                    .then(() => logClient.getLog(jobId))
+                    .then(log => {
+                        expect(log).to.contain(secondLog);
+                        done();
+                    });
+            });
+
+        });
+    });
+
+    describe('delete', function() {
+        var delJobId = '/4/8/l';
+
+        before(function(done) {
+            logClient.appendTo(delJobId, firstLog).then(() => done());
+        });
+
+        it('should delete the file from job-logs directory', function(done) {
+            logClient.deleteLog(delJobId)
+                .then(() => logClient.getLog(delJobId))
+                .then(log => {
+                    expect(log).to.equal('');
+                    done();
+                });
+        });
+    });
+
+    describe('migration', function() {
+        var client,
+            jId = '/asd/4/q',
+            logs = 'asdfasde',
+            newBranch = 'otherBranch';
+
+        before(function(done) {
+            client = new JobLogsClient({
+                logger: logger,
+                origin: server.getUrl(),
+                projectId: 'migTest',
+                branchName: 'master'
+            });
+            // Write logs to job
+            client.appendTo(jId, logs)
+                .then(() => client.fork(newBranch))
+                .catch(err => done(err))
+                .then(() => done());
+        });
+
+        it('should migrate the edited nodes to the new branch', function(done) {
+            client.getLog(jId).then(log => {
+                expect(log).to.equal(logs);
+                done();
+            });
+        });
+
+        describe('new logs', function() {
+            it('should not edit old job logs', function() {
+                var c2 = new JobLogsClient({
+                    logger: logger,
+                    origin: server.getUrl(),
+                    projectId: 'migTest',
+                    branchName: 'master'
+                });
+                c2.getLog(jId).then(log => {
+                    expect(log).to.equal(logs);
+                    done();
+                });
+            });
+
+            it('should write new logs', function() {
+                client.appendTo(jId, 'moreStuff')
+                    .then(() => client.getLog(jId))
+                    .then(log => {
+                        expect(log).to.contain('moreStuff');
+                        done();
+                    });
+            });
+        });
+
+        // TODO: Test that, on a fork, the logClient will copy all the current jobs to 
+        // the new fork name
+    });
+});

test/globals.js

@@ -7,6 +7,9 @@
 'use strict';
 
 var testFixture = require('webgme/test/_globals'),
+    path = require('path'),
+    fs = require('fs'),
+    exists = require('exists-file'),
     WEBGME_CONFIG_PATH = '../config';
 
 // This flag will make sure the config.test.js is being used
@@ -34,4 +37,18 @@ testFixture.requirejs.config({
 testFixture.getGmeConfig = getGmeConfig;
 
 testFixture.DF_SEED_DIR = testFixture.path.join(__dirname, '..', 'src', 'seeds');
+
+testFixture.mkdir = function(dir) {
+    var dirs = path.resolve(dir).split(path.sep),
+        shortDir,
+        i = 1;
+
+    while (i++ < dirs.length) {
+        shortDir = dirs.slice(0,i).join(path.sep);
+        if (!exists.sync(shortDir)) {
+            fs.mkdirSync(shortDir);
+        }
+    }
+};
+
 module.exports = testFixture;

test/plugins/CheckLibraries/CheckLibraries.spec.js

@@ -0,0 +1,79 @@
+/*jshint node:true, mocha:true*/
+/**
+ * Generated by PluginGenerator 1.7.0 from webgme on Tue Aug 23 2016 11:02:08 GMT-0500 (CDT).
+ */
+
+'use strict';
+var testFixture = require('../../globals');
+
+describe('CheckLibraries', function () {
+    var gmeConfig = testFixture.getGmeConfig(),
+        expect = testFixture.expect,
+        logger = testFixture.logger.fork('CheckLibraries'),
+        PluginCliManager = testFixture.WebGME.PluginCliManager,
+        projectName = 'testProject',
+        pluginName = 'CheckLibraries',
+        project,
+        gmeAuth,
+        storage,
+        commitHash;
+
+    before(function (done) {
+        testFixture.clearDBAndGetGMEAuth(gmeConfig, projectName)
+            .then(function (gmeAuth_) {
+                gmeAuth = gmeAuth_;
+                // This uses in memory storage. Use testFixture.getMongoStorage to persist test to database.
+                storage = testFixture.getMemoryStorage(logger, gmeConfig, gmeAuth);
+                return storage.openDatabase();
+            })
+            .then(function () {
+                var importParam = {
+                    projectSeed: testFixture.path.join(testFixture.SEED_DIR, 'EmptyProject.webgmex'),
+                    projectName: projectName,
+                    branchName: 'master',
+                    logger: logger,
+                    gmeConfig: gmeConfig
+                };
+
+                return testFixture.importProject(storage, importParam);
+            })
+            .then(function (importResult) {
+                project = importResult.project;
+                commitHash = importResult.commitHash;
+                return project.createBranch('test', commitHash);
+            })
+            .nodeify(done);
+    });
+
+    after(function (done) {
+        storage.closeDatabase()
+            .then(function () {
+                return gmeAuth.unload();
+            })
+            .nodeify(done);
+    });
+
+    it('should not edit the model', function (done) {
+        var manager = new PluginCliManager(null, logger, gmeConfig),
+            pluginConfig = {
+            },
+            context = {
+                project: project,
+                commitHash: commitHash,
+                branchName: 'test',
+                activeNode: '/1'
+            };
+
+        manager.executePlugin(pluginName, pluginConfig, context, function (err, pluginResult) {
+            expect(err).to.equal(null);
+            expect(typeof pluginResult).to.equal('object');
+            expect(pluginResult.success).to.equal(true);
+
+            project.getBranchHash('test')
+                .then(function (branchHash) {
+                    expect(branchHash).to.equal(commitHash);
+                })
+                .nodeify(done);
+        });
+    });
+});

test/plugins/GenerateArchitecture/GenerateArchitecture.spec.js

@@ -89,6 +89,7 @@ describe('GenerateArchitecture', function () {
             //['/o', 'basic.lua'],
             //['/8', 'basic-transfers.lua'],
             //['/M', 'concat-parallel.lua'],
+            ['/4', 'requiredOmitted.lua'],
             ['/e', 'googlenet.lua'],
             ['/X', 'overfeat.lua']
         ];

test/plugins/UpdateLibrarySeed/UpdateLibrarySeed.spec.js

@@ -0,0 +1,76 @@
+/*jshint node:true, mocha:true*/
+
+'use strict';
+var testFixture = require('../../globals');
+
+describe.skip('UpdateLibrarySeed', function () {
+    var gmeConfig = testFixture.getGmeConfig(),
+        expect = testFixture.expect,
+        logger = testFixture.logger.fork('UpdateLibrarySeed'),
+        PluginCliManager = testFixture.WebGME.PluginCliManager,
+        projectName = 'testProject',
+        pluginName = 'UpdateLibrarySeed',
+        project,
+        gmeAuth,
+        storage,
+        commitHash;
+
+    before(function (done) {
+        testFixture.clearDBAndGetGMEAuth(gmeConfig, projectName)
+            .then(function (gmeAuth_) {
+                gmeAuth = gmeAuth_;
+                // This uses in memory storage. Use testFixture.getMongoStorage to persist test to database.
+                storage = testFixture.getMemoryStorage(logger, gmeConfig, gmeAuth);
+                return storage.openDatabase();
+            })
+            .then(function () {
+                var importParam = {
+                    projectSeed: testFixture.path.join(testFixture.SEED_DIR, 'EmptyProject.webgmex'),
+                    projectName: projectName,
+                    branchName: 'master',
+                    logger: logger,
+                    gmeConfig: gmeConfig
+                };
+
+                return testFixture.importProject(storage, importParam);
+            })
+            .then(function (importResult) {
+                project = importResult.project;
+                commitHash = importResult.commitHash;
+                return project.createBranch('test', commitHash);
+            })
+            .nodeify(done);
+    });
+
+    after(function (done) {
+        storage.closeDatabase()
+            .then(function () {
+                return gmeAuth.unload();
+            })
+            .nodeify(done);
+    });
+
+    it('should run plugin and update the branch', function (done) {
+        var manager = new PluginCliManager(null, logger, gmeConfig),
+            pluginConfig = {
+            },
+            context = {
+                project: project,
+                commitHash: commitHash,
+                branchName: 'test',
+                activeNode: '/1'
+            };
+
+        manager.executePlugin(pluginName, pluginConfig, context, function (err, pluginResult) {
+            expect(err).to.equal(null);
+            expect(typeof pluginResult).to.equal('object');
+            expect(pluginResult.success).to.equal(true);
+
+            project.getBranchHash('test')
+                .then(function (branchHash) {
+                    expect(branchHash).to.not.equal(commitHash);
+                })
+                .nodeify(done);
+        });
+    });
+});

test/routers/JobLogsAPI.spec.js

@@ -0,0 +1,211 @@
+var testFixture = require('../globals'),
+    superagent = testFixture.superagent,
+    Q = testFixture.Q,
+    expect = testFixture.expect,
+    assert = require('assert'),
+    path = testFixture.path,
+    gmeConfig = testFixture.getGmeConfig(),
+    blobDir = gmeConfig.blob.fsDir,
+    server = testFixture.WebGME.standaloneServer(gmeConfig),
+    mntPt = 'execution/logs',
+    rm_rf = require('rimraf'),
+    exists = require('exists-file');
+
+describe('JobLogsAPI', function() {
+    var project = 'testProject',
+        branch = 'master',
+        jobId = encodeURIComponent('/4/q/l'),
+        firstLog = 'hello world',
+        url = [
+            server.getUrl(),
+            mntPt,
+            project,
+            branch,
+            jobId
+        ].join('/');
+
+    before(function(done) {
+        testFixture.mkdir(blobDir);
+        server.start(done);
+    });
+
+    after(function(done) {
+        rm_rf.sync(blobDir);
+        server.stop(done);
+    });
+
+    describe('appendTo', function() {
+
+        before(function(done) {
+            superagent.patch(url)
+                .send({patch: firstLog})
+                .end(function (err, res) {
+                    expect(res.status).equal(200, err);
+                    done();
+                });
+        });
+
+        it('should create job-logs directory', function() {
+            assert(exists.sync(path.join(blobDir, 'log-storage')));
+        });
+
+        describe('getLog', function() {
+            it('should return the logs from the job', function(done) {
+                superagent.get(url)
+                    .end(function (err, res) {
+                        expect(res.status).equal(200, err);
+                        expect(res.text).to.contain(firstLog);
+                        done();
+                    });
+            });
+
+            it('should append additional logs to the file', function(done) {
+                var secondLog = 'goodbye world';
+                superagent.patch(url)
+                    .send({patch: secondLog})
+                    .end(function (err, res) {
+                        expect(res.status).equal(200, err);
+                        superagent.get(url)
+                            .end(function (err, res) {
+                                expect(res.status).equal(200, err);
+                                expect(res.text).to.contain(secondLog);
+                                done();
+                            });
+                    });
+            });
+
+        });
+    });
+
+    describe('delete', function() {
+        var delUrl = [
+            server.getUrl(),
+            mntPt,
+            'testProject',
+            'other',
+            encodeURIComponent('/4/8/l')
+        ].join('/');
+
+        before(function(done) {
+            superagent.patch(delUrl)
+                .send({patch: firstLog})
+                .end(function (err, res) {
+                    expect(res.status).equal(200, err);
+                    done();
+                });
+        });
+
+        it('should delete the file from job-logs directory', function(done) {
+            superagent.delete(delUrl)
+                .end(function (err, res) {
+                    expect(res.status).equal(200, err);
+                    superagent.get(delUrl)
+                        .end(function (err, res) {
+                            expect(res.status).equal(200, err);
+                            expect(res.text).to.equal('');
+                            done();
+                        });
+                });
+        });
+    });
+
+    function getUrl(project, branch, job) {
+        return [
+            server.getUrl(),
+            mntPt,
+            encodeURIComponent(project),
+            encodeURIComponent(branch),
+            encodeURIComponent(job)
+        ].join('/');
+    }
+
+    function addLog(project, branch, job, log) {
+        var deferred = Q.defer();
+
+        console.log('adding log', log);
+        superagent.patch(getUrl(project, branch, job))
+            .send({patch: log})
+            .end(function (err, res) {
+                if (err) {
+                    return deferred.reject(err + ' (' + job + ')');
+                }
+                return deferred.resolve(res);
+            });
+            
+        return deferred.promise;
+    }
+
+    describe('migrate', function() {
+        var j1 = '/s/p/3',
+            j2 = '/1/d/4',
+            b1 = 'asdfmaster',
+            b2 = 'not-master',
+            proj = 'someProject',
+            j1log = 'I am ' + j1,
+            j2log = 'I am ' + j2,
+            url;
+
+        before(function(done) {
+            Q.all([
+                addLog(proj, b1, j1, j1log),
+                addLog(proj, b1, j2, j2log),
+                addLog(proj, b2, j2, 'otherStuff')
+            ]).then(() => {
+                url = [
+                    server.getUrl(),
+                    mntPt + '/migrate',
+                    encodeURIComponent(proj),
+                    encodeURIComponent(b1),
+                    encodeURIComponent(b2)
+                ].join('/');
+                superagent.post(url)
+                    .send({jobs: [j1]})
+                    .end(err => done(err));
+            })
+            .catch(err => done(err));
+
+        });
+
+        it('should copy the log content to the new branch', function(done) {
+            url = getUrl(proj, b2, j1);
+            superagent.get(url)
+                .end((err, res) => {
+                    expect(res.text).to.equal(j1log);
+                    done(err);
+                });
+        });
+
+        it('should not copy other jobs', function(done) {
+            url = getUrl(proj, b2, j2);
+            superagent.get(url)
+                .end((err, res) => {
+                    // This log shouldn't be updated
+                    expect(res.text).to.not.equal(j2log);
+                    done(err);
+                });
+        });
+
+        it('should not change original log', function(done) {
+            url = getUrl(proj, b1, j1);
+            superagent.get(url)
+                .end((err, res) => {
+                    expect(res.text).to.equal(j1log);
+                    done(err);
+                });
+        });
+
+        it('should not crash on bad request', function(done) {
+            url = [
+                server.getUrl(),
+                mntPt + '/migrate',
+                encodeURIComponent(proj),
+                encodeURIComponent('someBranch3'),
+                encodeURIComponent(b2)
+            ].join('/');
+            superagent.post(url)
+                .send({jobs: [j1]})
+                .end(err => done(err));
+        });
+    });
+
+});

test/test-cases/generated-code/googlenet.lua

@@ -11,136 +11,130 @@ net:add(nn.SpatialConvolution(64, 192, 3, 3, 1, 1, 1, 1))
 net:add(nn.ReLU(true))
 net:add(nn.SpatialMaxPooling(3, 3, 2, 2))
 
-local net = nn.Sequential()
-net:add(nn.SpatialConvolution(192, 64, 1, 1, 1, 1))
-net:add(nn.ReLU(true))
-net:add(nn.SpatialConvolution(64, 96, 3, 3, 1, 1, 1, 1))
-net:add(nn.ReLU(true))
-net:add(nn.SpatialConvolution(96, 96, 3, 3, 1, 1, 1, 1))
-net:add(nn.ReLU(true))
-
 local net_2 = nn.Sequential()
 net_2:add(nn.SpatialConvolution(192, 64, 1, 1, 1, 1))
 net_2:add(nn.ReLU(true))
+net_2:add(nn.SpatialConvolution(64, 96, 3, 3, 1, 1, 1, 1))
+net_2:add(nn.ReLU(true))
+net_2:add(nn.SpatialConvolution(96, 96, 3, 3, 1, 1, 1, 1))
+net_2:add(nn.ReLU(true))
 
 local net_3 = nn.Sequential()
 net_3:add(nn.SpatialConvolution(192, 64, 1, 1, 1, 1))
 net_3:add(nn.ReLU(true))
-net_3:add(nn.SpatialConvolution(64, 64, 3, 3, 1, 1, 1, 1))
-net_3:add(nn.ReLU(true))
 
 local net_4 = nn.Sequential()
-net_4:add(nn.SpatialZeroPadding(1, 1, 1, 1))
-net_4:add(nn.SpatialAveragePooling(3, 3, 1, 1))
-net_4:add(nn.SpatialConvolution(192, 32, 1, 1, 1, 1))
+net_4:add(nn.SpatialConvolution(192, 64, 1, 1, 1, 1))
+net_4:add(nn.ReLU(true))
+net_4:add(nn.SpatialConvolution(64, 64, 3, 3, 1, 1, 1, 1))
 net_4:add(nn.ReLU(true))
 
+local net_5 = nn.Sequential()
+net_5:add(nn.SpatialZeroPadding(1, 1, 1, 1))
+net_5:add(nn.SpatialAveragePooling(3, 3, 1, 1))
+net_5:add(nn.SpatialConvolution(192, 32, 1, 1, 1, 1))
+net_5:add(nn.ReLU(true))
+
 local concat_24 = nn.Concat(2)
+concat_24:add(net_5)
 concat_24:add(net_4)
 concat_24:add(net_3)
 concat_24:add(net_2)
-concat_24:add(net)
 
 net:add(concat_24)
 
-local net_5 = nn.Sequential()
-net_5:add(nn.SpatialConvolution(256, 64, 1, 1, 1, 1))
-net_5:add(nn.ReLU(true))
-
 local net_6 = nn.Sequential()
 net_6:add(nn.SpatialConvolution(256, 64, 1, 1, 1, 1))
 net_6:add(nn.ReLU(true))
-net_6:add(nn.SpatialConvolution(64, 96, 3, 3, 1, 1, 1, 1))
-net_6:add(nn.ReLU(true))
 
 local net_7 = nn.Sequential()
 net_7:add(nn.SpatialConvolution(256, 64, 1, 1, 1, 1))
 net_7:add(nn.ReLU(true))
 net_7:add(nn.SpatialConvolution(64, 96, 3, 3, 1, 1, 1, 1))
 net_7:add(nn.ReLU(true))
-net_7:add(nn.SpatialConvolution(96, 96, 3, 3, 1, 1, 1, 1))
-net_7:add(nn.ReLU(true))
 
 local net_8 = nn.Sequential()
-net_8:add(nn.SpatialZeroPadding(1, 1, 1, 1))
-net_8:add(nn.SpatialAveragePooling(3, 3, 1, 1))
 net_8:add(nn.SpatialConvolution(256, 64, 1, 1, 1, 1))
 net_8:add(nn.ReLU(true))
+net_8:add(nn.SpatialConvolution(64, 96, 3, 3, 1, 1, 1, 1))
+net_8:add(nn.ReLU(true))
+net_8:add(nn.SpatialConvolution(96, 96, 3, 3, 1, 1, 1, 1))
+net_8:add(nn.ReLU(true))
+
+local net_9 = nn.Sequential()
+net_9:add(nn.SpatialZeroPadding(1, 1, 1, 1))
+net_9:add(nn.SpatialAveragePooling(3, 3, 1, 1))
+net_9:add(nn.SpatialConvolution(256, 64, 1, 1, 1, 1))
+net_9:add(nn.ReLU(true))
 
 local concat_41 = nn.Concat(2)
+concat_41:add(net_9)
 concat_41:add(net_8)
 concat_41:add(net_7)
 concat_41:add(net_6)
-concat_41:add(net_5)
 
 net:add(concat_41)
 
-local net_9 = nn.Sequential()
-net_9:add(nn.SpatialConvolution(320, 128, 1, 1, 1, 1))
-net_9:add(nn.ReLU(true))
-net_9:add(nn.SpatialConvolution(128, 160, 3, 3, 1, 1, 1, 1))
-net_9:add(nn.ReLU(true))
-
 local net_10 = nn.Sequential()
-net_10:add(nn.SpatialConvolution(320, 64, 1, 1, 1, 1))
+net_10:add(nn.SpatialConvolution(320, 128, 1, 1, 1, 1))
 net_10:add(nn.ReLU(true))
-net_10:add(nn.SpatialConvolution(64, 96, 3, 3, 1, 1, 1, 1))
-net_10:add(nn.ReLU(true))
-net_10:add(nn.SpatialConvolution(96, 96, 3, 3, 1, 1, 1, 1))
+net_10:add(nn.SpatialConvolution(128, 160, 3, 3, 1, 1, 1, 1))
 net_10:add(nn.ReLU(true))
 
 local net_11 = nn.Sequential()
-net_11:add(nn.SpatialZeroPadding(1, 1, 1, 1))
-net_11:add(nn.SpatialMaxPooling(3, 3, 1, 1))
+net_11:add(nn.SpatialConvolution(320, 64, 1, 1, 1, 1))
+net_11:add(nn.ReLU(true))
+net_11:add(nn.SpatialConvolution(64, 96, 3, 3, 1, 1, 1, 1))
+net_11:add(nn.ReLU(true))
+net_11:add(nn.SpatialConvolution(96, 96, 3, 3, 1, 1, 1, 1))
+net_11:add(nn.ReLU(true))
+
+local net_12 = nn.Sequential()
+net_12:add(nn.SpatialZeroPadding(1, 1, 1, 1))
+net_12:add(nn.SpatialMaxPooling(3, 3, 1, 1))
 
 local concat_54 = nn.Concat(2)
+concat_54:add(net_12)
 concat_54:add(net_11)
 concat_54:add(net_10)
-concat_54:add(net_9)
 
 net:add(concat_54)
 net:add(nn.SpatialConvolution(576, 576, 2, 2, 2, 2))
 
-local net_12 = nn.Sequential()
-net_12:add(nn.SpatialConvolution(576, 224, 1, 1, 1, 1))
-net_12:add(nn.ReLU(true))
-
 local net_13 = nn.Sequential()
-net_13:add(nn.SpatialConvolution(576, 64, 1, 1, 1, 1))
-net_13:add(nn.ReLU(true))
-net_13:add(nn.SpatialConvolution(64, 96, 3, 3, 1, 1, 1, 1))
+net_13:add(nn.SpatialConvolution(576, 224, 1, 1, 1, 1))
 net_13:add(nn.ReLU(true))
 
 local net_14 = nn.Sequential()
-net_14:add(nn.SpatialConvolution(576, 96, 1, 1, 1, 1))
+net_14:add(nn.SpatialConvolution(576, 64, 1, 1, 1, 1))
 net_14:add(nn.ReLU(true))
-net_14:add(nn.SpatialConvolution(96, 128, 3, 3, 1, 1, 1, 1))
-net_14:add(nn.ReLU(true))
-net_14:add(nn.SpatialConvolution(128, 128, 3, 3, 1, 1, 1, 1))
+net_14:add(nn.SpatialConvolution(64, 96, 3, 3, 1, 1, 1, 1))
 net_14:add(nn.ReLU(true))
 
 local net_15 = nn.Sequential()
-net_15:add(nn.SpatialZeroPadding(1, 1, 1, 1))
-net_15:add(nn.SpatialAveragePooling(3, 3, 1, 1))
-net_15:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
+net_15:add(nn.SpatialConvolution(576, 96, 1, 1, 1, 1))
+net_15:add(nn.ReLU(true))
+net_15:add(nn.SpatialConvolution(96, 128, 3, 3, 1, 1, 1, 1))
+net_15:add(nn.ReLU(true))
+net_15:add(nn.SpatialConvolution(128, 128, 3, 3, 1, 1, 1, 1))
 net_15:add(nn.ReLU(true))
 
+local net_16 = nn.Sequential()
+net_16:add(nn.SpatialZeroPadding(1, 1, 1, 1))
+net_16:add(nn.SpatialAveragePooling(3, 3, 1, 1))
+net_16:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
+net_16:add(nn.ReLU(true))
+
 local concat_72 = nn.Concat(2)
+concat_72:add(net_16)
 concat_72:add(net_15)
 concat_72:add(net_14)
 concat_72:add(net_13)
-concat_72:add(net_12)
 
 net:add(concat_72)
 
-local net_16 = nn.Sequential()
-net_16:add(nn.SpatialConvolution(576, 192, 1, 1, 1, 1))
-net_16:add(nn.ReLU(true))
-
 local net_17 = nn.Sequential()
-net_17:add(nn.SpatialConvolution(576, 96, 1, 1, 1, 1))
-net_17:add(nn.ReLU(true))
-net_17:add(nn.SpatialConvolution(96, 128, 3, 3, 1, 1, 1, 1))
+net_17:add(nn.SpatialConvolution(576, 192, 1, 1, 1, 1))
 net_17:add(nn.ReLU(true))
 
 local net_18 = nn.Sequential()
@@ -148,31 +142,31 @@ net_18:add(nn.SpatialConvolution(576, 96, 1, 1, 1, 1))
 net_18:add(nn.ReLU(true))
 net_18:add(nn.SpatialConvolution(96, 128, 3, 3, 1, 1, 1, 1))
 net_18:add(nn.ReLU(true))
-net_18:add(nn.SpatialConvolution(128, 128, 3, 3, 1, 1, 1, 1))
-net_18:add(nn.ReLU(true))
 
 local net_19 = nn.Sequential()
-net_19:add(nn.SpatialZeroPadding(1, 1, 1, 1))
-net_19:add(nn.SpatialAveragePooling(3, 3, 1, 1))
-net_19:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
+net_19:add(nn.SpatialConvolution(576, 96, 1, 1, 1, 1))
+net_19:add(nn.ReLU(true))
+net_19:add(nn.SpatialConvolution(96, 128, 3, 3, 1, 1, 1, 1))
+net_19:add(nn.ReLU(true))
+net_19:add(nn.SpatialConvolution(128, 128, 3, 3, 1, 1, 1, 1))
 net_19:add(nn.ReLU(true))
 
+local net_20 = nn.Sequential()
+net_20:add(nn.SpatialZeroPadding(1, 1, 1, 1))
+net_20:add(nn.SpatialAveragePooling(3, 3, 1, 1))
+net_20:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
+net_20:add(nn.ReLU(true))
+
 local concat_89 = nn.Concat(2)
+concat_89:add(net_20)
 concat_89:add(net_19)
 concat_89:add(net_18)
 concat_89:add(net_17)
-concat_89:add(net_16)
 
 net:add(concat_89)
 
-local net_20 = nn.Sequential()
-net_20:add(nn.SpatialConvolution(576, 160, 1, 1, 1, 1))
-net_20:add(nn.ReLU(true))
-
 local net_21 = nn.Sequential()
-net_21:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
-net_21:add(nn.ReLU(true))
-net_21:add(nn.SpatialConvolution(128, 160, 3, 3, 1, 1, 1, 1))
+net_21:add(nn.SpatialConvolution(576, 160, 1, 1, 1, 1))
 net_21:add(nn.ReLU(true))
 
 local net_22 = nn.Sequential()
@@ -180,162 +174,168 @@ net_22:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
 net_22:add(nn.ReLU(true))
 net_22:add(nn.SpatialConvolution(128, 160, 3, 3, 1, 1, 1, 1))
 net_22:add(nn.ReLU(true))
-net_22:add(nn.SpatialConvolution(160, 160, 3, 3, 1, 1, 1, 1))
-net_22:add(nn.ReLU(true))
 
 local net_23 = nn.Sequential()
-net_23:add(nn.SpatialZeroPadding(1, 1, 1, 1))
-net_23:add(nn.SpatialAveragePooling(3, 3, 1, 1))
-net_23:add(nn.SpatialConvolution(576, 96, 1, 1, 1, 1))
+net_23:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
+net_23:add(nn.ReLU(true))
+net_23:add(nn.SpatialConvolution(128, 160, 3, 3, 1, 1, 1, 1))
+net_23:add(nn.ReLU(true))
+net_23:add(nn.SpatialConvolution(160, 160, 3, 3, 1, 1, 1, 1))
 net_23:add(nn.ReLU(true))
 
-local concat_106 = nn.Concat(2)
-concat_106:add(net_23)
-concat_106:add(net_22)
-concat_106:add(net_21)
-concat_106:add(net_20)
-
-net:add(concat_106)
-
 local net_24 = nn.Sequential()
+net_24:add(nn.SpatialZeroPadding(1, 1, 1, 1))
+net_24:add(nn.SpatialAveragePooling(3, 3, 1, 1))
 net_24:add(nn.SpatialConvolution(576, 96, 1, 1, 1, 1))
 net_24:add(nn.ReLU(true))
 
+local concat_106 = nn.Concat(2)
+concat_106:add(net_24)
+concat_106:add(net_23)
+concat_106:add(net_22)
+concat_106:add(net_21)
+
+net:add(concat_106)
+
 local net_25 = nn.Sequential()
-net_25:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
-net_25:add(nn.ReLU(true))
-net_25:add(nn.SpatialConvolution(128, 192, 3, 3, 1, 1, 1, 1))
+net_25:add(nn.SpatialConvolution(576, 96, 1, 1, 1, 1))
 net_25:add(nn.ReLU(true))
 
 local net_26 = nn.Sequential()
-net_26:add(nn.SpatialConvolution(576, 160, 1, 1, 1, 1))
+net_26:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
 net_26:add(nn.ReLU(true))
-net_26:add(nn.SpatialConvolution(160, 192, 3, 3, 1, 1, 1, 1))
-net_26:add(nn.ReLU(true))
-net_26:add(nn.SpatialConvolution(192, 192, 3, 3, 1, 1, 1, 1))
+net_26:add(nn.SpatialConvolution(128, 192, 3, 3, 1, 1, 1, 1))
 net_26:add(nn.ReLU(true))
 
 local net_27 = nn.Sequential()
-net_27:add(nn.SpatialZeroPadding(1, 1, 1, 1))
-net_27:add(nn.SpatialAveragePooling(3, 3, 1, 1))
-net_27:add(nn.SpatialConvolution(576, 96, 1, 1, 1, 1))
+net_27:add(nn.SpatialConvolution(576, 160, 1, 1, 1, 1))
+net_27:add(nn.ReLU(true))
+net_27:add(nn.SpatialConvolution(160, 192, 3, 3, 1, 1, 1, 1))
+net_27:add(nn.ReLU(true))
+net_27:add(nn.SpatialConvolution(192, 192, 3, 3, 1, 1, 1, 1))
 net_27:add(nn.ReLU(true))
 
+local net_28 = nn.Sequential()
+net_28:add(nn.SpatialZeroPadding(1, 1, 1, 1))
+net_28:add(nn.SpatialAveragePooling(3, 3, 1, 1))
+net_28:add(nn.SpatialConvolution(576, 96, 1, 1, 1, 1))
+net_28:add(nn.ReLU(true))
+
 local concat_123 = nn.Concat(2)
+concat_123:add(net_28)
 concat_123:add(net_27)
 concat_123:add(net_26)
 concat_123:add(net_25)
-concat_123:add(net_24)
 
 net:add(concat_123)
 
-local net_28 = nn.Sequential()
-net_28:add(nn.SpatialConvolution(576, 192, 1, 1, 1, 1))
-net_28:add(nn.ReLU(true))
-net_28:add(nn.SpatialConvolution(192, 256, 3, 3, 1, 1, 1, 1))
-net_28:add(nn.ReLU(true))
-net_28:add(nn.SpatialConvolution(256, 256, 3, 3, 1, 1, 1, 1))
-net_28:add(nn.ReLU(true))
-
 local net_29 = nn.Sequential()
-net_29:add(nn.SpatialZeroPadding(1, 1, 1, 1))
-net_29:add(nn.SpatialMaxPooling(3, 3, 1, 1))
+net_29:add(nn.SpatialConvolution(576, 192, 1, 1, 1, 1))
+net_29:add(nn.ReLU(true))
+net_29:add(nn.SpatialConvolution(192, 256, 3, 3, 1, 1, 1, 1))
+net_29:add(nn.ReLU(true))
+net_29:add(nn.SpatialConvolution(256, 256, 3, 3, 1, 1, 1, 1))
+net_29:add(nn.ReLU(true))
 
 local net_30 = nn.Sequential()
-net_30:add(nn.SpatialAveragePooling(5, 5, 3, 3))
-net_30:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
-net_30:add(nn.View())
-net_30:add(nn.Linear(2048, 768))
-net_30:add(nn.ReLU())
-net_30:add(nn.Linear(768, 4))
-net_30:add(nn.LogSoftMax())
+net_30:add(nn.SpatialZeroPadding(1, 1, 1, 1))
+net_30:add(nn.SpatialMaxPooling(3, 3, 1, 1))
 
 local net_31 = nn.Sequential()
+net_31:add(nn.SpatialAveragePooling(5, 5, 3, 3))
 net_31:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
-net_31:add(nn.ReLU(true))
-net_31:add(nn.SpatialConvolution(128, 192, 3, 3, 1, 1, 1, 1))
-net_31:add(nn.ReLU(true))
+net_31:add(nn.View())
+net_31:add(nn.Linear(2048, 768))
+net_31:add(nn.ReLU())
+net_31:add(nn.Linear(768, 4))
+net_31:add(nn.LogSoftMax())
+
+local net_32 = nn.Sequential()
+net_32:add(nn.SpatialConvolution(576, 128, 1, 1, 1, 1))
+net_32:add(nn.ReLU(true))
+net_32:add(nn.SpatialConvolution(128, 192, 3, 3, 1, 1, 1, 1))
+net_32:add(nn.ReLU(true))
 
 local concat_143 = nn.Concat(2)
-concat_143:add(net_31)
+concat_143:add(net_32)
+concat_143:add(net_30)
 concat_143:add(net_29)
-concat_143:add(net_28)
 
 net:add(concat_143)
-local net_32 = nn.Sequential()
-net_32:add(nn.SpatialConvolution(1024, 1024, 2, 2, 2, 2))
-
 local net_33 = nn.Sequential()
-net_33:add(nn.SpatialConvolution(1024, 352, 1, 1, 1, 1))
-net_33:add(nn.ReLU(true))
+net_33:add(nn.SpatialConvolution(1024, 1024, 2, 2, 2, 2))
 
 local net_34 = nn.Sequential()
-net_34:add(nn.SpatialConvolution(1024, 192, 1, 1, 1, 1))
-net_34:add(nn.ReLU(true))
-net_34:add(nn.SpatialConvolution(192, 320, 3, 3, 1, 1, 1, 1))
+net_34:add(nn.SpatialConvolution(1024, 352, 1, 1, 1, 1))
 net_34:add(nn.ReLU(true))
 
 local net_35 = nn.Sequential()
-net_35:add(nn.SpatialConvolution(1024, 160, 1, 1, 1, 1))
+net_35:add(nn.SpatialConvolution(1024, 192, 1, 1, 1, 1))
 net_35:add(nn.ReLU(true))
-net_35:add(nn.SpatialConvolution(160, 224, 3, 3, 1, 1, 1, 1))
-net_35:add(nn.ReLU(true))
-net_35:add(nn.SpatialConvolution(224, 224, 3, 3, 1, 1, 1, 1))
+net_35:add(nn.SpatialConvolution(192, 320, 3, 3, 1, 1, 1, 1))
 net_35:add(nn.ReLU(true))
 
 local net_36 = nn.Sequential()
-net_36:add(nn.SpatialZeroPadding(1, 1, 1, 1))
-net_36:add(nn.SpatialAveragePooling(3, 3, 1, 1))
-net_36:add(nn.SpatialConvolution(1024, 128, 1, 1, 1, 1))
+net_36:add(nn.SpatialConvolution(1024, 160, 1, 1, 1, 1))
+net_36:add(nn.ReLU(true))
+net_36:add(nn.SpatialConvolution(160, 224, 3, 3, 1, 1, 1, 1))
+net_36:add(nn.ReLU(true))
+net_36:add(nn.SpatialConvolution(224, 224, 3, 3, 1, 1, 1, 1))
 net_36:add(nn.ReLU(true))
 
+local net_37 = nn.Sequential()
+net_37:add(nn.SpatialZeroPadding(1, 1, 1, 1))
+net_37:add(nn.SpatialAveragePooling(3, 3, 1, 1))
+net_37:add(nn.SpatialConvolution(1024, 128, 1, 1, 1, 1))
+net_37:add(nn.ReLU(true))
+
 local concat_161 = nn.Concat(2)
+concat_161:add(net_37)
 concat_161:add(net_36)
 concat_161:add(net_35)
 concat_161:add(net_34)
-concat_161:add(net_33)
 
-net_32:add(concat_161)
-
-local net_37 = nn.Sequential()
-net_37:add(nn.SpatialConvolution(1024, 352, 1, 1, 1, 1))
-net_37:add(nn.ReLU(true))
+net_33:add(concat_161)
 
 local net_38 = nn.Sequential()
-net_38:add(nn.SpatialConvolution(1024, 192, 1, 1, 1, 1))
-net_38:add(nn.ReLU(true))
-net_38:add(nn.SpatialConvolution(192, 320, 3, 3, 1, 1, 1, 1))
+net_38:add(nn.SpatialConvolution(1024, 352, 1, 1, 1, 1))
 net_38:add(nn.ReLU(true))
 
 local net_39 = nn.Sequential()
 net_39:add(nn.SpatialConvolution(1024, 192, 1, 1, 1, 1))
 net_39:add(nn.ReLU(true))
-net_39:add(nn.SpatialConvolution(192, 224, 3, 3, 1, 1, 1, 1))
-net_39:add(nn.ReLU(true))
-net_39:add(nn.SpatialConvolution(224, 224, 3, 3, 1, 1, 1, 1))
+net_39:add(nn.SpatialConvolution(192, 320, 3, 3, 1, 1, 1, 1))
 net_39:add(nn.ReLU(true))
 
 local net_40 = nn.Sequential()
-net_40:add(nn.SpatialZeroPadding(1, 1, 1, 1))
-net_40:add(nn.SpatialMaxPooling(3, 3, 1, 1))
-net_40:add(nn.SpatialConvolution(1024, 128, 1, 1, 1, 1))
+net_40:add(nn.SpatialConvolution(1024, 192, 1, 1, 1, 1))
+net_40:add(nn.ReLU(true))
+net_40:add(nn.SpatialConvolution(192, 224, 3, 3, 1, 1, 1, 1))
+net_40:add(nn.ReLU(true))
+net_40:add(nn.SpatialConvolution(224, 224, 3, 3, 1, 1, 1, 1))
 net_40:add(nn.ReLU(true))
 
+local net_41 = nn.Sequential()
+net_41:add(nn.SpatialZeroPadding(1, 1, 1, 1))
+net_41:add(nn.SpatialMaxPooling(3, 3, 1, 1))
+net_41:add(nn.SpatialConvolution(1024, 128, 1, 1, 1, 1))
+net_41:add(nn.ReLU(true))
+
 local concat_178 = nn.Concat(2)
+concat_178:add(net_41)
 concat_178:add(net_40)
 concat_178:add(net_39)
 concat_178:add(net_38)
-concat_178:add(net_37)
 
-net_32:add(concat_178)
-net_32:add(nn.SpatialAveragePooling(7, 7, 1, 1))
-net_32:add(nn.View())
-net_32:add(nn.Linear(1024, 4))
-net_32:add(nn.LogSoftMax())
+net_33:add(concat_178)
+net_33:add(nn.SpatialAveragePooling(7, 7, 1, 1))
+net_33:add(nn.View())
+net_33:add(nn.Linear(1024, 4))
+net_33:add(nn.LogSoftMax())
 
 local concat_183 = nn.Concat(2)
-concat_183:add(net_32)
-concat_183:add(net_30)
+concat_183:add(net_33)
+concat_183:add(net_31)
 
 net:add(concat_183)
 

test/test-cases/generated-code/requiredOmitted.lua

@@ -0,0 +1,7 @@
+require 'nn'
+require 'rnn'
+
+local net = nn.Sequential()
+net:add(nn.Add(nil, true))
+
+return net

webgme-setup.json

@@ -44,6 +44,14 @@
       "ExecuteJob": {
         "src": "src/plugins/ExecuteJob",
         "test": "test/plugins/ExecuteJob"
+      },
+      "CheckLibraries": {
+        "src": "src/plugins/CheckLibraries",
+        "test": "test/plugins/CheckLibraries"
+      },
+      "UpdateLibrarySeed": {
+        "src": "src/plugins/UpdateLibrarySeed",
+        "test": "test/plugins/UpdateLibrarySeed"
       }
     },
     "layouts": {},
@@ -273,6 +281,12 @@
       "xor": {
         "src": "src/seeds/xor"
       }
+    },
+    "routers": {
+      "JobLogsAPI": {
+        "src": "src/routers/JobLogsAPI",
+        "mount": "execution/logs"
+      }
     }
   },
   "dependencies": {
@@ -329,6 +343,7 @@
         "path": "node_modules/webgme-easydag/src/decorators/EllipseDecorator"
       }
     },
-    "seeds": {}
+    "seeds": {},
+    "routers": {}
   }
 }