deep-package-manager/lib.compiled/Replication/Instance.js

DEEP Package Manager

/**
 * Created by CCristi on 2/6/17.
 */

/* eslint indent:0 */

'use strict';

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

var _awsSdk = require('aws-sdk');

var _awsSdk2 = _interopRequireDefault(_awsSdk);

var _Hash = require('../Helpers/Hash');

var _S3Service = require('./Service/S3Service');

var _DynamoDBService = require('./Service/DynamoDBService');

var _LambdaService = require('./Service/LambdaService');

var _DBManager = require('./Manager/DBManager');

var _FSManager = require('./Manager/FSManager');

var _CloudFrontService = require('./Service/CloudFrontService');

var _Route53Service = require('./Service/Route53Service');

var _AbstractStrategy = require('./Publish/AbstractStrategy');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class Instance {
  /**
   * @param {Object} blueAppConfig
   * @param {Object} greenAppConfig
   */
  constructor(blueAppConfig, greenAppConfig) {
    this._blueConfig = blueAppConfig;
    this._greenConfig = greenAppConfig;

    _awsSdk2.default.config.update(this._blueConfig.aws);

    this._dynamoDbService = new _DynamoDBService.DynamoDBService(this);
    this._dynamoDbService.dynamoDb = new _awsSdk2.default.DynamoDB();

    this._lambdaService = new _LambdaService.LambdaService(this);
    this._lambdaService.lambda = new _awsSdk2.default.Lambda();

    this._s3Service = new _S3Service.S3Service(this);
    this._s3Service.s3 = new _awsSdk2.default.S3();

    this._cloudFrontService = new _CloudFrontService.CloudFrontService(this);
    this._cloudFrontService.cloudFrontClient = new _awsSdk2.default.CloudFront();

    this._route53Service = new _Route53Service.Route53Service(this);
    this._route53Service.route53 = new _awsSdk2.default.Route53();

    this._replicationManagers = null;
  }

  /**
   * @returns {AbstractManager[]|DBManager[]}
   */
  get replicationManagers() {
    if (!this._replicationManagers) {
      this._replicationManagers = [new _DBManager.DBManager(this), new _FSManager.FSManager(this)];
    }

    return this._replicationManagers;
  }

  /**
   * @returns {Object}
   */
  get blueConfig() {
    return this._blueConfig;
  }

  /**
   * @returns {Object}
   */
  get greenConfig() {
    return this._greenConfig;
  }

  /** 
   * @returns {DynamoDBService}
   */
  get dynamoDbService() {
    return this._dynamoDbService;
  }

  /**
   * @returns {LambdaService}
   */
  get lambdaService() {
    return this._lambdaService;
  }

  /**
   * @returns {S3Service}
   */
  get s3Service() {
    return this._s3Service;
  }

  /**
   * @returns {CloudFrontService}
   */
  get cloudFrontService() {
    return this._cloudFrontService;
  }

  /**
   * @returns {Route53Service}
   */
  get route53Service() {
    return this._route53Service;
  }

  /**
   * @returns {String}
   */
  get hashCode() {
    return _Hash.Hash.crc32([this._blueConfig.appIdentifier, this._blueConfig.awsAccountId, this._blueConfig.env].join('|') + '~' + [this._greenConfig.appIdentifier, this._greenConfig.awsAccountId, this._greenConfig.env].join('|'));
  }

  /**
   * @param {Object} resources
   * @returns {Promise}
   */
  prepare(resources) {
    return Promise.all(this.replicationManagers.map(manager => {
      console.info(`Preparing replication for "${manager.name()}" resources.`);

      return manager.prepare(resources[manager.name()]).then(() => {
        console.info(`"${manager.name()}" resources prepared.`);
      });
    }));
  }

  /**
   * @param {Object} resources
   * @returns {Promise}
   */
  start(resources) {
    return Promise.all(this.replicationManagers.map(manager => {
      console.info(`Starting blue-green replication for "${manager.name()}" resources.`);

      return manager.start(resources[manager.name()]).then(() => {
        console.info(`Blue-green replication is running for "${manager.name()} resources."`);
      });
    }));
  }

  /**
   * @param {Object} resources
   * @returns {Promise}
   */
  stop(resources) {
    return Promise.all(this.replicationManagers.map(manager => {
      console.info(`Stopping blue-green replication for "${manager.name()}" resources.`);

      return manager.stop(resources[manager.name()]).then(() => {
        console.info(`Blue-green replication has been stopped for "${manager.name()} resources."`);
      });
    }));
  }

  /**
   * @param {Number} percentage
   * @param {Boolean} skipDNSActions
   * @returns {Promise}
   */
  publish(percentage, skipDNSActions) {
    let PublishStrategyProto = _AbstractStrategy.AbstractStrategy.chooseStrategyProto(percentage);
    let publisherInstance = new PublishStrategyProto(this, skipDNSActions);

    return publisherInstance.publish(percentage).then(() => {
      return publisherInstance.config();
    });
  }

  /**
   * @param {Number} percentage
   * @param {Boolean} skipDNSActions
   * @param {Object} config
   * @returns {Promise}
   */
  update(percentage, skipDNSActions, config) {
    let PublishStrategyProto = _AbstractStrategy.AbstractStrategy.chooseStrategyProto(percentage);
    let publisherInstance = new PublishStrategyProto(this, skipDNSActions);

    publisherInstance.updateConfig(config);

    return publisherInstance.update(percentage).then(() => {
      return publisherInstance.config();
    });
  }

  /**
   * @param {Object} resources
   * @returns {Promise}
   */
  checkStatus(resources) {
    let statusResult = {};

    return Promise.all(this.replicationManagers.map(replicationManger => {
      return replicationManger.checkStatus(resources[replicationManger.name()]).then(status => {
        if (status !== null) {
          statusResult[replicationManger.name()] = status;
        }
      });
    })).then(() => statusResult);
  }

  /**
   * @returns {String}
   */
  static get BLUE_GREEN_MS_IDENTIFIER() {
    return 'deep-blue-green';
  }
}
exports.Instance = Instance;