Merge pull request #244 from iurimatias/serviceschecks

Services Monitor refactor

lib/cmds/template_generator.js

@@ -1,5 +1,5 @@
 var fs = require('../core/fs.js');
-var utils = require('../core/utils.js');
+var utils = require('../utils/utils.js');
 
 var TemplateGenerator = function(templateName) {
   this.templateName = templateName;

lib/contracts/compiler.js

@@ -1,18 +1,7 @@
 /*jshint esversion: 6, loopfunc: true */
-var async = require('async');
+var async = require('../utils/async_extend.js');
 var SolcW = require('./solcW.js');
 
-function asyncEachObject(object, iterator, callback) {
-  async.each(
-    Object.keys(object || {}),
-    function(key, next){
-      iterator(key, object[key], next);
-    },
-    callback
-  );
-}
-async.eachObject = asyncEachObject;
-
 var Compiler = function(options) {
   this.plugins = options.plugins;
   this.logger = options.logger;

lib/contracts/deploy_manager.js

@@ -1,5 +1,4 @@
 var async = require('async');
-var Web3 = require('web3');
 
 var Deploy = require('./deploy.js');
 var ContractsManager = require('./contracts.js');
@@ -33,21 +32,25 @@ DeployManager.prototype.deployContracts = function(done) {
     });
     contractsManager.build(callback);
   },
-  function connectWithWeb3(contractsManager, callback) {
-    var web3;
-    if (self.web3) {
-      web3 = self.web3;
-    } else {
-      web3 = new Web3();
-      var web3Endpoint = 'http://' + self.config.blockchainConfig.rpcHost + ':' + self.config.blockchainConfig.rpcPort;
-      web3.setProvider(new web3.providers.HttpProvider(web3Endpoint));
-      if (!web3.isConnected()) {
-        self.logger.error(("Couldn't connect to " + web3Endpoint.underline + " are you sure it's on?").red);
-        self.logger.info("make sure you have an ethereum node or simulator running. e.g 'embark blockchain'".magenta);
-        return callback(Error("error connecting to blockchain node"));
-      }
+  function checkWeb3IsConnected(contractsManager, callback) {
+    if (!self.web3) {
+      return callback(Error("no web3 instance found"));
+    }
+    if (self.web3.currentProvider.isConnected !== undefined && !self.web3.isConnected()) {
+      self.logger.error(("Couldn't connect to an Ethereum node are you sure it's on?").red);
+      self.logger.info("make sure you have an Ethereum node or simulator running. e.g 'embark blockchain'".magenta);
+      return callback(Error("error connecting to blockchain node"));
+    }
+    if (self.web3.currentProvider.isConnected === undefined) {
+      self.web3.version.getNode(function(err, version) {
+        if (err) {
+          return callback(Error("error connecting to blockchain node"));
+        }
+        return callback(null, contractsManager, self.web3);
+      });
+    } else {
+      return callback(null, contractsManager, self.web3);
     }
-    callback(null, contractsManager, web3);
   },
   function setDefaultAccount(contractsManager, web3, callback) {
     web3.eth.getAccounts(function(err, accounts) {

lib/contracts/solcW.js

@@ -1,4 +1,4 @@
-var utils = require('../core/utils.js');
+var utils = require('../utils/utils.js');
 var solcProcess;
 var compilerLoaded = false;
 

lib/core/config.js

@@ -1,6 +1,6 @@
 var fs = require('./fs.js');
 var Plugins = require('./plugins.js');
-var utils = require('./utils.js');
+var utils = require('../utils/utils.js');
 
 // TODO: add wrapper for fs so it can also work in the browser
 // can work with both read and save

lib/core/engine.js

@@ -1,11 +1,14 @@
+var http = require('http');
+var Web3 = require('web3');
+var utils = require('../utils/utils.js');
+
 var Events = require('./events.js');
 var Logger = require('./logger.js');
 var Config = require('./config.js');
 
 var DeployManager = require('../contracts/deploy_manager.js');
 var ABIGenerator = require('../contracts/abi.js');
-var Dashboard = require('../dashboard/dashboard.js');
-var ServicesMonitor = require('./services.js');
+var ServicesMonitor = require('./services_monitor.js');
 var Pipeline = require('../pipeline/pipeline.js');
 var Server = require('../pipeline/server.js');
 var Watch = require('../pipeline/watch.js');
@@ -19,24 +22,35 @@ var Engine = function(options) {
 };
 
 Engine.prototype.init = function(_options) {
+  var self = this;
   var options = _options || {};
   this.events = new Events();
   this.logger = options.logger || new Logger({logLevel: 'debug'});
   this.config = new Config({env: this.env, logger: this.logger, events: this.events});
   this.config.loadConfigFiles({embarkConfig: this.embarkConfig, interceptLogs: this.interceptLogs});
   this.plugins = this.config.plugins;
+
+  this.servicesMonitor = new ServicesMonitor({events: this.events, logger: this.logger});
+  this.servicesMonitor.addCheck('embarkVersion', function(cb) {
+    return cb({name: 'Embark ' + self.version, status: 'green'});
+  }, 0);
+};
+
+Engine.prototype.startMonitor = function() {
+  this.servicesMonitor.startMonitor();
 };
 
 Engine.prototype.startService = function(serviceName, _options) {
   var options = _options || {};
 
   var services = {
-    "monitor":     this.monitorService,
     "pipeline":    this.pipelineService,
     "abi":         this.abiService,
     "deployment":  this.deploymentService,
     "fileWatcher": this.fileWatchService,
-    "webServer":   this.webServerService
+    "webServer":   this.webServerService,
+    "ipfs":        this.ipfsService,
+    "web3":        this.web3Service
   };
 
   var service = services[serviceName];
@@ -50,18 +64,6 @@ Engine.prototype.startService = function(serviceName, _options) {
   return service.apply(this, [options]);
 };
 
-Engine.prototype.monitorService = function(options) {
-  var servicesMonitor = new ServicesMonitor({
-    logger: this.logger,
-    config: this.config,
-    serverHost: options.serverHost,
-    serverPort: options.serverPort,
-    runWebserver: options.runWebserver,
-    version: this.version
-  });
-  servicesMonitor.startMonitor();
-};
-
 Engine.prototype.pipelineService = function(options) {
   var self = this;
   this.logger.setStatus("Building Assets");
@@ -111,7 +113,7 @@ Engine.prototype.abiService = function(options) {
 Engine.prototype.deploymentService = function(options) {
   var self = this;
   this.deployManager = new DeployManager({
-    web3: options.web3,
+    web3: options.web3 || self.web3,
     trackContracts: options.trackContracts,
     config: this.config,
     logger: this.logger,
@@ -134,15 +136,96 @@ Engine.prototype.fileWatchService = function(options) {
 };
 
 Engine.prototype.webServerService = function(options) {
+  var self = this;
   var webServerConfig = this.config.webServerConfig;
   if (!webServerConfig.enabled) { return; }
+
+  var host = options.host || webServerConfig.host;
+  var port = options.port  || webServerConfig.port;
+
   this.logger.setStatus("Starting Server");
   var server = new Server({
     logger: this.logger,
-    host: options.host || webServerConfig.host,
-    port: options.port  || webServerConfig.port
+    host: host,
+    port: port
+  });
+
+  self.servicesMonitor.addCheck('Webserver', function(cb) {
+    var devServer = 'Webserver (http://' + host + ':' + port + ')';
+    return cb({name: devServer, status: 'green'});
+  });
+
+  server.start(function(){
   });
-  server.start(function(){});
 };
 
+Engine.prototype.ipfsService = function(options) {
+  var self = this;
+  self.servicesMonitor.addCheck('IPFS', function(cb) {
+    utils.checkIsAvailable('http://localhost:5001', function(available) {
+      if (available) {
+        //Ideally this method should be in an IPFS API JSONRPC wrapper
+        //The URL should also be flexible to accept non-default IPFS url
+        self.logger.trace("Checking IPFS version...");
+        http.get('http://localhost:5001/api/v0/version', function(res) {
+          var body = '';
+          res.on('data', function(d) {
+            body += d;
+          });
+          res.on('end', function() {
+            try{
+              var parsed = JSON.parse(body);
+              if(parsed.Version){
+                return cb({name: ("IPFS " + parsed.Version), status: 'green'});
+              }
+              else{
+                return cb({name: "IPFS ", status: 'green'});
+              }
+            }
+            catch (e){
+              return cb({name: "IPFS ", status: 'red'});
+            }
+          });
+          res.on('error', function(err) {
+            self.logger.trace("Check IPFS version error: " + err);
+            return cb({name: "IPFS ", status: 'red'});
+          });
+        });
+      }
+      else {
+        return cb({name: "IPFS ", status: 'red'});
+      }
+    });
+  });
+};
+
+Engine.prototype.web3Service = function(options) {
+  var self = this;
+  this.web3 = options.web3;
+  if (this.web3 === undefined) {
+    this.web3 = new Web3();
+    var web3Endpoint = 'http://' + this.config.blockchainConfig.rpcHost + ':' + this.config.blockchainConfig.rpcPort;
+    this.web3.setProvider(new this.web3.providers.HttpProvider(web3Endpoint));
+  }
+
+  self.servicesMonitor.addCheck('Ethereum', function(cb) {
+    if (self.web3.isConnected()) {
+      return cb({name: (self.web3.version.node.split("/")[0] + " " + self.web3.version.node.split("/")[1].split("-")[0] + " (Ethereum)"), status: 'green'});
+    } else {
+      return cb({name: "No Blockchain node found", status: 'red'});
+    }
+  });
+
+  self.servicesMonitor.addCheck('Whisper', function(cb) {
+    self.web3.version.getWhisper(function(err, res) {
+      if (err) {
+        return cb({name: 'Whisper', status: 'red'});
+      } else {
+        return cb({name: 'Whisper', status: 'green'});
+      }
+    });
+  });
+};
+
+
 module.exports = Engine;

lib/core/fs.js

@@ -1,5 +1,5 @@
 var fs = require('fs-extra');
-var utils = require('./utils.js');
+var utils = require('../utils/utils.js');
 
 function mkdirpSync() {
   return fs.mkdirpSync.apply(fs.mkdirpSync, arguments);

lib/core/logger.js

@@ -5,7 +5,6 @@ var Logger = function(options) {
   this.logLevel    = options.logLevel || 'info';
   this.logFunction = options.logFunction || console.log;
   this.contractsState = options.contractsState || function() {};
-  this.availableServices = options.availableServices || function() {};
   this.setStatus = options.setStatus || console.log;
 };
 

lib/core/plugin.js

@@ -1,6 +1,6 @@
 /*jshint esversion: 6, loopfunc: true */
 var fs = require('./fs.js');
-var utils = require('./utils.js');
+var utils = require('../utils/utils.js');
 
 // TODO: pass other params like blockchainConfig, contract files, etc..
 var Plugin = function(options) {

lib/core/plugins.js

@@ -1,5 +1,5 @@
 var Plugin = require('./plugin.js');
-var utils = require('./utils.js');
+var utils = require('../utils/utils.js');
 
 var Plugins = function(options) {
   this.pluginList = options.plugins || [];

lib/core/services.js

@@ -1,119 +0,0 @@
-var Web3 = require('web3');
-var async = require('async');
-var http = require('http');
-var utils = require('./utils.js');
-
-// TODO: needs a refactor and be done in a different way
-var ServicesMonitor = function(options) {
-  this.logger = options.logger;
-  this.interval = options.interval || 5000;
-  this.config = options.config;
-  this.serverHost = options.serverHost || 'localhost';
-  this.serverPort = options.serverPort || 8000;
-  this.runWebserver = options.runWebserver;
-  this.version = options.version;
-};
-
-ServicesMonitor.prototype.startMonitor = function() {
-  this.check();
-  this.monitor = setInterval(this.check.bind(this), this.interval);
-};
-
-ServicesMonitor.prototype.stopMonitor = function() {
-  clearInterval(this.monitor);
-};
-
-ServicesMonitor.prototype.check = function() {
-  var self = this;
-  async.waterfall([
-    function connectWeb3(callback) {
-      self.logger.trace('connectWeb3');
-      var web3 = new Web3();
-      var web3Endpoint = 'http://' + self.config.blockchainConfig.rpcHost + ':' + self.config.blockchainConfig.rpcPort;
-      web3.setProvider(new web3.providers.HttpProvider(web3Endpoint));
-      callback(null, web3, []);
-    },
-    function addEmbarkVersion(web3, result, callback) {
-      self.logger.trace('addEmbarkVersion');
-      result.push(('Embark ' + self.version).green);
-      callback(null, web3, result);
-    },
-    function checkEthereum(web3, result, callback) {
-      self.logger.trace('checkEthereum');
-      var service;
-      if (web3.isConnected()) {
-        service = (web3.version.node.split("/")[0] + " " + web3.version.node.split("/")[1].split("-")[0] + " (Ethereum)").green;
-      } else {
-        service = "No Blockchain node found".red;
-      }
-      result.push(service);
-      callback(null, web3, result);
-    },
-    function checkWhisper(web3, result, callback) {
-      self.logger.trace('checkWhisper');
-      web3.version.getWhisper(function(err, res) {
-        var service = 'Whisper';
-        result.push(err ? service.red : service.green);
-        callback(null, result);
-      });
-    },
-    function checkIPFS(result, callback) {
-      self.logger.trace('checkIPFS');
-
-      utils.checkIsAvailable('http://localhost:5001', function(available) {
-        if (available) {
-          //Ideally this method should be in an IPFS API JSONRPC wrapper
-          //The URL should also be flexible to accept non-default IPFS url
-          self.logger.trace("Checking IPFS version...");
-          http.get('http://localhost:5001/api/v0/version', function(res) {
-            var body = '';
-           res.on('data', function(d) {
-               body += d;
-           });
-           res.on('end', function() {
-               try{
-                 var parsed = JSON.parse(body);
-                 if(parsed.Version){
-                   result.push(("IPFS " + parsed.Version).green);
-                 }
-                 else{
-                   result.push("IPFS".green);
-                 }
-               }
-               catch (e){
-                 result.push("IPFS".red);
-               }
-               callback(null, result);
-           });
-           res.on('error', function(err) {
-            self.logger.trace("Check IPFS version error: " + err);
-            result.push("IPFS".red);
-            callback(null, result);
-           });
-         });
-        }
-        else {
-          result.push('IPFS'.red);
-          return callback(null, result);
-        }
-      });
-    },
-    function checkDevServer(result, callback) {
-      var host = self.serverHost || self.config.webServerConfig.host;
-      var port = self.serverPort || self.config.webServerConfig.port;
-      self.logger.trace('checkDevServer');
-      var devServer = 'Webserver (http://' + host + ':' + port + ')';
-      devServer = (self.runWebserver) ? devServer.green : devServer.red;
-      result.push(devServer);
-      callback(null, result);
-    }
-  ], function(err, result) {
-    if (err) {
-      self.logger.error(err.message);
-    } else {
-      self.logger.availableServices(result);
-    }
-  });
-};
-
-module.exports = ServicesMonitor;

lib/core/services_monitor.js

@@ -0,0 +1,80 @@
+var async = require('../utils/async_extend.js');
+
+// TODO: need to separate colors from states
+// i.e use status: /on|off|warn/ not /red|green/
+// it's up to the logger or console to determine the color
+var ServicesMonitor = function(options) {
+  this.events = options.events;
+  this.logger = options.logger;
+  this.checkList = {};
+  this.checkTimers = {};
+  this.checkState = {};
+  this.working = false;
+};
+
+ServicesMonitor.prototype.initCheck = function(checkName) {
+  var self = this;
+  var check = this.checkList[checkName];
+
+  if (!check) { return false; }
+
+  self.events.on('check:' + checkName, function(obj) {
+    // TODO: see todo above
+    if (check && check.status === 'red' && obj.status === 'green') {
+      self.events.emit('check:backOnline:' + checkName);
+    }
+    if (check && check.status === 'green' && obj.status === 'red') {
+      self.events.emit('check:wentOffline:' + checkName);
+    }
+    self.checkState[checkName] = obj.name[obj.status];
+    check.status = obj.status;
+    self.events.emit("servicesState", self.checkState);
+  });
+
+  if (check.interval !== 0) {
+    self.checkTimers[checkName] = setInterval(function() {
+      check.fn.call(check.fn, function(obj) {
+        self.events.emit('check:' + checkName, obj);
+      });
+    }, check.interval);
+  }
+
+  check.fn.call(check.fn, function(obj) {
+    self.events.emit('check:' + checkName, obj);
+  });
+};
+
+ServicesMonitor.prototype.addCheck = function(checkName, checkFn, time) {
+  var self = this;
+  this.logger.trace('add check: ' + checkName);
+  this.checkList[checkName] = {fn: checkFn, interval: time || 5000};
+
+  if (this.working) {
+    this.initCheck(checkName);
+  }
+};
+
+ServicesMonitor.prototype.stopCheck = function(name) {
+  clearInterval(this.checkTimers[name]);
+  delete this.checkTimers[name];
+  delete this.checkList[name];
+  delete this.checkState[name];
+};
+
+ServicesMonitor.prototype.startMonitor = function() {
+  var self = this;
+  this.working = true;
+  this.logger.trace('startMonitor');
+
+  async.eachObject(this.checkList, function(checkName, check, callback) {
+    self.initCheck(checkName);
+    callback();
+  }, function(err) {
+    if (err) {
+      self.logger.error("error running service check");
+      self.logger.error(err.message);
+    }
+  });
+};
+
+module.exports = ServicesMonitor;

lib/core/test.js

@@ -1,15 +1,7 @@
 var async = require('async');
 var Web3 = require('web3');
 
-var Embark = require('../index.js');
-
 var Engine = require('./engine.js');
-
-var ABIGenerator = require('../contracts/abi.js');
-var ContractsManager = require('../contracts/contracts.js');
-var Deploy = require('../contracts/deploy.js');
-
-var Config = require('./config.js');
 var RunCode = require('./runCode.js');
 var TestLogger = require('./test_logger.js');
 

lib/dashboard/console.js

@@ -1,4 +1,4 @@
-var utils = require('../core/utils.js');
+var utils = require('../utils/utils.js');
 var RunCode = require('../core/runCode.js');
 
 var Console = function(options) {

lib/dashboard/dashboard.js

@@ -23,7 +23,6 @@ Dashboard.prototype.start = function(done) {
       monitor = new Monitor({env: self.env, console: console});
       self.logger.logFunction = monitor.logEntry;
       self.logger.contractsState = monitor.setContracts;
-      self.logger.availableServices = monitor.availableServices;
       self.logger.setStatus = monitor.setStatus.bind(monitor);
 
       self.logger.info('========================'.bold.green);

lib/dashboard/monitor.js

@@ -40,7 +40,13 @@ function Dashboard(options) {
   this.input.focus();
 }
 
-Dashboard.prototype.availableServices = function(services) {
+Dashboard.prototype.availableServices = function(_services) {
+  var services = [];
+  var checkName;
+  for (checkName in _services) {
+    services.push(_services[checkName]);
+  }
+
   this.progress.setContent(services.join('\n'));
   this.screen.render();
 };

lib/index.js

@@ -1,8 +1,7 @@
 /*jshint esversion: 6 */
 var async = require('async');
-//require("./core/debug_util.js")(__filename, async);
+//require("./utils/debug_util.js")(__filename, async);
 
-var Web3 = require('web3');
 var colors = require('colors');
 
 var Engine = require('./core/engine.js');
@@ -90,6 +89,11 @@ var Embark = {
             dashboard.console.runCode(abi);
           });
 
+          engine.logger.info('dashboard start');
+          engine.events.on('servicesState', function(servicesState) {
+            dashboard.monitor.availableServices(servicesState);
+          });
+
           callback();
         });
       },
@@ -99,16 +103,20 @@ var Embark = {
           engine.logger.info("loaded plugins: " + pluginList.join(", "));
         }
 
-        if (options.useDashboard) {
-          engine.startService("monitor", {
-            serverHost: options.serverHost,
-            serverPort: options.serverPort,
-            runWebserver: options.runWebserver
-          });
-        }
+        engine.startMonitor();
+        engine.startService("web3");
         engine.startService("pipeline");
         engine.startService("abi");
         engine.startService("deployment");
+        engine.startService("ipfs");
+
+        engine.events.on('check:backOnline:Ethereum', function() {
+          engine.logger.info('Ethereum node detected..');
+          engine.config.reloadConfig();
+          engine.deployManager.deployContracts(function() {
+            engine.logger.info('Deployment Done');
+          });
+        });
 
         engine.deployManager.deployContracts(function() {
           engine.startService("fileWatcher");

lib/utils/async_extend.js

@@ -0,0 +1,14 @@
+var async = require('async');
+
+function asyncEachObject(object, iterator, callback) {
+  async.each(
+    Object.keys(object || {}),
+    function(key, next){
+      iterator(key, object[key], next);
+    },
+    callback
+  );
+}
+async.eachObject = asyncEachObject;
+
+module.exports = async;