Rewrite of core logic, nodeminer will now poll each configured miner …

…on the server side and only emit updates to the client on socket connect (this applies to pool & coin configuration as well)

app.js

@@ -21,13 +21,184 @@ require('./lib/config/express')(app);
 // Routing
 require('./lib/routes')(app);
 
-// socket.io initialization
+// Create our HTTP server
 var server = http.createServer(app).listen(config.port, "0.0.0.0");
+
+// Initialize our services
+var MinerService = new (require('./lib/services/MinersService.js'))();
+var CoinService = new (require('./lib/services/CoinsService.js'))();
+var PoolService = new (require('./lib/services/PoolsService.js'))();
+
+// socket.io initialization
 var io = require('socket.io').listen(server);
-io.set('log level', 1); // reduce logging
+
+// reduce logging
+io.set('log level', 1);
 
 // Listen to socket.io connection
-io.sockets.on('connection', socket);
+//io.sockets.on('connection', socket);
+
+io.sockets.on('connection', function (socket) {
+  socket.emit('miners:init', MinerService.miners);
+  socket.emit('coins:init', CoinService.coins);
+  socket.emit('pools:init', PoolService.pools);
+
+  /*
+   *  Socket.IO Event Listeners
+   */
+  socket.on('save:miners', function (miners) {
+    MinerService.save(miners);
+  });
+
+  socket.on('save:coins', function (coins) {
+    CoinService.save(coins);
+  });
+
+  socket.on('save:pools', function (pools) {
+    PoolService.save(pools);
+  });
+
+  socket.on('gpu:enable', function (data) {
+    MinerService.enableGpu(data.miner, data.device);
+  });
+
+  socket.on('gpu:disable', function (data) {
+    MinerService.disableGpu(data.miner, data.device);
+  });
+
+  socket.on('update:intensity', function (data) {
+    MinerService.updateIntensity(data.miner, data.device, data.value);
+  });
+
+  socket.on('update:gpuengine', function (data) {
+    MinerService.updateGpuEngine(data.miner, data.device, data.value);
+  });
+
+  socket.on('update:gpumemory', function (data) {
+    MinerService.updateGpuMemory (data.miner, data.device, data.value);
+  });
+
+  socket.on('update:gpuvoltage', function (data) {
+    MinerService.updateGpuVoltage (data.miner, data.device, data.value);
+  });
+
+  socket.on('zero:miner', function (miner) {
+    MinerService.zeroMiner(miner);
+  });
+
+  socket.on('zero:allminers', function () {
+    MinerService.miners.forEach(function (miner) {
+      MinerService.zeroMiner(miner);
+    });
+  });
+
+  socket.on('change:pool', function (data) {
+    MinerService.changePool(data.miner, data.pool);
+  });
+
+  /*
+   *  Miner Service Event Listeners
+   */
+  MinerService.on('update', function (miner) {
+    socket.emit('miner:config', miner);
+  });
+
+  MinerService.on('saved', function (miners) {
+    socket.emit('saved:miners', miners);
+  });
+
+  MinerService.on('loaded', function (miners) {
+    socket.emit('miners:init', miners);
+  });
+
+  MinerService.on('error:miner', function (data) {
+    socket.emit('error:miner', { miner: data.miner, error: data.error });
+  });
+
+  MinerService.on('fileError', function (msg, data) {
+    socket.emit('error:file', { msg: msg, data: data });
+  });
+
+  MinerService.on('success:gpuenable', function (data) {
+    socket.emit('success:gpuenable', data);
+  });
+
+  MinerService.on('success:gpudisable', function (data) {
+    socket.emit('success:gpudisable', data);
+  });
+
+  MinerService.on('error:gpuenable', function (data) {
+    socket.emit('error:gpuenable', data);
+  });
+
+  MinerService.on('error:gpudisable', function (data) {
+    socket.emit('error:gpudisable', data);
+  });
+
+  MinerService.on('success:intensity', function (data) {
+    socket.emit('success:intensity', data);
+  });
+
+  MinerService.on('error:intensity', function (data) {
+    socket.emit('error:intensity', data);
+  });
+
+  MinerService.on('success:gpuengine', function (data) {
+    socket.emit('success:gpuengine', data);
+  });
+
+  MinerService.on('error:gpuengine', function (data) {
+    socket.emit('error:gpuengine', data);
+  });
+
+  MinerService.on('success:gpumemory', function (data) {
+    socket.emit('success:gpumemory', data);
+  });
+
+  MinerService.on('error:gpumemory', function (data) {
+    socket.emit('error:gpumemory', data);
+  });
+
+  MinerService.on('success:gpuvoltage', function (data) {
+    socket.emit('success:gpuvoltage', data);
+  });
+
+  MinerService.on('error:gpuvoltage', function (data) {
+    socket.emit('error:gpuvoltage', data);
+  });
+
+  MinerService.on('success:zerominer', function (data) {
+    socket.emit('success:zerominer', { miner:data.miner, status:data.status });
+  });
+
+  MinerService.on('error:zerominer', function (data) {
+    socket.emit('error:zerominer', { miner:data.miner, status:data.status });
+  });
+
+  MinerService.on('success:changepool', function (data) {
+    socket.emit('success:changepool', { miner: data.miner, pool: data.pool, status: data.status });
+  });
+
+  MinerService.on('error:changepool', function (data) {
+    socket.emit('error:changepool', { miner: data.miner, pool: data.pool, status: data.status });
+  });
+
+  /**
+   *  Coins Service Event Listeners
+   */
+
+  CoinService.on('saved', function (coins) {
+    socket.emit('saved:coins', coins);
+  });
+
+  /**
+   *  Pool Service Event Listeners
+   */
+
+  PoolService.on('saved', function (pools) {
+    socket.emit('saved:coins', pools);
+  });
+});
 
 // Expose app
 var exports = module.exports = server;

lib/controllers/api.js

@@ -1,28 +1,23 @@
-var minerApi = require('../modules/bfgminer');
-
 'use strict';
 
-/**
- * Get awesome things
- */
-exports.pingMiner = function (req, res) {
+var MinerService = new (require('../services/MinersService.js'))();
+
+exports.ping = function (req, res) {
   var hostName = req.params.hostname;
   var port = req.params.port;
 
-  minerApi.ping({ host: hostName, port: port }, function (err, data) {
-    if (err) {
-      res.json({
-        host: hostName,
-        port: port,
-        online: false
-      });
-    } else {
-      res.json({
-        host: hostName,
-        port: port,
-        online: true,
-        status: data
-      });
-    }
+  MinerService.ping({ host: hostName, port: port}).then(function (data) {
+    res.json({
+      host: hostName,
+      port: port,
+      online: true,
+      status: data
+    });
+  }, function (err) {
+    res.json({
+      host: hostName,
+      port: port,
+      online: false
+    });
   });
 };

lib/helpers.js

@@ -1,3 +1,5 @@
+var _ = require('lodash');
+
 exports.parseDevDetails = function (miner, response) {
   var data;
 

lib/routes.js

@@ -9,7 +9,7 @@ var api = require('./controllers/api'),
 module.exports = function(app) {
 
   // Server API Routes
-  app.get('/api/miner/ping/:hostname/:port', api.pingMiner)
+  app.get('/api/miner/ping/:hostname/:port', api.ping)
 
   // All other routes to use Angular routing in app/scripts/app.js
   app.get('/partials/*', index.partials);

lib/services/CoinsService.js

@@ -0,0 +1,61 @@
+/**
+ * Dependencies
+ */
+
+var EventEmitter  = require('events').EventEmitter,
+    util          = require('util'),
+    fs            = require('fs'),
+    path          = require('path'),
+    _             = require('lodash'),
+    helpers       = require('../helpers');
+
+function CoinsService() {
+  EventEmitter.call(this);
+  var self = this;
+
+  if (!self.coins || self.coins.length == 0) {
+    self.load();
+  }
+};
+
+util.inherits(CoinsService, EventEmitter);
+
+CoinsService.prototype.load = function () {
+  var self = this;
+
+  var file = path.normalize(__dirname + "/../config/coins.json");
+
+  try {
+    var data = fs.readFileSync(file, 'utf8');
+
+    this.coins = JSON.parse(data);
+
+  } catch (err) {
+    setTimeout(function() {
+      self.emit('fileError', { msg: 'Error reading coin configuration', data: err });
+    }, 0);
+  }
+};
+
+CoinsService.prototype.save = function (coins) {
+  var self = this;
+
+  var file = path.normalize(__dirname + "/../config/coins.json");
+
+  fs.writeFile(file, JSON.stringify(coins, null, 4), function (err) {
+    if (err) {
+      setTimeout(function() {
+        self.emit('fileError', { msg: 'Error saving coin configuration', data: err });
+      }, 0);
+      return;
+    }
+
+    setTimeout(function() {
+      self.emit('saved', coins);
+      self.coins = coins;
+    }, 0);
+  });
+};
+
+module.exports = CoinsService;
+