small conflicts

lib/core/logger.js

@@ -18,7 +18,7 @@ Logger.prototype.registerAPICall = function (plugins) {
   plugin.registerAPICall(
     'ws',
     '/embark-api/logs',
-    (ws, req) => {
+    (ws, _req) => {
       self.events.on("log", function(logLevel, logMsg) {
         ws.send(JSON.stringify({msg: logMsg, msg_clear: logMsg.stripColors, logLevel: logLevel}), () => {});
       });
@@ -26,7 +26,7 @@ Logger.prototype.registerAPICall = function (plugins) {
   );
 };
 
-Logger.prototype.writeToFile = function (txt) {
+Logger.prototype.writeToFile = function (_txt) {
   if (!this.logfile) {
     return;
   }

lib/core/plugin.js

@@ -24,6 +24,7 @@ var Plugin = function(options) {
   this.pluginTypes = [];
   this.uploadCmds = [];
   this.apiCalls = [];
+  this.processes = [];
   this.imports = [];
   this.embarkjs_code = [];
   this.embarkjs_init_code = {};
@@ -213,7 +214,12 @@ Plugin.prototype.registerActionForEvent = function(eventName, cb) {
 Plugin.prototype.registerAPICall = function(method, endpoint, cb) {
   console.dir("registerAPICall " + method + " " + endpoint);
   this.apiCalls.push({method: method, endpoint: endpoint, cb: cb});
-  this.pluginTypes.push('apiCalls');
+  this.addPluginType('apiCalls');
+};
+
+Plugin.prototype.registerProcess = function(processName) {
+  this.processes.push({processName});
+  this.addPluginType('processes');
 };
 
 Plugin.prototype.runFilePipeline = function() {

lib/core/processes/processLauncher.js

@@ -14,15 +14,19 @@ class ProcessLauncher {
    * @return {ProcessLauncher}    The ProcessLauncher instance
    */
   constructor(options) {
-    this.name = path.basename(options.modulePath);
+    this.name = options.name || path.basename(options.modulePath);
     this.process = child_process.fork(options.modulePath);
     this.logger = options.logger;
     this.events = options.events;
     this.silent = options.silent;
     this.exitCallback = options.exitCallback;
+    this.embark = options.embark;
 
     this.subscriptions = {};
     this._subscribeToMessages();
+    if (this.embark) {
+      this._registerAsPlugin();
+    }
   }
 
   // Subscribes to messages from the child process and delegates to the right methods
@@ -48,8 +52,22 @@ class ProcessLauncher {
     });
   }
 
+  _registerAsPlugin() {
+    const self = this;
+    self.embark.registerAPICall(
+      'ws',
+      '/embark/process-logs/' + self.name,
+      (ws, _req) => {
+        self.events.on('log-' + self.name, function(logLevel, msg) {
+          ws.send(JSON.stringify({msg, msg_clear: msg.stripColors, logLevel}), () => {});
+        });
+      }
+    );
+  }
+
   // Translates logs from the child process to the logger
   _handleLog(msg) {
+    this.events.emit('log-' + this.name, msg.type, msg.message);
     if (this.silent && msg.type !== 'error') {
       return;
     }

lib/core/processes/processManager.js

@@ -1,12 +1,35 @@
 
 class ProcessManager {
   constructor(options) {
-    const self = this;
     this.logger = options.logger;
     this.events = options.events;
     this.plugins = options.plugins;
     this.processes = {};
 
+    this._registerAsPlugin();
+    this._registerEvents();
+  }
+
+  _registerAsPlugin() {
+    const self  =this;
+    self.plugin = this.plugins.createPlugin('processManager', {});
+    self.plugin.registerAPICall(
+      'get',
+      '/embark/processes',
+      (req, res) => {
+        let parsedProcesses = {};
+        Object.keys(self.processes).forEach(processName => {
+          parsedProcesses[processName] = {
+            state: self.processes[processName]
+          };
+        });
+        res.send(parsedProcesses);
+      }
+    );
+  }
+
+  _registerEvents() {
+    const self = this;
     self.events.setCommandHandler('processes:register', (name, cb) => {
       this.processes[name] = {
         state: 'unstarted',
@@ -16,7 +39,7 @@ class ProcessManager {
 
     self.events.setCommandHandler('processes:launch', (name, cb) => {
       let process = self.processes[name];
-      if (process.state != 'unstarted') {
+      if (process.state !== 'unstarted') {
         return cb();
       }
       process.state = 'starting';
@@ -28,7 +51,6 @@ class ProcessManager {
       ]);
     });
   }
-
 }
 
 module.exports = ProcessManager;

lib/modules/ipfs/index.js

@@ -19,6 +19,10 @@ class IPFS {
     this.webServerConfig = embark.config.webServerConfig;
     this.blockchainConfig = embark.config.blockchainConfig;
 
+    this.events.request('processes:register', 'ipfs', (cb) => {
+      self.startProcess(cb);
+    });
+
     if (this.isIpfsStorageEnabledInTheConfig() || this.isIpfsNameEnabledInTheConfig()) {
       this.downloadIpfsApi();
       this.addDefaultToEmbarkJS();
@@ -35,7 +39,7 @@ class IPFS {
           return;
         }
         self.logger.info("IPFS node not found, attempting to start own node");
-        self.startProcess(() => {});
+        this.events.request("processes:launch", "ipfs", () => {});
       });
     }
 
@@ -145,7 +149,8 @@ class IPFS {
       events: self.events,
       storageConfig: self.storageConfig,
       webServerConfig: self.webServerConfig,
-      blockchainConfig: self.blockchainConfig
+      blockchainConfig: self.blockchainConfig,
+      embark: self.embark
     });
     self.logger.trace(`Storage module: Launching ipfs process...`);
     return storageProcessesLauncher.launchProcess('ipfs', callback);

lib/modules/storage/storageProcessesLauncher.js

@@ -17,6 +17,7 @@ class StorageProcessesLauncher {
     this.storageConfig = options.storageConfig;
     this.webServerConfig = options.webServerConfig;
     this.blockchainConfig = options.blockchainConfig;
+    this.embark = options.embark;
     this.processes = {};
 
     this.cors = this.buildCors();
@@ -105,8 +106,10 @@ class StorageProcessesLauncher {
       self.logger.info(__(`Starting %s process`, storageName).cyan);
       self.processes[storageName] = new ProcessLauncher({
         modulePath: filePath,
+        name: storageName,
         logger: self.logger,
         events: self.events,
+        embark: self.embark,
         silent: self.logger.logLevel !== 'trace',
         exitCallback: self.processExited.bind(this, storageName)
       });

lib/modules/webserver/server.js

@@ -1,5 +1,3 @@
-let finalhandler = require('finalhandler');
-let http = require('http');
 let serveStatic = require('serve-static');
 const {canonicalHost, defaultHost, dockerHostSwap} = require('../../utils/host');
 require('http-shutdown').extend();
@@ -28,11 +26,11 @@ class Server {
     }
     var app = express();
     app.use(cors());
-		app.use(express.static(path.join(fs.dappPath(this.dist)), {'index': ['index.html', 'index.htm']}));
+    app.use(express.static(path.join(fs.dappPath(this.dist)), {'index': ['index.html', 'index.htm']}));
     app.use('/embark', express.static(path.join(__dirname, '../../../embark-ui/build')));
 
     app.use(bodyParser.json()); // support json encoded bodies
-    app.use(bodyParser.urlencoded({ extended: true })); // support encoded bodies
+    app.use(bodyParser.urlencoded({extended: true})); // support encoded bodies
 
     expressWebSocket(app);