deep-package-manager/lib.compiled/Registry/Registry.js

DEEP Package Manager

/**
 * Created by AlexanderC on 2/5/16.
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Registry = undefined;

var _WaitFor = require('../Helpers/WaitFor');

var _Dumper = require('./Dumper/Dumper');

var _Storage = require('./Storage/Storage');

var _S3Driver = require('./Storage/Driver/S3Driver');

var _FSDriver = require('./Storage/Driver/FSDriver');

var _ApiDriver = require('./Storage/Driver/ApiDriver');

var _GitHubDriver = require('./Storage/Driver/GitHubDriver');

var _ComplexDriver = require('./Storage/Driver/ComplexDriver');

var _PropertyAwareFSDriver = require('./Dumper/Driver/PropertyAwareFSDriver');

var _FSDriver2 = require('./Dumper/Driver/FSDriver');

var _DependenciesResolver = require('./Resolver/DependenciesResolver');

var _ModuleInstance = require('./Module/ModuleInstance');

var _ModuleConfig = require('./ModuleConfig');

var _Server = require('./Local/Server');

var _Context = require('./Context/Context');

var _OptimisticStrategy = require('./Resolver/Strategy/OptimisticStrategy');

class Registry {
  /**
   * @param {Storage|*} storage
   */
  constructor(storage) {
    this._storage = storage;
  }

  /**
   * @returns {Storage|*}
   */
  get storage() {
    return this._storage;
  }

  /**
   * @param {String} repositoryPath
   * @param {String} baseHost
   * @param {Function} cb
   * @param {Boolean} cached
   * @returns {Server|*}
   */
  static startApiServerAndCreateRegistry(repositoryPath, baseHost, cb, cached = false) {
    let server = new _Server.Server(repositoryPath);

    server.start(error => {
      if (error) {
        cb(error, null);
        return;
      }

      Registry.createApiRegistry(baseHost, (error, registry) => {
        if (error) {
          server.stop(() => {
            cb(error, null);
          });

          return;
        }

        cb(null, registry);
      }, cached);
    });

    return server;
  }

  /**
   * @param {String} baseHost
   * @param {Function} cb
   * @param {Boolean} cached
   */
  static createApiRegistry(baseHost, cb, cached = false) {
    let driver = new _ComplexDriver.ComplexDriver(new _GitHubDriver.GitHubDriver());
    let storage = new _Storage.Storage(driver);

    _ApiDriver.ApiDriver.autoDiscover(baseHost, (error, apiDriver) => {
      if (error) {
        console.warn(`DEEP registry is not available on ${baseHost}`);
      } else {
        driver.addDriver(apiDriver);
      }

      try {
        cb(null, new Registry(storage));
      } catch (error) {
        cb(error, null);
      }
    }, cached);
  }

  /**
   * @param {String} storagePath
   * @returns {Registry}
   */
  static createRegistry(storagePath) {
    let driver = new _ComplexDriver.ComplexDriver(new _FSDriver.FSDriver(storagePath), new _GitHubDriver.GitHubDriver());

    let storage = new _Storage.Storage(driver);

    return new Registry(storage);
  }

  /**
   * @param {AWS.S3|*} s3
   * @param {String} bucket
   * @param {String} prefix
   * @returns {Registry}
   */
  static createS3Registry(s3, bucket, prefix = '') {
    let storage = new _Storage.Storage(new _S3Driver.S3Driver(s3, bucket, prefix));

    return new Registry(storage);
  }

  /**
   * @param {Property|*} property
   * @param {Function} cb
   * @param {String[]|null} allowedMicroservices
   */
  install(property, cb, allowedMicroservices = null) {
    let dumpPath = property.path;
    let wait = new _WaitFor.WaitFor();

    let cbSent = false;
    let microservices = property.microservices;
    let remaining = microservices.length;

    wait.push(() => {
      return remaining <= 0;
    });

    microservices.forEach(microservice => {
      if (allowedMicroservices && Array.isArray(allowedMicroservices) && allowedMicroservices.indexOf(microservice.identifier) === -1) {

        remaining--;
        return;
      }

      let dependencies = microservice.config.dependencies || {};

      if (Object.keys(dependencies).length <= 0) {
        remaining--;
        return;
      }

      for (let dependencyName in dependencies) {
        if (!dependencies.hasOwnProperty(dependencyName)) {
          continue;
        }

        let dependencyRawVersion = dependencies[dependencyName];
        let moduleContext = _Context.Context.create(dependencyName, dependencyRawVersion);

        this.installModule(moduleContext, dumpPath, error => {
          if (error) {
            if (!cbSent) {
              cbSent = true;
              cb(error);
            }
          }

          remaining--;
        }, property);
      }
    });

    wait.ready(() => {
      if (!cbSent) {
        cb(null);
      }
    });
  }

  /**
   * @param {String} modulePath
   * @param {Function} cb
   */
  publishModule(modulePath, cb) {
    _ModuleConfig.ModuleConfig.createFromModulePath(this._storage, modulePath, (error, moduleConfig) => {
      if (error) {
        cb(error);
        return;
      }

      console.debug(`Publishing '${moduleConfig.context}' module`);

      let moduleObj = new _ModuleInstance.ModuleInstance(moduleConfig.context, '', this._storage);

      console.debug(`Archiving '${moduleConfig.context}' module content`);

      moduleObj.load(modulePath, () => {
        console.debug(`Uploading '${moduleConfig.context}' module to remote registry`);

        moduleObj.upload(error => {
          if (error) {
            cb(error);
            return;
          }

          console.debug(`Saving '${moduleConfig.context}' module config to remote registry`);

          moduleConfig.dump(error => {
            if (error) {
              cb(error);
              return;
            }

            console.debug(`Updating '${moduleConfig.context}' module DB`);

            this._storage.updateModuleDb(moduleConfig.context, error => {
              if (error) {
                console.error(`Module '${moduleConfig.context}' publication failed: ${error}`);
              } else {
                console.debug(`Module '${moduleConfig.context}' successfully published`);
              }

              cb(error);
            });
          });
        });
      });
    });
  }

  /**
   * @param {Context} moduleContext
   * @param {String} dumpPath
   * @param {Function} cb
   * @param {Property|Instance|null|*} property
   *
   * @todo: Remove property argument?
   */
  installModule(moduleContext, dumpPath, cb, property = null) {
    console.debug(`Installing '${moduleContext}' module into '${dumpPath}'`);

    _DependenciesResolver.DependenciesResolver.createUsingRawVersion(this._storage, new _OptimisticStrategy.OptimisticStrategy(), moduleContext, (error, dependenciesResolver) => {
      if (error) {
        console.error(`Module '${moduleContext}' installation failed: ${error}`);
        cb(error);
        return;
      }

      let dumpDriver = property ? Registry._getPropertyAwareFSDumpDriver(dumpPath, property) : Registry._getFSDumpDriver(dumpPath);

      let dumper = new _Dumper.Dumper(dependenciesResolver, this._storage, dumpDriver);

      dumper.dump(error => {
        if (error) {
          console.error(`Module '${moduleContext}' installation failed: ${error}`);
        } else {
          console.log(`Module '${moduleContext}' successfully installed`);
        }

        cb(error);
      });
    });
  }

  /**
   * @param {String} basePath
   * @param {Property|Instance|*} property
   * @returns {PropertyAwareFSDriver|*}
   * @private
   */
  static _getPropertyAwareFSDumpDriver(basePath, property) {
    let driver = new _PropertyAwareFSDriver.PropertyAwareFSDriver(basePath);
    driver.property = property;

    return driver;
  }

  /**
   * @param {String} basePath
   * @returns {FSDriver|*}
   * @private
   */
  static _getFSDumpDriver(basePath) {
    return new _FSDriver2.FSDriver(basePath);
  }
}
exports.Registry = Registry;