WIP Added istanbul

* Cancel job if the exec has been canceled. Fixes #820

* WIP #820 Added test for stopping watching on cancel

* WIP #820 Increased the timeout for import torch

.gitignore

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

README.md

@@ -7,7 +7,13 @@
 **Notice**: DeepForge is still a work in progress and is also lacking significant documentation! That being said, any contributions and/or feedback is greatly appreciated (and feel free to always ask any questions on the gitter)!
 
 # DeepForge
-DeepForge is an open-source visual development environment for deep learning. Currently, it supports Convolutional Neural Networks but we are planning on supporting additional deep learning classifiers such as RNNs and LSTMs. Additional features include real-time collaborative editing and version control.
+DeepForge is an open-source visual development environment for deep learning. Currently, it supports Convolutional Neural Networks, RNNs and LSTMs as well as the creation of custom layers. Additional features include:
+- Graphical architecture editor
+- Training/testing pipeline creation
+- Distributed pipeline execution
+- Real-time pipeline feedback
+- Collaborative editing
+- Automatic version control.
 
 ## Quick Start
 Simply run the following command to install deepforge with its dependencies:

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,35 @@
 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.seedProjects.basePaths.push(__dirname + '/../src/seeds/devProject');
 
 
 
-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,17 @@
     "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",
+    "test-cover": "node node_modules/istanbul/lib/cli.js --hook-run-in-context cover node_modules/mocha/bin/_mocha -- -R spec 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",
@@ -34,6 +36,7 @@
     "chai": "^3.0.0",
     "jszip": "^2.5.0",
     "mocha": "^2.2.5",
+    "istanbul": "^0.4.5",
     "mockery": "^1.7.0"
   }
 }

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,11 @@ define([
         this.pluginMetadata = pluginMetadata;
 
         this._currentSave = Q();
+        this.changes = {};
+        this.currentChanges = {};  // read-only changes being applied
+        this.creations = {};
+        this.deletions = [];
+        this.createIdToMetadataId = {};
         this.initRun();
     };
 
@@ -94,17 +101,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 +118,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 +134,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 +153,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 +172,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());
     };
 
@@ -176,6 +189,10 @@ define([
         });
     };
 
+    ExecutePipeline.prototype.isExecutionCanceled = function () {
+        return this.getAttribute(this.activeNode, 'status') === 'canceled';
+    };
+
     ExecutePipeline.prototype.isInputData = function (node) {
         var prnt = this.core.getParent(node);
         return this.core.isTypeOf(prnt, this.META.Inputs);
@@ -195,14 +212,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 +311,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 +358,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 +440,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 +450,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 +469,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.debug(`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 from ${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/ExecuteJob/ExecuteJob.spec.js

@@ -10,12 +10,14 @@ describe('ExecuteJob', function () {
         PluginCliManager = testFixture.WebGME.PluginCliManager,
         projectName = 'testProject',
         pluginName = 'ExecuteJob',
+        manager = new PluginCliManager(null, logger, gmeConfig),
         project,
         gmeAuth,
         storage,
         commitHash;
 
     before(function (done) {
+        this.timeout(10000);
         testFixture.clearDBAndGetGMEAuth(gmeConfig, projectName)
             .then(function (gmeAuth_) {
                 gmeAuth = gmeAuth_;
@@ -25,7 +27,7 @@ describe('ExecuteJob', function () {
             })
             .then(function () {
                 var importParam = {
-                    projectSeed: testFixture.path.join(testFixture.SEED_DIR, 'EmptyProject.webgmex'),
+                    projectSeed: testFixture.path.join(testFixture.DF_SEED_DIR, 'devProject', 'devProject.webgmex'),
                     projectName: projectName,
                     branchName: 'master',
                     logger: logger,
@@ -51,9 +53,7 @@ describe('ExecuteJob', function () {
     });
 
     it('should verify activeNode is "Job"', function (done) {
-        var manager = new PluginCliManager(null, logger, gmeConfig),
-            pluginConfig = {
-            },
+        var pluginConfig = {},
             context = {
                 project: project,
                 commitHash: commitHash,
@@ -68,4 +68,285 @@ describe('ExecuteJob', function () {
             done();
         });
     });
+
+    ////////// Helper Functions //////////
+    var plugin,
+        node,
+        preparePlugin = function(done) {
+            var context = {
+                project: project,
+                commitHash: commitHash,
+                branchName: 'test',
+                activeNode: '/K/R/p'  // hello world job
+            };
+
+            return manager.initializePlugin(pluginName)
+                .then(plugin_ => {
+                    plugin = plugin_;
+                    return manager.configurePlugin(plugin, {}, context);
+                })
+                .then(() => node = plugin.activeNode)
+                .nodeify(done);
+        };
+
+    ////////// END Helper Functions //////////
+
+    // Race condition checks w/ saving...
+    describe('get/set', function() {
+        beforeEach(preparePlugin);
+
+        it('should get correct attribute after set', function() {
+            plugin.setAttribute(node, 'status', 'queued');
+            var attrValue = plugin.getAttribute(node, 'status');
+            expect(attrValue).to.equal('queued');
+        });
+
+        it('should get correct attribute before updating nodes', function(done) {
+            // Run setAttribute on some node
+            plugin.setAttribute(node, 'status', 'queued');
+
+            // Check that the value is correct before applying node changes
+            var updateNodes = plugin.updateNodes;
+            plugin.updateNodes = function() {
+                var attrValue = plugin.getAttribute(node, 'status');
+                expect(attrValue).to.equal('queued');
+                return updateNodes.apply(this, arguments);
+            };
+            plugin.save().nodeify(done);
+        });
+
+        it('should get correct attribute (from new node) before updating nodes', function(done) {
+            // Run setAttribute on some node
+            var graphTmp = plugin.createNode('pipeline.Graph', node),
+                newVal = 'testGraph',
+                id = 'testId';
+
+            // Get the 
+            plugin.setAttribute(graphTmp, 'name', newVal);
+            plugin._metadata[id] = graphTmp;
+            plugin.createIdToMetadataId[graphTmp] = id;
+
+            // Check that the value is correct before applying node changes
+            var updateNodes = plugin.updateNodes;
+            plugin.updateNodes = function() {
+                var graph = plugin._metadata[id],
+                    attrValue = plugin.getAttribute(graph, 'name');
+
+                expect(attrValue).to.equal(newVal);
+                return updateNodes.apply(this, arguments);
+            };
+            plugin.save().nodeify(done);
+        });
+
+        it('should get correct attribute after save', function(done) {
+            // Run setAttribute on some node
+            plugin.setAttribute(node, 'status', 'queued');
+
+            // Check that the value is correct before applying node changes
+            plugin.save()
+                .then(() => {
+                    var attrValue = plugin.getAttribute(node, 'status');
+                    expect(attrValue).to.equal('queued');
+                })
+                .nodeify(done);
+        });
+
+        it('should get correct attribute while applying node changes', function(done) {
+            // Run setAttribute on some node
+            plugin.setAttribute(node, 'status', 'queued');
+
+            // Check that the value is correct before applying node changes
+            var oldApplyChanges = plugin._applyNodeChanges;
+            plugin._applyNodeChanges = function() {
+                var attrValue = plugin.getAttribute(node, 'status');
+                expect(attrValue).to.equal('queued');
+                return oldApplyChanges.apply(this, arguments);
+            };
+            plugin.save().nodeify(done);
+        });
+    });
+
+    describe('createNode', function() {
+        beforeEach(preparePlugin);
+
+        it('should update _metadata after applying changes', function(done) {
+            // Run setAttribute on some node
+            var graphTmp = plugin.createNode('pipeline.Graph', node),
+                id = 'testId';
+
+            plugin._metadata[id] = graphTmp;
+            plugin.createIdToMetadataId[graphTmp] = id;
+
+            // Check that the value is correct before applying node changes
+            var applyModelChanges = plugin.applyModelChanges;
+            plugin.applyModelChanges = function() {
+                return applyModelChanges.apply(this, arguments)
+                    .then(() => {
+                        var graph = plugin._metadata[id];
+                        expect(graph).to.not.equal(graphTmp);
+                    });
+            };
+            plugin.save().nodeify(done);
+        });
+
+        it('should update _metadata in updateNodes', function(done) {
+            var id = 'testId';
+
+            plugin._metadata[id] = node;
+            node.old = true;
+            plugin.updateNodes()
+                    .then(() => {
+                        var graph = plugin._metadata[id];
+                        expect(graph.old).to.not.equal(true);
+                    })
+                    .nodeify(done);
+        });
+
+        // Check that it gets the correct value from a newly created node after
+        // it has been saved/created
+        it('should get changed attribute', function(done) {
+            // Run setAttribute on some node
+            var graphTmp = plugin.createNode('pipeline.Graph', node),
+                id = 'testId';
+
+            plugin._metadata[id] = node;
+            plugin.createIdToMetadataId[graphTmp] = id;
+
+            plugin.setAttribute(graphTmp, 'name', 'firstName');
+
+            // Check that the value is correct before applying node changes
+            plugin.save()
+                .then(() => {
+                    var graph = plugin._metadata[id],
+                        val = plugin.getAttribute(graph, 'name');
+                    expect(val).to.equal('firstName');
+                })
+                .nodeify(done);
+        });
+
+        it('should get inherited attribute', function(done) {
+            // Run setAttribute on some node
+            var graphTmp = plugin.createNode('pipeline.Graph', node),
+                id = 'testId',
+                val;
+
+            // Check that the value is correct before applying node changes
+            plugin._metadata[id] = node;
+            plugin.createIdToMetadataId[graphTmp] = id;
+
+            val = plugin.getAttribute(graphTmp, 'name');
+            expect(val).to.equal('Graph');
+
+            plugin.save()
+                .then(() => {
+                    var graph = plugin._metadata[id];
+
+                    val = plugin.getAttribute(graph, 'name');
+
+                    expect(val).to.equal('Graph');
+                })
+                .nodeify(done);
+        });
+    });
+
+    // Canceling
+    describe('cancel', function() {
+        beforeEach(preparePlugin);
+
+        it('should stop the job if the execution is canceled', function(done) {
+            var job = node,
+                hash = 'abc123',
+                exec = {
+                    cancelJob: jobHash => expect(jobHash).equal(hash)
+                };
+
+            plugin.setAttribute(node, 'secret', 'abc');
+            plugin.isExecutionCanceled = () => true;
+            plugin.onOperationCanceled = () => done();
+            plugin.watchOperation(exec, hash, job, job);
+        });
+
+        it('should stop the job if a job is canceled', function(done) {
+            var job = node,
+                hash = 'abc123',
+                exec = {
+                    cancelJob: jobHash => expect(jobHash).equal(hash)
+                };
+
+            plugin.setAttribute(job, 'secret', 'abc');
+            plugin.canceled = true;
+            plugin.onOperationCanceled = () => done();
+            plugin.watchOperation(exec, hash, job, job);
+        });
+
+        it('should set exec to running', function(done) {
+            var job = node,
+                execNode = plugin.core.getParent(job);
+
+            // Set the execution to canceled
+            plugin.setAttribute(execNode, 'status', 'canceled');
+            plugin.prepare = () => {
+                var status = plugin.getAttribute(execNode, 'status');
+                expect(status).to.not.equal('canceled');
+                return {then: () => done()};
+            };
+            plugin.main();
+        });
+    });
+
+    describe('exec files', function() {
+        describe('attribute file', function() {
+            var boolString = /['"](true|false)['"]/g;
+
+            beforeEach(preparePlugin);
+
+            it('should not quote true (s) boolean values', function() {
+                var files = {},
+                    content,
+                    matches;
+
+                plugin.setAttribute(node, 'debug', 'true');
+                plugin.createAttributeFile(node, files);
+                content = files['attributes.lua'];
+                matches = content.match(boolString);
+                expect(matches).to.equal(null);
+            });
+
+            it('should not quote true boolean values', function() {
+                var files = {},
+                    content,
+                    matches;
+
+                plugin.setAttribute(node, 'debug', true);
+                plugin.createAttributeFile(node, files);
+                content = files['attributes.lua'];
+                matches = content.match(boolString);
+                expect(matches).to.equal(null);
+            });
+
+            it('should not quote false (s) boolean values', function() {
+                var files = {},
+                    content,
+                    matches;
+
+                plugin.setAttribute(node, 'debug', 'false');
+                plugin.createAttributeFile(node, files);
+                content = files['attributes.lua'];
+                matches = content.match(boolString);
+                expect(matches).to.equal(null);
+            });
+
+            it('should not quote false boolean values', function() {
+                var files = {},
+                    content,
+                    matches;
+
+                plugin.setAttribute(node, 'debug', false);
+                plugin.createAttributeFile(node, files);
+                content = files['attributes.lua'];
+                matches = content.match(boolString);
+                expect(matches).to.equal(null);
+            });
+        });
+    });
 });

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/ImportTorch/ImportTorch.spec.js

@@ -14,7 +14,7 @@ var testFixture = require('../../globals'),
     ];
 
 describe('ImportTorch', function () {
-    this.timeout(5000);
+    this.timeout(7500);
     var gmeConfig = testFixture.getGmeConfig(),
         Q = testFixture.Q,
         GraphChecker = testFixture.requirejs('deepforge/GraphChecker'),

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": {},
@@ -272,6 +280,15 @@
       },
       "xor": {
         "src": "src/seeds/xor"
+      },
+      "devProject": {
+        "src": "src/seeds/devProject"
+      }
+    },
+    "routers": {
+      "JobLogsAPI": {
+        "src": "src/routers/JobLogsAPI",
+        "mount": "execution/logs"
       }
     }
   },
@@ -329,6 +346,7 @@
         "path": "node_modules/webgme-easydag/src/decorators/EllipseDecorator"
       }
     },
-    "seeds": {}
+    "seeds": {},
+    "routers": {}
   }
 }