@kumologica/sdk 3.0.0

package/src/app/lib/aws/index.js

@@ -0,0 +1,970 @@
+const fs = require('fs-extra');
+const path = require('path');
+const AWS = require('aws-sdk');
+const AdmZip = require('adm-zip');
+const util = require('util');
+const exec = util.promisify(require('child_process').exec);
+const rimraf = require('rimraf');
+const { codegen } = require('@kumologica/builder');
+const AWSCFTemplate = require('./cf');
+const CAAWSCloudWatch = require('./ca-cloudwatch-api');
+const CAAWSIot = require('./ca-iot-api');
+const CAS3 = require('./ca-s3-api');
+const CASNS = require('./ca-sns-api');
+const CASQS = require('./ca-sqs-api');
+const CAAWSApiGateway = require('./ca-apigw-api');
+const CADynamoDb = require('./ca-dynamodb-api');
+const CAElb = require('./ca-elb-api');
+const CAEvents = require('./ca-events-api');
+const CAAlexa = require('./ca-alexa-api');
+const CACodeCommit = require('./ca-codecommit-api');
+const AWSProfile = require('./aws-profile');
+const KLIAM = require('./kl-iam-api');
+const { openFileOnEditor } = require('../utils/editor');
+
+/**
+ * sample events:
+ * https://docs.aws.amazon.com/lambda/latest/dg/lambda-services.html
+ */
+class AWSDeployer {
+  constructor(terminal) {
+    this.term = terminal;
+    this.awsProfile = new AWSProfile();
+
+    AWS.config.apiVersions = {
+      cloudformation: '2010-05-15',
+    };
+  }
+
+  async initAWS(profile) {
+    AWS.config.credentials = new AWS.SharedIniFileCredentials({profile: profile});
+    AWS.config.profile = profile;  // this is not AWS property
+
+    const region = await this.awsProfile.getRegion(profile);
+    AWS.config.update({region: region});
+ 
+    this.cw = false;
+
+    this.iot = new CAAWSIot(this.log.bind(this));
+    this.apiGateway = new CAAWSApiGateway(this.log.bind(this));
+    this.dynamoDb = new CADynamoDb(this.log.bind(this));
+    this.cf = new AWS.CloudFormation();
+    this.s3 = new CAS3(this.log.bind(this));
+    this.sns = new CASNS(this.log.bind(this));
+    this.sqs = new CASQS(this.log.bind(this));
+    this.lambdaApi = new AWS.Lambda();
+    this.cfTemplate = new AWSCFTemplate();
+    this.cwLogs = new CAAWSCloudWatch(this.logCloud.bind(this));
+    this.cwevents = new AWS.CloudWatchEvents();
+    this.cognito = new AWS.CognitoIdentityServiceProvider();
+    this.elb = new CAElb(this.log.bind(this));
+    this.events = new CAEvents(this.log.bind(this));
+    this.alexa = new CAAlexa(this.log.bind(this));
+    this.codecommit = new CACodeCommit(this.log.bind(this));
+    this.iam = new KLIAM(this.log.bind(this));
+  }
+
+  chalk(c, t) {
+    if (c == 'whiteBright') {
+      c = '#FFFFFF';
+    } else if (c == 'redBright') {
+      c = '#FF0000';
+    } else if (c == 'yellowBright') {
+      c = '#FFFF00';
+    } else if (c == 'greenBright') {
+      c = '#00FF00';
+    }
+
+    return `<span style="color: ${c}">${t}</span>`;
+  }
+
+  log(text, calog = true) {
+    var t = text;
+
+    if (calog && this.chalk) {
+     t = `Kumologica: ${this.chalk('#F5DEB3', text)}`;
+    }
+
+    if (this.term) {
+      this.term.emit('terminal-output', t);
+    }
+  }
+
+  logCloud(text) {
+    if (this.term) {
+      this.term.emit('terminal-cloud', `${text}`);
+    }
+  }
+
+  sanitizeLambdaName(name) {
+
+    return name
+      .replace('.json', '')
+      .trim()
+      .replace(/^@/, '')
+      .replace(/[^a-zA-Z0-9-]/g, '-')
+      .substr(0, 140);
+  }
+
+  prepare(projectDir, flowFileName, originaLambdaName) {
+    const deployDir = projectDir + '/deploy';
+    
+    const flowName = flowFileName.replace('.json', '');
+
+    // setup deployment directory
+    fs.ensureDirSync(deployDir);
+    fs.emptyDirSync(deployDir);
+    fs.ensureDirSync(deployDir + '/node_modules');
+
+    // copy project files
+    codegen.generateProjectCode(
+      deployDir,
+      flowFileName
+    );
+
+    this.processPackageJson(projectDir, deployDir);
+
+    const zipFileName = `${flowName}/lambda${Date.now()}.zip`;
+    const lambdaName = this.sanitizeLambdaName(originaLambdaName);
+
+    const functionName = `kumologica-${lambdaName}-lambda`;
+    const stackName = `kumologica-${lambdaName}-stack`;
+    const roleName = `kumologica-${lambdaName}-role`;
+    return {
+      deployDir,
+      flowName,
+      zipFileName,
+      functionName,
+      stackName,
+      roleName,
+      lambdaName,
+    };
+  }
+
+  processPackageJson(projectDir, deployDir) {
+    
+    const pckg = this.loadJsonFile(path.join(projectDir, 'package.json'));
+
+    // ensure dependencies contain runtime
+    if (!pckg.dependencies["@kumologica/runtime"]) {
+      pckg.dependencies["@kumologica/runtime"] = `^${pckg.version.substr(0, 1)}`;
+      this.createFile(deployDir, 'package.json', JSON.stringify(pckg));
+
+    } else {
+      fs.copySync(
+        path.join(projectDir, 'package.json'),
+        path.join(deployDir, 'package.json')
+      );  
+    }
+
+    if (pckg.files) {
+      pckg.files.forEach(f => {
+        
+        if (!["node_modules/**/*", "lambda.js" ].includes(f)) {
+          fs.copySync(
+            path.join(projectDir, f),
+            path.join(deployDir, f)
+          );
+        }
+      });
+    }
+  }
+
+  /**
+   *
+   * @param {String} flowName
+   */
+  async prepareS3Bucket(flowName) {
+    let bucketName = undefined;
+
+    // find bucket
+    const buckets = await this.s3.getBuckets();
+
+    if (buckets) {
+      bucketName = buckets.find(function (b) {
+        return b.id.startsWith('kumologica-designer-deploy');
+      });
+    }
+    // if not found create bucket
+
+    if (!bucketName) {
+      const ts = Date.now();
+      let uniqueId = Math.random().toString(36).substring(2) + ts.toString(36);
+      bucketName = `kumologica-designer-deploy-${uniqueId}-${ts}`;
+      await this.s3.createS3Bucket(bucketName);
+    } else {
+      bucketName = bucketName.id;
+      await this.s3.deleteS3Objects(bucketName, `${flowName}/`);
+    }
+
+    return bucketName;
+  }
+  /*
+   * Main function orchestrating build and deployment of lambda to aws.
+   */
+  async deploy(projectInfo, params, profile) {
+    if (!profile) {
+      throw new Error(
+        'AWS profile has not been provided, unable to deploy kumologica flow into AWS. Select correct profile from list.'
+      );
+    }
+
+    const deploymentStart = Date.now();
+    var lambdaArn;
+
+    this.log(`Deployment to AWS Started:`);
+    this.log(`  ${this.chalk('#F5DEB3', 'flow:')}              ${this.chalk('whiteBright', projectInfo.projectFlowName)}`, false);
+    this.log(`  ${this.chalk('#F5DEB3', 'working directory:')} ${this.chalk('whiteBright', projectInfo.projectDir + "/deploy")}`, false);
+    this.log(`  ${this.chalk('#F5DEB3', 'lambda parameters:')} ${this.chalk('whiteBright', JSON.stringify(params))}`, false);
+    this.log(`  ${this.chalk('#F5DEB3', 'AWS profile:')}       ${this.chalk('whiteBright', AWS.config.profile)}`, false);
+    
+    await this.initAWS(profile);
+    this.log(`  ${this.chalk('#F5DEB3', 'AWS region:')}        ${this.chalk('whiteBright', AWS.config.region)}`, false);
+    this.log('', false);
+
+    const settings = this.prepare(
+      projectInfo.projectDir,
+      projectInfo.projectFlowName,
+      params.functionName
+    );
+
+    let flowListeners = null;
+
+    try {
+      settings.deploymentBucketName = await this.prepareS3Bucket(
+        settings.flowName
+      );
+      await this.buildLambda(settings);
+
+      const nodes = this.loadJsonFile(
+        path.join(projectInfo.projectDir, projectInfo.projectFlowName)
+      );
+
+      flowListeners = this.processFlow(nodes);
+
+      const stackDetails = await this.executeStack(
+        settings,
+        params,
+        deploymentStart,
+        nodes
+      );
+      lambdaArn = stackDetails.Stacks[0].Outputs[0].OutputValue;
+
+      this.log(`${this.chalk('greenBright', 'Deployment successful.')}`);
+      this.log(
+        `  ${this.chalk('#F5DEB3', 'StackId:')}   ${this.chalk('whiteBright', 
+          stackDetails.Stacks[0].StackId
+        )}`,
+        false
+      );
+      this.log(`  ${this.chalk('#F5DEB3', 'LambdaArn:')} ${this.chalk('whiteBright',lambdaArn)}`, false);
+      this.log('', false);
+
+      // this call to be moved out to the terminals panel
+      /*if (this.cw == false) {
+        this.cwLogs.startCWLogs(settings.functionName, AWS.config.region);
+        this.cw = true;
+      }*/
+    } catch (error) {
+      this.log(`${this.chalk('redBright', 'Deployment failed.')}`);
+      this.log(`  ${this.chalk('redBright', error)}`);
+    } finally {
+      //this.s3.deleteS3Bucket(deploymentBucketName);
+    }
+
+    let response = {};
+    if (lambdaArn) {
+      try {
+        response = await this.runTriggers(params, settings, lambdaArn);
+        if (response) {
+          const url = `https://${response.apiId}.execute-api.${AWS.config.region}.amazonaws.com/${response.stage}`;
+          this.printSignature(url, flowListeners);
+        }
+      } catch (error) {
+        this.log(`${this.chalk('redBright', 'Trigger creation failed.')}`);
+        this.log(`  ${this.chalk('redBright', error)}`);
+      }
+    }
+    return response;
+  }
+
+  printSignature(url, s) {
+    this.log(' ')
+    if (s.api && s.api.length > 0) {
+      this.log('API Gateway:');
+      s.api.forEach(a => this.log(`  ${('    ' + a.verb.toUpperCase()).slice(-6)}  ${url}${a.url}`), this);
+      this.log('');
+    }
+
+    if (s.dynamodb && s.dynamodb.length > 0) {
+      this.log('DynamoDB Streams:');
+      s.dynamodb.forEach(a => this.log(` ${a.startingPosition} ${a.stream}`), this);
+      this.log('');
+    }
+
+    if (s.s3 && s.s3.length > 0) {
+      this.log('S3:');
+      s.s3.forEach(a => this.log(` ${a.eventType} ${a.bucket}`), this);
+      this.log('');
+    }
+    
+    if (s.sns && s.sns.length > 0) {
+      this.log('SNS Topics:');
+      s.sns.forEach(a => this.log(` ${a.topic}`), this);
+      this.log('');
+    }
+  
+    if (s.iot && s.iot.length > 0) {
+      this.log('IOT:');
+      s.iot.forEach(a => this.log(` ${a.rule} ${a.query}`), this);
+      this.log('');
+    }
+
+    if (s.alb && s.alb.length > 0) {
+      this.log('Application Load Balancer:');
+      s.alb.forEach(a => this.log(` ${a.alb} ${a.listener}`), this);
+      this.log('');
+    }
+
+    if (s.sqs && s.sqs.length > 0) {
+      this.log('SQS URL:');
+      s.sqs.forEach(a => this.log(` ${a.queueUrl}`), this);
+      this.log('');
+    }
+
+    if (s.alexa && s.alexa.length > 0) {
+      this.log('Alexa Skills:');
+      s.alexa.forEach(a => this.log(` ${a.skillId}`), this);
+      this.log('');
+    }
+
+    if (s.kinesis && s.kinesis.length > 0) {
+      this.log('Kinesis:');
+      s.kinesis.forEach(a => this.log(` ${a.startingPosition} ${a.stream}`), this);
+      this.log('');
+    }
+
+    if (s.cwevents && s.cwevents.length > 0) {
+      this.log('Cloud Watch Events Rules:');
+      s.cwevents.forEach(a => this.log(` ${a.rule}`), this);
+      this.log('');
+    }
+  }
+
+  processFlow(flow) {
+
+    const listener = flow.filter(i => i.type == "EventListener");
+    if (!listener || listener.length == 0) {
+      throw new Error("Flow has no EventListener defined, unable to deploy to aws account.");
+    } 
+  
+    const nonAWSlisteners = flow.filter(i => i.type == "EventListener" && i.provider != "aws");
+    if (nonAWSlisteners && nonAWSlisteners.length > 0) {
+      const names = nonAWSlisteners.map(l => l.name).concat();
+      this.log(`${this.chalk('yellowBright', `Warning (Invalid provider): Kumohub API Gateway Event Listeners found ${names} for AWS Account deployment.`)}`);
+    }
+
+    if (nonAWSlisteners && nonAWSlisteners.length >= 0 && listener.length == nonAWSlisteners.length) {
+      throw new Error("Flow has no EventListener for AWS defined, unable to deploy to aws account.");
+    } 
+
+    // api
+    const apis = listener.filter(i => i.eventSource == 'api' && i.provider == 'aws')
+                          .map(a => {return {url: a.apiUrl, verb: a.apiMethod}});
+  
+    // validate if aws nodes got explicit credentials only
+    /*const awsNodes = flow.filter(i => ['Rekognition', 'S3', 'SQS', 'Cloudwatch', 'Dynamo DB', 'SNS', 'SES', 'SSM'].includes(i.type));
+    if (awsNodes && awsNodes.length > 0) {
+      awsNodes.forEach(n => {
+        if (!n.securitytype || n.securitytype != 'Credentials') {
+          throw new Error (`AWS Node ${n.name} must have explicit credentials set. Open this node and choose Credentials option.`);
+        }
+      });
+    }*/
+  
+    const dynamodb = listener.filter(i => i.eventSource == 'dynamodb')
+                             .map(a => {return {stream: a.stream, startingPosition: a.startingPosition}});
+    const s3 = listener.filter(i => i.eventSource == 's3')
+                             .map(a => {return {bucket: a.bucket, eventType: a.eventType}});
+    const sns = listener.filter(i => i.eventSource == 'sns')
+                             .map(a => {return {topic: a.topic}});
+    const iot = listener.filter(i => i.eventSource == 'iot')
+                             .map(a => {return {rule: a.rule, query: a.query}});
+    const alb = listener.filter(i => i.eventSource == 'alb')
+                             .map(a => {return {alb: a.alb, listener: a.listener}});
+    const sqs = listener.filter(i => i.eventSource == 'sqs')
+                             .map(a => {return {queueUrl: a.stream}});
+    const alexa = listener.filter(i => i.eventSource == 'alexa')
+                             .map(a => {return {skillId: a.skillId}});                        
+    const kinesis = listener.filter(i => i.eventSource == 'kinesis')
+                             .map(a => {return {stream: a.stream, startingPosition: a.startingPosition}});
+    const cwevents = listener.filter(i => i.eventSource == 'cwevents')
+                             .map(a => {return {rule: a.rule}});
+
+    return {
+      api: apis,
+      dynamodb: dynamodb,
+      s3: s3,
+      sns: sns,
+      iot: iot,
+      alb: alb,
+      sqs: sqs,
+      alexa: alexa,
+      kinesis: kinesis,
+      cwevents: cwevents
+ //     cron: listener.filter(l => l.eventSource == 'cwevents')
+ //                   .map(l => {return {type: "cron", expression: l.cronexpression, id: l.id}})
+    };  
+  }
+
+  async generateScript(projectInfo, params, profile) {
+    if (!profile) {
+      throw new Error(
+        'AWS profile has not been provided, unable to generate cloud formation script. Select correct profile from list.'
+      );
+    }
+
+    try {
+      this.log('Generating cloud formation script');
+      this.log(
+        `  ${this.chalk('#F5DEB3', 'AWS profile:')}       ${this.chalk('whiteBright', AWS.config.profile)}`,
+        false
+      );
+
+      await this.initAWS(profile);
+      
+      this.log(`  ${this.chalk('#F5DEB3', 'AWS region:')}        ${this.chalk('whiteBright', AWS.config.region)}`, false);
+      
+      const settings = this.prepare(projectInfo.projectDir, projectInfo.projectFlowName, params.functionName, params.description);
+      const nodes = await this.prepareNodes(this.loadJsonFile(path.join(projectInfo.projectDir, projectInfo.projectFlowName)));
+      
+      settings.deploymentBucketName = await this.prepareS3Bucket(
+        settings.flowName
+      );
+      
+      const lambdaCfTemplate = JSON.stringify(
+        this.cfTemplate.createCfTemplate(
+          params,
+          settings,
+          nodes,
+          AWS.config.region
+        ),
+        null,
+        2
+      );
+
+      this.createFile(
+        settings.deployDir,
+        `cf-${projectInfo.projectFlowName}`,
+        lambdaCfTemplate
+      );
+
+      const scriptFileName = path.join(
+        settings.deployDir,
+        `cf-${projectInfo.projectFlowName}`
+      );
+      this.log(`Cloud formation script created: ${scriptFileName}`);
+      openFileOnEditor(scriptFileName);
+    } catch (Error) {
+      this.log(`${this.chalk('redBright', 'Script creation failed.')}`);
+      this.log(`  ${this.chalk('redBright', Error)}`);
+      throw Error;
+    }
+  }
+
+  
+  /*
+   * Builds lambda and zips all sources.
+   */
+  async buildLambda(settings) {
+    this.log('Building lambda...');
+
+    const npmCmd = `npm install --production --prefix "${settings.deployDir}"`;
+    const response = await exec(npmCmd, { cwd: settings.deployDir });
+
+    if (response) {
+      this.log('', false);
+      const lines = response.stdout.split('\n');
+      for (var i = 0; i < lines.length; i++) {
+        if (lines[i]) {
+          this.log(lines[i], false);
+        }
+      }
+      this.log('', false);
+    }
+
+    this.log('Excluding optional dependencies...');
+    // Remove aws-sdk library as it is provided by aws nodejs runtime.
+    // Reducing the resulting lambda zip file by more than 70%
+    rimraf.sync(path.join(settings.deployDir, 'node_modules', 'aws-sdk'));
+
+    this.log('Zipping lambda...');
+    const zip = new AdmZip();
+    zip.addLocalFolder(settings.deployDir);
+    zip.writeZip(path.join(settings.deployDir, settings.zipFileName));
+  }
+
+  /*
+   * Uploads lambda zip file to s3 bucket, creates cloud formation template for lambda
+   * and executes create or update stack.
+   * Returns stack id
+   */
+  async executeStack(settings, params, deploymentStartTimestamp, nodes) {
+    this.log(`Uploading zip file to bucket...`);
+    var body = fs.createReadStream(
+      path.join(settings.deployDir, settings.zipFileName)
+    );
+
+    await this.s3.upload({
+      Bucket: settings.deploymentBucketName,
+      Key: settings.zipFileName,
+      Body: body,
+    });
+
+    params = await this.prepareParams(params);
+    nodes = await this.prepareNodes(nodes);
+
+    const lambdaCfTemplate = this.cfTemplate.createCfTemplate(
+      params,
+      settings,
+      nodes,
+      AWS.config.region
+    );
+
+    const stackParams = {
+      StackName: settings.stackName,
+      Capabilities: ['CAPABILITY_NAMED_IAM'],
+      TemplateBody: JSON.stringify(lambdaCfTemplate),
+    };
+
+    this.log('Starting cloudformation stack...');
+
+    let stack = {};
+    try {
+      stack = await this.cf.createStack(stackParams).promise();
+      this.log('Waiting for stack create complete...');
+      await this.cf
+        .waitFor('stackCreateComplete', { StackName: stackParams.StackName })
+        .promise();
+    } catch (error) {
+      if (error.code == 'AlreadyExistsException') {
+        stack = await this.cf.updateStack(stackParams).promise();
+        this.log('Waiting for stack update complete...');
+
+        try {
+          await this.cf
+            .waitFor('stackUpdateComplete', {
+              StackName: stackParams.StackName,
+            })
+            .promise();
+        } catch (error) {
+          await this.describeStackEvents(
+            stackParams.StackName,
+            deploymentStartTimestamp
+          );
+          throw Error(error);
+        }
+      } else {
+        await this.describeStackEvents(
+          stackParams.StackName,
+          deploymentStartTimestamp
+        );
+        throw Error(error);
+      }
+    }
+
+    return this.describeStack(stackParams.StackName);
+  }
+
+  /**
+   * Function links additional details for parameters that are not needed
+   * in ui but are required by cloud formation
+   *
+   * @param {*} params
+   */
+  async prepareParams(params) {
+    for (var i = 0; i < params.events.length; i++) {
+      if (params.events[i].source === 'sqs') {
+        if (!params.events[i].stream) {
+          throw Error(`Missing Trigger Parameter: SQS Queue Url.`);
+        }
+        params.events[i].stream = await this.sqs.getQueueArn(
+          params.events[i].stream
+        );
+      } else if (params.events[i].source === 'codecommit') {
+        if (!params.events[i].repository) {
+          throw Error(`Missing Trigger Parameter: CodeCommit Repository.`);
+        }
+        const repository = await this.codecommit.getRepository(
+          params.events[i].repository
+        );
+        params.events[i].repositoryArn = repository.Arn;
+        params.events[i].account = repository.accountId;
+      }
+    }
+    return params;
+  }
+
+  async prepareNodes(nodes) {
+    for (var i = 0; i < nodes.length; i++) {
+      if (nodes[i].type === 'SQS') {
+        if (!nodes[i].QueueUrl) {
+          throw Error(`Missing Node Parameter: SQS Queue Url.`);
+        }
+        nodes[i].QueueArn = await this.sqs.getQueueArn(nodes[i].QueueUrl);
+      }
+    }
+    return nodes;
+  }
+
+  async runTriggers(params, settings, lambdaArn) {
+    let response = {};
+
+    if (params.events) {
+      this.log('Adding flow triggers ...');
+
+      for (var i = 0; i < params.events.length; i++) {
+        if (params.events[i].source === 's3') {
+          await this.addS3Event(
+            params.events[i],
+            settings.functionName,
+            lambdaArn
+          );
+        } else if (params.events[i].source === 'sns') {
+          await this.addSNSEvent(
+            params.events[i],
+            settings.functionName,
+            lambdaArn
+          );
+        } else if (params.events[i].source === 'cwevents') {
+          await this.addCWEvent(
+            params.events[i],
+            settings.functionName,
+            lambdaArn
+          );
+        } else if (params.events[i].source === 'cwlogs') {
+          await this.addCWLogsEvent(
+            params.events[i],
+            settings.functionName,
+            lambdaArn
+          );
+        } else if (params.events[i].source === 'cognito') {
+          await this.addCognitoEvent(
+            params.events[i],
+            settings.functionName,
+            lambdaArn
+          );
+        } else if (params.events[i].source === 'alexa') {
+          await this.addAlexaEvent(
+            params.events[i],
+            settings.functionName,
+            lambdaArn
+          );
+        } else if (params.events[i].source === 'codecommit') {
+          await this.addCodeCommitEvent(
+            params.events[i],
+            settings.functionName,
+            lambdaArn
+          );
+        } else if (params.events[i].source === 'iot') {
+          var rule = await this.iot.addTrigger(
+            params.events[i],
+            settings.functionName,
+            lambdaArn
+          );
+          if (rule) {
+            await this.addLambdaPermission(
+              'iot.amazonaws.com',
+              settings.functionName,
+              null,
+              rule.ruleArn
+            );
+          }
+        } else if (params.events[i].source === 'api') {
+          const newApiId = await this.apiGateway.addTrigger(
+            params.events[i],
+            settings.functionName,
+            lambdaArn
+          );
+         
+          response.apiId = newApiId? newApiId: params.events[i].api;
+          response.stage = params.events[i].stage;
+          
+          //arn:aws:lambda:ap-southeast-2:640233474616:function:kumologica-aws-inbound-test-flow-lambda
+          const lambdaArnParts = lambdaArn.split(':');
+          const apiArn = `arn:aws:execute-api:${lambdaArnParts[3]}:${lambdaArnParts[4]}:${params.events[i].api}/*/*/{proxy+}`;
+          await this.addLambdaPermission(
+            'apigateway.amazonaws.com',
+            settings.functionName,
+            null,
+            apiArn
+          );
+        }
+      }
+      this.log(`${this.chalk('greenBright', 'All triggers added successfully:')}`);
+    }
+    return response;
+  }
+
+  async describeStack(stackName) {
+    return this.cf.describeStacks({ StackName: stackName }).promise();
+  }
+
+  /*
+   * Returns events created by cloud formation for current run.
+   */
+  async describeStackEvents(stackName, deploymentStartTimestamp) {
+    this.log('Calling describe stack events...');
+
+    const events = await this.cf
+      .describeStackEvents({ StackName: stackName })
+      .promise();
+    if (!events || events == undefined) {
+      return;
+    }
+
+    var deploymentEvents = events.StackEvents.filter(
+      (event) => event.Timestamp > deploymentStartTimestamp
+    ).sort((a, b) => a.Timestamp - b.Timestamp);
+    if (deploymentEvents == undefined || deploymentEvents.length == 0) {
+      return;
+    }
+
+    const formatStatus = function (status, chalk) {
+      if (['CREATE_COMPLETE', 'UPDATE_COMPLETE'].includes(status)) {
+        return chalk('greenBright', status);
+      } else if (status.endsWith('_FAILED') || status.includes('ROLLBACK')) {
+        return chalk('redBright', status);
+      } else {
+        return status;
+      }
+    };
+
+    this.log('', false);
+    for (var i = 0; i < deploymentEvents.length; i++) {
+      this.log(
+        `${deploymentEvents[i].Timestamp.toLocaleTimeString()} - ${formatStatus(
+          deploymentEvents[i].ResourceStatus
+        , this.chalk.bind(this))} - ${deploymentEvents[i].ResourceType || ''} - ${
+          deploymentEvents[i].ResourceStatusReason || ''
+        }`,
+        false
+      );
+    }
+    this.log('', false);
+  }
+
+  loadJsonFile(flowFileName) {
+    return JSON.parse(fs.readFileSync(flowFileName));
+  }
+
+  createFile(baseDir, fileName, content) {
+    fs.outputFileSync(path.join(baseDir, fileName), content, 'utf-8');
+  }
+
+  async addLambdaPermission(
+    principal,
+    lambdaName,
+    sourceAccount,
+    sourceArn,
+    eventSourceToken
+  ) {
+    var request = {
+      Action: 'lambda:InvokeFunction',
+      FunctionName: lambdaName,
+      Principal: principal,
+      SourceAccount: sourceAccount,
+      SourceArn: sourceArn,
+      EventSourceToken: eventSourceToken,
+      StatementId: `${lambdaName}-${Date.now()}`,
+    };
+
+    // wait for response, the subsequent calls require permissions to be present.
+    await this.lambdaApi.addPermission(request).promise();
+  }
+
+  async addS3Event(event, lambdaName, lambdaArn) {
+    if (!event.bucket) {
+      throw Error(`Missing Trigger Parameter: Bucket Name.`);
+    }
+
+    this.log(
+      `Setting lambda execution permissions for bucket ${event.bucket} ...`
+    );
+    await this.addLambdaPermission(
+      's3.amazonaws.com',
+      lambdaName,
+      event.sourceAccount,
+      `arn:aws:s3:::${event.bucket}`
+    );
+
+    await this.s3.bucketNotificationConfiguration(
+      lambdaArn,
+      event.bucket,
+      event.eventType,
+      event.prefix,
+      event.suffix
+    );
+  }
+
+  async addAlexaEvent(event, lambdaName, lambdaArn) {
+    this.log(`Setting  configuration for alexa skill id ${event.skillID} ...`);
+    await this.addLambdaPermission(
+      'alexa-appkit.amazon.com',
+      lambdaName,
+      null,
+      null,
+      event.skillID
+    );
+  }
+
+  async addCodeCommitEvent(event, lambdaName, lambdaArn) {
+    this.log(
+      `Setting configuration for code commit repository ${event.repository} ...`
+    );
+
+    await this.addLambdaPermission(
+      'codecommit.amazon.com',
+      lambdaName,
+      event.account,
+      event.repositoryArn
+    );
+
+    this.log('Adding permissions for lambda to call codecommit.');
+    await this.codecommit.addLambdaPermissions(event, lambdaArn);
+  }
+
+  async addSNSEvent(event, lambdaName, lambdaArn) {
+    await this.addLambdaPermission(
+      'sns.amazonaws.com',
+      lambdaName,
+      null,
+      event.topic
+    );
+
+    this.log(`Setting notification configuration for topic ${event.topic} ...`);
+    await this.sns.subscribe(event.topic, lambdaArn);
+  }
+
+  async addCWEvent(event, lambdaName, lambdaArn) {
+    await this.addLambdaPermission(
+      'events.amazonaws.com',
+      lambdaName,
+      null,
+      event.rule
+    );
+
+    const ruleName = event.rule.split('rule/').pop();
+
+    this.log(
+      `Setting notification configuration for cloudwatch event ${ruleName} ...`
+    );
+
+    var params = {
+      Rule: ruleName,
+      Targets: [
+        {
+          Arn: lambdaArn,
+          Id: `${lambdaName}`,
+        },
+      ],
+    };
+
+    await this.cwevents.putTargets(params).promise();
+  }
+
+  /**
+   * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CloudWatchLogs.html#putSubscriptionFilter-property
+   *
+   * @param {*} event
+   * @param {*} lambdaName
+   * @param {*} lambdaArn
+   */
+  async addCWLogsEvent(event, lambdaName, lambdaArn) {
+    //await this.addLambdaPermission("events.amazonaws.com",
+    //  lambdaName, null, event.rule);
+
+    /*this.log(`Setting notification configuration for cloudwatch event ${ruleName} ...`);
+    var params = {
+      destinationArn: 'STRING_VALUE', // required 
+      filterName: 'STRING_VALUE', // required 
+      filterPattern: 'STRING_VALUE', // required 
+      logGroupName: 'STRING_VALUE', // required 
+      distribution: Random | ByLogStream,
+      roleArn: 'STRING_VALUE'
+    };*/
+    await this.cwLogs.putSubscriptionFilter(params).promise();
+  }
+
+  async addCognitoEvent(event, lambdaName, lambdaArn) {
+    await this.addLambdaPermission(
+      'cognito-idp.amazonaws.com',
+      lambdaName,
+      null,
+      event.identityPool
+    );
+
+    const ruleName = event.rule.split('rule/').pop();
+
+    // TODO: add cognito implementation
+    //this.log(`Setting notification configuration for cloudwatch event ${ruleName} ...`);
+    var params = {};
+
+    await this.cognito.updateUserPool(params).promise();
+  }
+
+  async listServices(type, profile) {
+    if (!profile) {
+      throw new Error(
+        `AWS profile has not been provided, unable to return list of ${type}. Select correct profile from list.`
+      );
+    }
+
+    await this.initAWS(profile);
+    
+    let res = null;
+    switch (type) {
+      case 'api':
+        res = await this.apiGateway.getApiGateways();
+        break;
+      case 's3':
+        res = await this.s3.getBuckets();
+        break;
+      case 'sns':
+        res = await this.sns.getTopics();
+        break;
+      case 'sqs':
+        res = await this.sqs.getQueues();
+        break;
+      case 'dynamodb':
+        res = await this.dynamoDb.listStreams();
+        break;
+      case 'cwlogs':
+        res = await this.cwLogs.listLogGroups();
+        break;
+      case 'alb':
+        res = await this.elb.listElbs();
+        break;
+      case 'cwevents':
+        res = await this.events.listRules();
+        break;
+      case 'iot':
+        res = await this.iot.listTopicRules();
+        break;
+      case 'alexa':
+        res = await this.alexa.listSkills();
+        break;
+      case 'codecommit':
+        res = await this.codecommit.listRepositories();
+        break;
+      case 'iamroles':
+        res = await this.iam.listRoles();
+        break;
+      default:
+        res = [];
+    }
+    return res;
+  }
+}
+
+module.exports = AWSDeployer;