embark-area-51/lib/modules/storage/index.js

const utils = require('../../utils/utils.js');
const fs = require('../../core/fs.js');
const _ = require('underscore');
const async = require('async');
const StorageProcessesLauncher = require('../../processes/storageProcesses/storageProcessesLauncher');
const constants = require('../../constants');

class Storage {
  constructor(embark, options){
    this._embark = embark;
    this._options = options;
    this._storageConfig = options.storageConfig;
    this._webServerConfig = options.webServerConfig;
    this._blockchainConfig = options.blockchainConfig;
    this._servicesMonitor = options.servicesMonitor;
    this._events = options.events;
    this._logger = options.logger;

    // filter list of dapp connections based on available_providers set in config
    let hasSwarm = _.contains(this._storageConfig.available_providers, 'swarm'); // don't need to eval this in every loop iteration
    // contains valid dapp storage providers
    this._validDappProviders = _.filter(this._storageConfig.dappConnection, (conn) => {
        return _.contains(this._storageConfig.available_providers, conn.provider) || (conn === '$BZZ' && hasSwarm);
    });

    this.initStorageForEmbark();
    this.initStorageForDapp();

    // don't start storage processes on build command, only on upload or run
    if(_.contains(options.context, constants.contexts.upload) || _.contains(options.context, constants.contexts.run)){
      this.startStorageProcesses();
    }
  }

  _checkStorageEndpoint(platform, callback) {
    let checkFn;
    let self = this;
    self._logger.trace(`Storage module: Checking ${platform} availability...`);
    _.find(self._servicesMonitor.checkList, (value, key) => {
      if(key.toLowerCase() === platform.toLowerCase()){
        checkFn = value;
        return true;
      }
    });
    if (!checkFn || typeof checkFn.fn !== 'function') {
      self._logger.trace(`Storage module: Check for ${platform} node does not exist.`);
      return callback();
    }

    checkFn.fn(function (serviceCheckResult) {
      if (!serviceCheckResult.status || serviceCheckResult.status === 'off') {
        self._logger.trace(`Storage module: ${platform} node not available.`);
        return callback('No node');
      }
      callback();
    });
  }
    
  _startStorageNode(platform, callback) {
    let self = this;
    const storageProcessesLauncher = new StorageProcessesLauncher({
      logger: self._logger,
      events: self._events,
      storageConfig: self._storageConfig,
      webServerConfig: self._webServerConfig,
      blockchainConfig: self._blockchainConfig
    });
    self._logger.trace(`Storage module: Launching ${platform} process...`);
    return storageProcessesLauncher.launchProcess(platform.toLowerCase(), (err) => {
      if (err) {
        self._logger.error(err);
        return callback(err);
      }
      callback();
    });
  }

  /// Initializes a storage provider for Embark upload
  initStorageForEmbark(){
    let storageProviderCls = require(`../${this._storageConfig.upload.provider}/index.js`);
    let uploadProvider = new storageProviderCls(this._embark, this._options); /*eslint no-new: "off"*/

    if(typeof uploadProvider.commandlineDeploy == 'function') uploadProvider.commandlineDeploy();
    if(typeof uploadProvider.setServiceCheck == 'function') uploadProvider.setServiceCheck();
    if(typeof uploadProvider.addObjectToConsole == 'function') uploadProvider.addObjectToConsole();
  }

  /**
   * Initializes a storage provider for EmbarkJS
   * 
   * @return {void}
   */
  initStorageForDapp(){
    // now we need to add instantiate any dappConnection/available_providers storage providers to add
    // their provider code to embarkjs
    this._validDappProviders.forEach(dappConn => {
      if(!dappConn.provider) return;
      let storageProviderCls = require(`../${dappConn.provider}/index.js`);
      
      // override options with dappConnection settings
      let storageOptions = this._options;
      storageOptions.protocol = dappConn.protocol;
      storageOptions.host = dappConn.host;
      storageOptions.port = dappConn.port;

      // then instantiate the storage provdier class
      let storageProvider = new storageProviderCls(this._embark, storageOptions); /*eslint no-new: "off"*/

      // register the service check so we can use it to check if the process is running before spawning it
      // check that it hasn't already been done above
      if(dappConn.provider !== this._storageConfig.upload.provider){
        if(typeof storageProvider.setServiceCheck == 'function') storageProvider.setServiceCheck();
      }

      // add __embarkSwarm and __embarkIPFS objects to EmbarkJS
      if(typeof storageProvider.addProviderToEmbarkJS == 'function') storageProvider.addProviderToEmbarkJS();
    });

    // add the storage provider code (__embarkStorage) to embarkjs
    this.addProviderToEmbarkJS();

    // add the code to call setProviders in embarkjs after embark is ready
    this.addSetProviders();
  }

  /**
   * Adds the storage provider code (__embarkStorage) to embarkjs
   * 
   * @returns {void}
   */
  addProviderToEmbarkJS(){
    // TODO: make this a shouldAdd condition
    if (this._storageConfig === {} || !this._storageConfig.dappConnection || !this._storageConfig.dappConnection.length) {
      return;
    }

    let code = "\n" + fs.readFileSync(utils.joinPath(__dirname, 'embarkjs.js')).toString();

    this._embark.addCodeToEmbarkJS(code);
  }

  /**
   * Adds the code to call setProviders in embarkjs after embark is ready
   * 
   * @returns {void}
   */
  addSetProviders() {

    let code = `\n__embarkStorage.setProviders(${JSON.stringify(this._validDappProviders)});`;
    let shouldInit = (storageConfig) => {
      return (this._validDappProviders !== undefined && this._validDappProviders.length > 0 && storageConfig.enabled === true);
    };
  
    this._embark.addProviderInit('storage', code, shouldInit);
  }

  startStorageProcesses(){
    let platform = this._storageConfig.upload.provider;
    let self = this;

    async.waterfall([
      function checkStorageService(callback){
        const errorObj = {message: __('Cannot upload: {{platform}} node is not running on {{url}}.', {platform: platform, url: utils.buildUrlFromConfig(self._storageConfig.upload)})};

        // start the upload storage node
        self._checkStorageEndpoint(platform, function (err) {
          if (!err) {
            return callback();
          }
          self._startStorageNode(platform, (err) => {
            if (err) {
              self._logger.error(err);
              return callback(errorObj);
            }
            // Check endpoint again to see if really did start
            self._checkStorageEndpoint(platform, (err) => {
              if (err) {
                return callback(errorObj);
              }
              callback();
            });
          });
        });
      },
      function checkDappConnectionStorageService(callback){
        // start any dappConnection storage nodes
        self._validDappProviders.forEach(dappConn => {
          if(!dappConn.provider || dappConn.provider === platform) return; // don't start the process we've just started above
          
          const errorObj = {message: __('Cannot start {{platform}} node on {{url}}.', {platform: dappConn.provider, url: utils.buildUrlFromConfig(dappConn)})};
          
          self._checkStorageEndpoint(dappConn.provider, function (err) {
            if (!err) {
              return callback();
            }
            self._startStorageNode(dappConn.provider, (err) => {
              if (err) {
                self._logger.error(err);
                return callback(errorObj);
              }
              // Check endpoint again to see if really did start
              self._checkStorageEndpoint(dappConn.provider, (err) => {
                if (err) {
                  return callback(errorObj);
                }
                callback();
              });
            });
          });
        });
      }
    ]);
  }
}

module.exports = Storage;