Merge pull request #165 from pnagurny/feature/web-service

Web Service and other changes in preparation for insight-api

Author: Braydon Fuller

integration/regtest-node.js

@@ -69,17 +69,17 @@ describe('Node Functionality', function() {
           {
             name: 'db',
             module: DBService,
-            dependencies: DBService.dependencies
+            config: {}
           },
           {
             name: 'bitcoind',
             module: BitcoinService,
-            dependencies: BitcoinService.dependencies
+            config: {}
           },
           {
             name: 'address',
             module: AddressService,
-            dependencies: AddressService.dependencies
+            config: {}
           }
         ]
       };

integration/regtest.js

@@ -227,7 +227,27 @@ describe('Daemon Binding Functionality', function() {
         work.cmp(expectedWork).should.equal(0);
         expectedWork = expectedWork.add(new BN(2));
         should.exist(blockIndex.prevHash);
+        blockIndex.hash.should.equal(blockHashes[i]);
         blockIndex.prevHash.should.equal(blockHashes[i - 1]);
+        blockIndex.height.should.equal(i + 1);
+      });
+    });
+  });
+
+  describe('get block index by height', function() {
+    var expectedWork = new BN(6);
+    [2,3,4,5,6,7,8,9].forEach(function(i) {
+      it('generate block ' + i, function() {
+        var blockIndex = bitcoind.getBlockIndex(i);
+        should.exist(blockIndex);
+        should.exist(blockIndex.chainWork);
+        var work = new BN(blockIndex.chainWork, 'hex');
+        work.cmp(expectedWork).should.equal(0);
+        expectedWork = expectedWork.add(new BN(2));
+        should.exist(blockIndex.prevHash);
+        blockIndex.hash.should.equal(blockHashes[i - 1]);
+        blockIndex.prevHash.should.equal(blockHashes[i - 2]);
+        blockIndex.height.should.equal(i);
       });
     });
   });

lib/node.js

@@ -6,10 +6,12 @@ var async = require('async');
 var bitcore = require('bitcore');
 var Networks = bitcore.Networks;
 var $ = bitcore.util.preconditions;
+var _ = bitcore.deps._;
 var index = require('./');
 var log = index.log;
 var Bus = require('./bus');
 var BaseService = require('./service');
+var errors = require('./errors');
 
 function Node(config) {
   if(!(this instanceof Node)) {
@@ -18,6 +20,8 @@ function Node(config) {
 
   var self = this;
 
+  this.errors = errors; // So services can use errors without having to have bitcore-node as a dependency
+  this.log = log;
   this.network = null;
   this.services = {};
   this._unloadedServices = [];
@@ -30,6 +34,7 @@ function Node(config) {
 
   $.checkState(config.datadir, 'Node config expects "datadir"');
   this.datadir = config.datadir;
+  this.port = config.port;
 
   this._setNetwork(config);
 
@@ -116,7 +121,7 @@ Node.prototype.getServiceOrder = function() {
       $.checkState(service, 'Required dependency "' + name + '" not available.');
 
       // first add the dependencies
-      addToStack(service.dependencies);
+      addToStack(service.module.dependencies);
 
       // add to the stack if it hasn't been added
       if(!stackNames[name]) {
@@ -134,9 +139,13 @@ Node.prototype.getServiceOrder = function() {
 
 Node.prototype._instantiateService = function(service) {
   var self = this;
-  var mod = new service.module({
-    node: this
-  });
+
+  $.checkState(_.isObject(service.config));
+  $.checkState(!service.config.node);
+
+  var config = service.config;
+  config.node = this;
+  var mod = new service.module(config);
 
   $.checkState(
     mod instanceof BaseService,

lib/scaffold/default-config.js

@@ -13,7 +13,7 @@ function getDefaultConfig() {
       datadir: process.env.BITCORENODE_DIR || path.resolve(process.env.HOME, '.bitcoin'),
       network: process.env.BITCORENODE_NETWORK || 'livenet',
       port: process.env.BITCORENODE_PORT || 3001,
-      services: ['bitcoind', 'db', 'address']
+      services: ['bitcoind', 'db', 'address', 'web']
     }
   };
 }

lib/scaffold/start.js

@@ -6,6 +6,7 @@ var BitcoreNode = require('../node');
 var index = require('../');
 var bitcore = require('bitcore');
 var _ = bitcore.deps._;
+var $ = bitcore.util.preconditions;
 var log = index.log;
 log.debug = function() {};
 
@@ -22,37 +23,35 @@ function start(options) {
 
   if (config.services) {
     for (var i = 0; i < config.services.length; i++) {
-      var serviceName = config.services[i];
-      var service;
+      var service = {};
+      service.name = config.services[i];
+      service.config = config.servicesConfig && config.servicesConfig[service.name] ? config.servicesConfig[service.name] : {};
+
       try {
         // first try in the built-in bitcore-node services directory
-        service = require(path.resolve(__dirname, '../services/' + serviceName));
+        service.module = require(path.resolve(__dirname, '../services/' + service.name));
       } catch(e) {
 
         // check if the package.json specifies a specific file to use
-        var servicePackage = require(serviceName + '/package.json');
-        var serviceModule = serviceName;
+        var servicePackage = require(service.name + '/package.json');
+        var serviceModule = service.name;
         if (servicePackage.bitcoreNode) {
-          serviceModule = serviceName + '/' + servicePackage.bitcoreNode;
+          serviceModule = service.name + '/' + servicePackage.bitcoreNode;
         }
-        service = require(serviceModule);
+        service.module = require(serviceModule);
       }
 
       // check that the service supports expected methods
-      if (!service.prototype ||
-          !service.dependencies ||
-          !service.prototype.start ||
-          !service.prototype.stop) {
+      if (!service.module.prototype ||
+          !service.module.dependencies ||
+          !service.module.prototype.start ||
+          !service.module.prototype.stop) {
         throw new Error(
-          'Could not load service "' + serviceName + '" as it does not support necessary methods.'
+          'Could not load service "' + service.name + '" as it does not support necessary methods.'
         );
       }
-      services.push({
-        name: serviceName,
-        module: service,
-        dependencies: service.dependencies
-      });
 
+      services.push(service);
     }
   }
 
@@ -82,102 +81,7 @@ function start(options) {
   });
 
   node.on('ready', function() {
-
-    var io = socketio(fullConfig.port);
-
-    io.on('connection', function(socket) {
-
-      var bus = node.openBus();
-
-      var methods = node.getAllAPIMethods();
-      var methodsMap = {};
-
-      methods.forEach(function(data) {
-        var name = data[0];
-        var instance = data[1];
-        var method = data[2];
-        var args = data[3];
-        methodsMap[name] = {
-          fn: function() {
-            return method.apply(instance, arguments);
-          },
-          args: args
-        };
-      });
-
-      socket.on('message', function(message, socketCallback) {
-        if (methodsMap[message.method]) {
-          var params = message.params;
-
-          if(!params || !params.length) {
-            params = [];
-          }
-
-          if(params.length !== methodsMap[message.method].args) {
-            return socketCallback({
-              error: {
-                message: 'Expected ' + methodsMap[message.method].args + ' parameters'
-              }
-            });
-          }
-
-          var callback = function(err, result) {
-            var response = {};
-            if(err) {
-              response.error = {
-                message: err.toString()
-              };
-            }
-
-            if(result) {
-              response.result = result;
-            }
-
-            socketCallback(response);
-          };
-
-          params = params.concat(callback);
-          methodsMap[message.method].fn.apply(this, params);
-        } else {
-          socketCallback({
-            error: {
-              message: 'Method Not Found'
-            }
-          });
-        }
-      });
-
-      socket.on('subscribe', function(name, params) {
-        bus.subscribe(name, params);
-      });
-
-      socket.on('unsubscribe', function(name, params) {
-        bus.unsubscribe(name, params);
-      });
-
-      var events = node.getAllPublishEvents();
-
-      events.forEach(function(event) {
-        bus.on(event.name, function() {
-          if(socket.connected) {
-            var results = [];
-
-            for(var i = 0; i < arguments.length; i++) {
-              results.push(arguments[i]);
-            }
-
-            var params = [event.name].concat(results);
-            socket.emit.apply(socket, params);
-          }
-        });
-      });
-
-      socket.on('disconnect', function() {
-        bus.close();
-      });
-
-    });
-
+    log.info('Bitcore Node ready');
   });
 
   node.on('error', function(err) {
@@ -207,7 +111,12 @@ function start(options) {
       if(err.stack) {
         console.log(err.stack);
       }
-      process.exit(-1);
+      node.stop(function(err) {
+        if(err) {
+          log.error('Failed to stop services: ' + err);
+        }
+        process.exit(-1);
+      });
     }
     if (options.sigint) {
       node.stop(function(err) {

lib/service.js

@@ -24,7 +24,9 @@ Service.dependencies = [];
  */
 Service.prototype.blockHandler = function(block, add, callback) {
   // implement in the child class
-  setImmediate(callback);
+  setImmediate(function() {
+    callback(null, []);
+  });
 };
 
 /**
@@ -57,12 +59,26 @@ Service.prototype.getAPIMethods = function() {
 //
 // };
 
+/**
+ * Function which is called when module is first initialized
+ */
 Service.prototype.start = function(done) {
   setImmediate(done);
 };
 
+/**
+ * Function to be called when bitcore-node is stopped
+ */
 Service.prototype.stop = function(done) {
   setImmediate(done);
 };
 
+/**
+ * Setup express routes
+ * @param  {Express} app
+ */
+Service.prototype.setupRoutes = function(app) {
+  // Setup express routes here
+};
+
 module.exports = Service;

lib/services/address.js

@@ -505,6 +505,7 @@ AddressService.prototype.getAddressHistoryForAddress = function(address, queryMe
         var confirmations = 0;
         if(transaction.__height >= 0) {
           confirmations = self.node.services.db.tip.__height - transaction.__height;
+          confirmations = self.node.services.db.tip.__height - transaction.__height + 1;
         }
 
         txinfos[transaction.hash] = {

lib/services/db.js

@@ -217,6 +217,7 @@ DB.prototype.getTransactionWithBlockInfo = function(txid, queryMempool, callback
     }
 
     var tx = Transaction().fromBuffer(obj.buffer);
+    tx.__blockHash = obj.blockHash;
     tx.__height = obj.height;
     tx.__timestamp = obj.timestamp;
 
@@ -657,6 +658,7 @@ DB.prototype.sync = function() {
 
     self.bitcoindSyncing = false;
     self.lastSavedMetadataThreshold = 0;
+    self.saveMetadata();
 
     // If bitcoind is completely synced
     if (self.node.services.bitcoind.isSynced()) {