start.js

'use strict';

var path = require('path');
var BitcoreNode = require('../node');
var index = require('../');
var bitcore = require('bitcore-lib');
var _ = bitcore.deps._;
var log = index.log;
var shuttingDown = false;
var fs = require('fs');

log.debug = function() {};


/**
 * This function will instantiate and start a Node, requiring the necessary service
 * modules, and registering event handlers.
 * @param {Object} options
 * @param {Object} options.servicesPath - The path to the location of service modules
 * @param {String} options.path - The absolute path of the configuration file
 * @param {Object} options.config - The parsed bitcore-node.json configuration file
 * @param {Array}  options.config.services - An array of services names.
 * @param {Object} options.config.servicesConfig - Parameters to pass to each service
 * @param {String} options.config.network - 'livenet', 'testnet' or 'regtest
 * @param {Number} options.config.port - The port to use for the web service
 */
function start(options) {
  /* jshint maxstatements: 20 */

  var fullConfig = _.clone(options.config);

  var servicesPath;
  if (options.servicesPath) {
    servicesPath = options.servicesPath; // services are in a different directory than the config
  } else {
    servicesPath = options.path; // defaults to the same directory
  }

  fullConfig.path = path.resolve(options.path, './bitcore-node.json');

  fullConfig.services = start.setupServices(require, servicesPath, options.config);

  var node = new BitcoreNode(fullConfig);

  // setup handlers for uncaught exceptions and ctrl+c
  start.registerExitHandlers(process, node);

  node.on('ready', function() {
    log.info('Bitcore Node ready');
  });

  node.on('error', function(err) {
    log.error(err);
  });

  node.start(function(err) {
    if(err) {
      log.error('Failed to start services');
      if (err.stack) {
        log.error(err.stack);
      }
      start.cleanShutdown(process, node);
    }
  });

  return node;

}

/**
 * Checks a service for the expected methods
 * @param {Object} service
 */
function checkService(service) {
  if (!service.module.prototype ||
      !service.module.dependencies ||
      !service.module.prototype.start ||
      !service.module.prototype.stop) {
    throw new Error(
      'Could not load service "' +
        service.name +
        '" as it does not support necessary methods and properties.');
  }
}

function lookInRequirePathConfig(req, service) {
  if (!service.config.requirePath) {
    return;
  }

  try {
    if (fs.statSync(service.config.requirePath).isDirectory()) {
      return req(service.config.requirePath);
    }
    var serviceFile = service.config.requirePath.replace(/.js$/, '');
    return req(serviceFile);
  } catch(e) {
    log.info('Checked the service\'s requirePath value, ' +
      'but could not find the service, checking elsewhere. ' +
        'Error caught: ' + e.message);
  }
}

function lookInCwd(req, service) {
  try {
    return req(process.cwd + '/' + service);
  } catch(e) {
    log.info('Checked the current working directory, but did not find the service. ' +
      'Error caught: ' + e.message);
  }
}

function lookInBuiltInPath(req, service) {
  try {
    var serviceFile = path.resolve(__dirname, '../services/' + service.name);
    return req(serviceFile);
  } catch(e) {
    log.info('Checked the built-in path: lib/services, but did not find the service. ' +
      'Error caught: ' + e.message);
  }
}

function lookInModuleManifest(req, service) {
  try {
    var servicePackage = req(service.name + '/package.json');
    var serviceModule = service.name;
    if (servicePackage.bitcoreNode) {
      serviceModule = serviceModule + '/' + servicePackage.bitcoreNode;
      return req(serviceModule);
    }
  } catch(e) {
    log.info('Checked the module\'s package.json for \'bitcoreNode\' field, but found no service. ' +
      'Error caught: ' + e.message);
  }
}

function loadModule(req, service) {
  var serviceCode;

  //first, if we have explicitly set the require path for our service:
  serviceCode = lookInRequirePathConfig(req, service);

  //second, look in the current working directory (of the controlling terminal, if there is one) for the service code
  if(!serviceCode) {
    serviceCode = lookInCwd(req, service);
  }

  //third, try the built-in services
  if(!serviceCode) {
    serviceCode = lookInBuiltInPath(req, service);
  }

  //fourth, see if there is directory in our module search path that has a
  //package.json file, if so, then see if there is a bitcoreNode field, if so
  //use this as the path to the service module
  if(!serviceCode) {
    serviceCode = lookInModuleManifest(req, service);
  }

  if (!serviceCode) {
    throw new Error('Attempted to load the ' + service.name + ' service from: ' +
      'the requirePath in the services\' config, then "' +
      process.cwd() + '" then from: "' + __dirname + '/../lib/services' + '" finally from: "' +
      process.cwd() + '/package.json" - bitcoreNode field. All paths failed to find valid nodeJS code.');
  }

  service.module = serviceCode;
}

/**
 * This function will loop over the configuration for services and require the
 * specified modules, and assemble an array in this format:
 * [
 *   {
 *     name: 'bitcoind',
 *     config: {},
 *     module: BitcoinService
 *   }
 * ]
 * @param {Function} req - The require function to use
 * @param {Array} servicesPath - The local path (for requiring services)
 * @param {Object} config
 * @param {Array} config.services - An array of strings of service names.
 * @returns {Array}
 */
function setupServices(req, servicesPath, config) {

  module.paths.push(path.resolve(servicesPath, './node_modules'));

  var services = [];
  if (config.services) {
    for (var i = 0; i < config.services.length; i++) {
      var service = {};

      service.name = config.services[i];

      var hasConfig = config.servicesConfig && config.servicesConfig[service.name];
      service.config = hasConfig ? config.servicesConfig[service.name] : {};

      loadModule(req, service);
      checkService(service);

      services.push(service);
    }
  }
  return services;
}

/**
 * Will shutdown a node and then the process
 * @param {Object} _process - The Node.js process object
 * @param {Node} node - The Bitcore Node instance
 */
function cleanShutdown(_process, node) {
  node.stop(function(err) {
    if(err) {
      log.error('Failed to stop services: ' + err);
      return _process.exit(1);
    }
    log.info('Halted');
    _process.exit(0);
  });
}

/**
 * Will handle all the shutdown tasks that need to take place to ensure a safe exit
 * @param {Object} options
 * @param {String} options.sigint - The signal given was a SIGINT
 * @param {Array}  options.exit - The signal given was an uncaughtException
 * @param {Object} _process - The Node.js process
 * @param {Node} node
 * @param {Error} error
*/
function exitHandler(options, _process, node, err) {
  if (err) {
    log.error('uncaught exception:', err);
    if(err.stack) {
      log.error(err.stack);
    }
    node.stop(function(err) {
      if(err) {
        log.error('Failed to stop services: ' + err);
      }
      _process.exit(-1);
    });
  }
  if (options.sigint) {
    if (!shuttingDown) {
      shuttingDown = true;
      start.cleanShutdown(_process, node);
    }
  }
}

/**
 * Will register event handlers to stop the node for `process` events
 * `uncaughtException` and `SIGINT`.
 * @param {Object} _process - The Node.js process
 * @param {Node} node
 */
function registerExitHandlers(_process, node) {
  //catches uncaught exceptions
  _process.on('uncaughtException', exitHandler.bind(null, {exit:true}, _process, node));

  //catches ctrl+c event
  _process.on('SIGINT', exitHandler.bind(null, {sigint:true}, _process, node));
}

module.exports = start;
module.exports.registerExitHandlers = registerExitHandlers;
module.exports.exitHandler = exitHandler;
module.exports.setupServices = setupServices;
module.exports.cleanShutdown = cleanShutdown;