ecs task sample aws sdk

ecs_task.js

import AWS from 'aws-sdk'
import dotenv from 'dotenv'
import ConfigWriter from '../config_writer'
import ConfigReader from '../config_reader'

dotenv.config()

// https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html
// https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/ECS.html
class EcsTask {
  constructor(options={}){
    // { taskDefinition: ""core-web-fargate_web_stg:8" };
    this.options = options
    this.ecs  = new AWS.ECS();
  }

  createNewRevision(envVars) {
   console.log("this.options", this.options);
   
   this.getTaskDefinition((err, data)=> {
    if(err){
      console.log("error", err.stack);
      return
      
    }

    var taskDefinition = data['taskDefinition']
     var newTaskDefinition = this.prepareDefinition(taskDefinition, envVars)
     this.ecs.registerTaskDefinition(newTaskDefinition, (err, data) => {
       if(err)
         console.log(err);
      else
        console.log(data);
     })
   })
  }

  getTaskDefinition(callback){
    console.log("getDefinition this.options", this.options);
    this.ecs.describeTaskDefinition(this.options, (err, data) => {
      callback(err, data)
     })
  }

  registerTaskDefinition() {
    this.ecs.registerTaskDefinition(newTaskDefinition, (err, data) => {
      callback(err, data)
    })
  }

  loadEnv(callback) {
    console.log("this.options", this.options);
   
    this.getTaskDefinition((err, data)=> {
      if(err){
        callback(err, null)
      }

      var taskDefinition = data['taskDefinition']
      let containerDefinitions = taskDefinition['containerDefinitions']
      let environtments = containerDefinitions[0]['environment']
      if(callback != null)
        callback(false, environtments)
    })
  }

  loadAndSaveEnv(newFilename, format='json') {
    this.loadEnv((err, data) => {
      if(err)
        return console.log(err.stack);
    
      ConfigWriter.saveDataToFileWithFormat(data, newFilename, format)
    })
  }

  ignoreEcsTaskProperties() {
    return  ['taskDefinitionArn', 'revision', 'status', 'requiresAttributes', 'compatibilities']
  }

  prepareDefinition(taskDefinition, envVars=null){
    var newDefinition = JSON.parse(JSON.stringify(taskDefinition))

    const deleteKeys = this.ignoreEcsTaskProperties().forEach((item)=> {
      delete newDefinition[item]
    })

    if(envVars == null)
      return newDefinition

    if(typeof envVars == 'object')
      return this.mergeEnvVars(newDefinition, envVars)
  }

  mergeEnvVars(taskDefinition, envVars={}) {
    let containerDefinitions = taskDefinition['containerDefinitions']
    let environtments = containerDefinitions[0]['environment']  

    console.log("typeof envVarse ", typeof envVars);
    
    if(typeof envVars != 'object')
      return taskDefinition

    console.log("merge");

    containerDefinitions[0]['environment'] = EcsTask.mergeObject(environtments, envVars)
    return taskDefinition
  }

  /**
   * 
   * @param {array} existings 
   * @param {object} entries 
   */
  static mergeObject(existings, entries) {

    Object.keys(entries).forEach( (virtualKey)=> {
      // Negative keys mean search key to remove if exist otherwise ignore
      var value = entries[virtualKey]
      let isKeyRemove = virtualKey.startsWith("-")
      let key = isKeyRemove ? virtualKey.substring(1) : virtualKey

      var newItem = {
        name: key,
        value: value
      }

      var index = existings.findIndex( (elm) => {
        return  elm.name == key
      })
      
      if(index == -1) {
        if(!isKeyRemove)
          existings.push(newItem)
      }
      else {
        if(isKeyRemove){
          existings.splice(index, 1)
        }
        else{
          existings[index] = newItem
        }
      }
    })
    return existings
  }

  /**
   * 
   * @param {*} tasks: array of task definations per env
   * @param {*} subject: a yaml file config with env section or a hash
   * @param {*} env: production or staging environment
   */
  static createReservisions(tasks, subject, env) {
    tasks.forEach((task) => {
      let taskName = env + '-' + task
      console.log('Loading task env:' + taskName);
      
      const options =  { taskDefinition: taskName }
      // Can load the envs vars from local files yaml
  
      let newEnvVars = typeof subject == "string" ?  ConfigReader.loadYaml(subject, env) : subject[env]
      // console.log(newEnvVars);
  
      var ecsTask = new EcsTask(options)
      ecsTask.createNewRevision(newEnvVars)
    })
  }
}

export default EcsTask