deep-package-manager/lib.compiled/Provisioning/ResourceTagging/Driver/LambdaDriver.js

DEEP Package Manager

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

'use strict';

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

var _deepCore = require('deep-core');

var _deepCore2 = _interopRequireDefault(_deepCore);

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

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

var _Tagging = require('../Tagging');

var _AwsRequestExtend = require('../../../Helpers/AwsRequestExtend');

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

class LambdaDriver extends _AbstractDriver.AbstractDriver {
  /**
   * @param {*} args
   */
  constructor(...args) {
    super(...args);

    this._lambda = this.provisioning.lambda;
  }

  /**
   * @param {Function} cb
   */
  tag(cb) {
    let lambdasArns = this.resourcesArns();
    let tags = this.tags;

    if (lambdasArns.length === 0) {
      cb();
      return;
    }

    let lambdaChunks = this.arrayChunk(lambdasArns, LambdaDriver.TAG_CHUNK_SIZE);

    this._tagChunks(lambdaChunks, tags).then(() => {
      console.debug(`Lambda resources have been successfully tagged`);

      cb();
    }).catch(e => {
      console.warn(`Error while tagging lambda resources: ${e.toString()}`);
    });
  }

  /**
   * @param {(String[])[]} chunks
   * @param {Object} tags
   * @returns {Promise}
   * @private
   */
  _tagChunks(chunks, tags) {
    if (chunks.length === 0) {
      return Promise.resolve();
    }

    let chunksClone = [].concat(chunks);
    let workingChunk = chunksClone.shift();

    let promises = workingChunk.map(lambdaArn => {
      return _AwsRequestExtend.AwsRequestExtend.retryable(this._lambda.tagResource({
        Resource: lambdaArn,
        Tags: tags
      })).promise().catch(e => {
        console.warn(`Error while tagging "${lambdaArn}": ${e.toString()}`);

        return Promise.resolve();
      });
    });

    return Promise.all(promises).then(() => {
      return this._tagChunks(chunksClone, tags);
    });
  }

  /**
   * @returns {String}
   */
  name() {
    return _deepCore2.default.AWS.Service.LAMBDA;
  }

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

  /**
   * @returns {String[]}
   */
  resourcesArns() {
    let lambdaArns = [];
    let lambdaService = this.provisioning.services.find(_LambdaService.LambdaService);
    let lambdasObj = lambdaService.config().names;

    for (let msName in lambdasObj) {
      if (!lambdasObj.hasOwnProperty(msName)) {
        continue;
      }

      for (let actionName in lambdasObj[msName]) {
        if (!lambdasObj[msName].hasOwnProperty(actionName)) {
          continue;
        }

        let lambdaArn = lambdaService._generateLambdaArn(lambdasObj[msName][actionName]);

        lambdaArns.push(lambdaArn);
      }
    }

    return lambdaArns;
  }

  /**
   * @returns {Number}
   */
  static get TAG_CHUNK_SIZE() {
    return 5;
  }

  /**
   * @returns {Number}
   */
  step() {
    return _Tagging.Tagging.POST_DEPLOY_STEP;
  }
}
exports.LambdaDriver = LambdaDriver;