fast dependency solution

Author: siloenix

command/NetworkCommand.js

@@ -0,0 +1,13 @@
+const log = require('../logger');
+const Command = require('../command');
+
+module.exports = class NetworkCommand extends Command {
+  constructor(name, options) {
+    super(name, options)
+  }
+
+  _runInternal() {
+    return new Promise(resolve => setTimeout(resolve, 1000))
+      .then(() => log.info(`network created: '${this.name}'`));
+  }
+};

command/ServiceCommand.js

@@ -0,0 +1,13 @@
+const log = require('../logger');
+const Command = require('../command');
+
+module.exports = class ServiceCommand extends Command {
+  constructor(name, options) {
+    super(name, options)
+  }
+
+  _runInternal() {
+    return new Promise(resolve => setTimeout(resolve, 1000))
+      .then(() => log.info(`service created: '${this.name}'`));
+  }
+};

command/VolumeCommand.js

@@ -0,0 +1,13 @@
+const log = require('../logger');
+const Command = require('../command');
+
+module.exports = class VolumeCommand extends Command {
+  constructor(name, options) {
+    super(name, options)
+  }
+
+  _runInternal() {
+    return new Promise(resolve => setTimeout(resolve, 1000))
+      .then(() => log.info(`volume created: '${this.name}'`));
+  }
+};

command/index.js

@@ -0,0 +1,29 @@
+const log = require('../logger');
+
+module.exports = class Command {
+  constructor(name, options) {
+    this.name = name;
+    this.options = options;
+    this.dependencies = [];
+  }
+
+  addDependency(dependency) {
+    if (dependency instanceof Command) {
+      this.dependencies.push(dependency);
+      log.info(`${this.name} -> ${dependency.name}`)
+    }
+  }
+
+  run() {
+    if (!this.executable) {
+      this.executable = Promise.all(this.dependencies.map(command => command.run()))
+        .then(() => this._runInternal())
+    }
+    return this.executable;
+  }
+
+  _runInternal() {
+    log.warn('Command run on base class');
+    return Promise.resolve(); // todo : maybe reject
+  }
+};

middleware/errorHandler.js

@@ -3,6 +3,6 @@ const log = require('../logger');
 module.exports = function (err, req, res, next) {
   res.status(err.status || 500);
   const message = err.message || err.constructor.name;
-  log.error(message);
+  log.error(err.status ? message : err.stack);
   res.json({message: message});
 };

package.json

@@ -15,6 +15,7 @@
     "http-errors": "~1.6.2",
     "morgan": "~1.9.0",
     "nconf": "^0.10.0",
+    "parser-yaml": "^0.1.1",
     "winston": "^3.1.0",
     "yaml": "^1.0.0"
   },

services/DockerService.js

@@ -1,29 +1,68 @@
 const log = require('../logger');
-const yaml = require('yaml');
+const yaml = require('parser-yaml');
+const ServiceCommand = require('../command/ServiceCommand');
+const NetworkCommand = require('../command/NetworkCommand');
+const VolumeCommand = require('../command/VolumeCommand');
 
 module.exports = class DockerService {
   static applyYaml(fileContent) {
-    const directives = yaml.parse(fileContent);
+    const directives = yaml.parseSync(fileContent);
     return this.applyDirectives(directives);
   }
 
-  static async applyDirectives(directives) {
-    const all = {
-      ...directives.services,
-      ...directives.volumes,
-      ...directives.networks
-    };
+  static async applyDirectives({services, volumes, networks}) {
+    const commands = {};
 
-    for (const name in directives.services) {
+    for (const name in services) {
       log.info(`service: ${name}`);
     }
-    for (const name in directives.volumes) {
+    for (const name in volumes) {
       log.info(`volume: ${name}`);
     }
-    for (const name in directives.networks) {
+    for (const name in networks) {
       log.info(`network: ${name}`);
     }
 
+    for (const name in services) {
+      const directive = services[name];
+      const command = getCommand(name, services, commands, ServiceCommand);
+
+      const dependencies = directive.depends_on;
+      const depNetworks = directive.networks;
+      const depVolumes = directive.volumes;
+
+      if (dependencies) {
+        for (const dependency of dependencies) {
+          command.addDependency(getCommand(dependency, services, commands, ServiceCommand))
+        }
+      }
+
+      if (depNetworks) {
+        for (const network of depNetworks) {
+          command.addDependency(getCommand(network, networks, commands, NetworkCommand))
+        }
+      }
+
+      if (depVolumes) {
+        for (const name of depVolumes) {
+          const volume = name.split(':')[0];
+          if (volumes.hasOwnProperty(volume)) {
+            command.addDependency(getCommand(volume, volumes, commands, VolumeCommand))
+          }
+        }
+      }
+    }
+
+    await Promise.all(Object.values(commands).map(c => c.run()));
     return {ok: true}
   }
 };
+
+function getCommand(name, directives, commands, CommandType) {
+  let command = commands[name];
+  if (!command) {
+    command = new CommandType(name, directives[name] || {});
+    commands[name] = command;
+  }
+  return command;
+}