deep-package-manager/lib.compiled/Provisioning/ListingDriver/AbstractTaggingDriver.js

DEEP Package Manager

/**
 * Created by CCristi on 4/24/17.
 */

'use strict';

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

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

var _awsSdk2 = _interopRequireDefault(_awsSdk);

var _AbstractDriver = require('./AbstractDriver');

var _AbstractService = require('../Service/AbstractService');

var _AbstractDriver2 = require('../ResourceTagging/Driver/AbstractDriver');

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

class AbstractTaggingDriver extends _AbstractDriver.AbstractDriver {
  /**
   * @param {Object[]} args
   */
  constructor(...args) {
    super(...args);

    this._taggingService = null;
  }

  /**
   * @returns {*}
   */
  get taggingService() {
    if (!this._taggingService) {
      this._taggingService = new _awsSdk2.default.ResourceGroupsTaggingAPI({
        region: this.region()
      });
    }

    return this._taggingService;
  }

  /**
   * @returns {String}
   */
  region() {
    return this.awsService.config.region;
  }

  /**
   * @returns {Promise}
   */
  listFilteredResources() {
    return this.listResources().then(resources => resources.filter(this._filterResource.bind(this)));
  }

  /**
   * @param {Object} resource
   * @returns {*}
   * @private
   */
  _filterResource(resource) {
    let resourceId = this._generateResourceIdFromTags(resource.Tags);

    return resourceId && this._matchResource(resourceId);
  }

  /**
   * @param {Object[]} tagsVector
   * @returns {String}
   * @private
   */
  _generateResourceIdFromTags(tagsVector) {
    let tags = tagsVector.reduce((tagsObj, tagItem) => {
      tagsObj[tagItem.Key] = tagItem.Value;

      return tagsObj;
    }, {});

    let envNameKey = _AbstractDriver2.AbstractDriver.ENVIRONMENT_NAME_KEY;
    let envIdKey = _AbstractDriver2.AbstractDriver.ENVIRONMENT_ID_KEY;
    let awsResourcePrefix = _AbstractService.AbstractService.AWS_RESOURCES_PREFIX;

    if (tags.hasOwnProperty(envNameKey) && tags.hasOwnProperty(envIdKey)) {
      return `${awsResourcePrefix}.${tags[envNameKey]}.resource.${tags[envIdKey]}`;
    }

    return null;
  }

  /**
   * @param {String} _token
   * @returns {Promise}
   */
  listResources(_token = null) {
    const payload = {
      TagsPerPage: this.constructor.DEFAULT_TAGS_PER_PAGE,
      ResourceTypeFilters: [].concat(this.resourceType()),
      TagFilters: []
    };

    if (_token) {
      payload.PaginationToken = _token;
    }

    return this.taggingService.getResources(payload).promise().then(response => {
      const resourcesList = response.ResourceTagMappingList;

      if (response.PaginationToken) {
        return this.listResources(response.PaginationToken).then(childResources => {
          return resourcesList.concat(childResources);
        });
      }

      return resourcesList;
    });
  }

  /**
   * @todo: inherit this method in implementations
   * @returns {String}
   */
  resourceType() {
    return '';
  }

  /**
   * @returns {Number}
   */
  static get DEFAULT_TAGS_PER_PAGE() {
    return 500;
  }
}
exports.AbstractTaggingDriver = AbstractTaggingDriver;