ecs_helper 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e8be79974f9b2a283b5534324966c2d0911bf82fc10082e81099b453ddbf108
+  data.tar.gz: '04283f48874519795e2a9ccbf76974c7aaca9076be1baa3031d044736477d72b'
+SHA512:
+  metadata.gz: eaff219c5e0e59dd24c3645dca404a8df80a20bc5edf31947ab545970721223ee07dd8a57e4b49c93706dd0ed163173f33ca2a3f0c3dcab9e1e2c096f7afe891
+  data.tar.gz: bab7042458321e8118b121fdb2e05bf061d9cf669902a653021e68358ded2d1fc389ec0b6cc4f7b36dd442f5bdfa1a4ca266bbd8564b96c2a59b718688f31162

data/bin/ecs_helper

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'ecs_helper'
+
+helper = ECSHelper.new
+helper.run

data/lib/ecs_helper/client.rb

@@ -0,0 +1,57 @@
+require 'aws-sdk-ecs'
+require 'aws-sdk-ecr'
+
+class ECSHelper::Client
+  attr_accessor :ecs, :ecr
+  def initialize
+    @ecs = Aws::ECS::Client.new
+    @ecr = Aws::ECR::Client.new
+  end
+
+  # ECS
+  def task_definitions
+    @task_definitions ||= ecs.list_task_definitions.task_definition_arns
+  end
+
+  def clusters
+    @clusters ||= ecs.list_clusters.cluster_arns
+  end
+
+  def services(cluster)
+    @services ||= ecs.list_services(cluster: cluster).service_arns
+  end
+
+  def tasks(cluster, service)
+    arns = ecs.list_tasks(cluster: cluster, service_name: service).task_arns
+    ecs.describe_tasks({ tasks: arns, cluster: cluster }).tasks
+  end
+
+  def describe_service(cluster, service)
+    ecs.describe_services(cluster: cluster, services: [service]).services[0]
+  end
+
+  def describe_task_definition(task_definition)
+    ecs.describe_task_definition(task_definition: task_definition).task_definition
+  end
+
+  def register_task_definition(params = {})
+    ecs.register_task_definition(params).task_definition
+  end
+
+  def deregister_task_definition(params = {})
+    ecs.deregister_task_definition(params).task_definition
+  end
+
+  def update_service(params = {})
+    ecs.update_service(params)
+  end
+
+  # ECR
+  def repositories(params = {})
+    ecr.describe_repositories(params).repositories
+  end
+
+  def describe_images(params = {})
+    ecr.describe_images(params).image_details[0]
+  end
+end

data/lib/ecs_helper/cluster_helper.rb

@@ -0,0 +1,31 @@
+require 'aws-sdk-ecs'
+
+class ECSHelper::ClusterHelper
+  attr_accessor :helper, :client, :clusters, :options, :project, :environment, :current_cluster
+  def initialize(helper)
+    @helper = helper
+  end
+
+  def clusters
+    @clusters ||= helper.client.clusters
+  end
+
+  def current_cluster
+    @current_cluster ||= from_options || only_one || from_env || raise(StandardError.new("Cluster not detected"))
+  end
+
+  def from_options
+    value = helper.options[:cluster]
+    return nil unless value
+    return value if clusters.include?(value)
+    raise(StandardError.new("Cluster specified in cli not exists, clusters you have: #{clusters}")) unless clusters.find {|r| r == value}
+  end
+
+  def from_env
+    clusters.find {|c| c.include?(helper.project) && c.include?(helper.environment)}
+  end
+
+  def only_one
+    return clusters[0] if clusters.length == 1
+  end
+end

data/lib/ecs_helper/command/base.rb

@@ -0,0 +1,41 @@
+require 'optparse'
+require 'terrapin'
+require 'ecs_helper/logging'
+
+class ECSHelper::Command::Base
+  include ECSHelper::Logging
+  attr_accessor :type, :options, :helper, :client, :option_parser
+
+  def initialize(helper)
+    @client = helper.client
+    @helper = helper
+    @option_parser, @options = cmd_option_parser
+    @option_parser.parse!(into: @options)
+  end
+
+  def type
+    helper.type
+  end
+
+  def validate
+    required.each do |r|
+      value = options[r]
+      unless value
+        puts "'#{r}' required for command '#{command}'".light_white
+        puts option_parser.help
+        exit
+      end
+    end
+  end
+
+  private
+
+  def required
+    []
+  end
+
+  def processEqual(value)
+    value.start_with?('=') ? value[1..-1] : value
+  end
+end
+

data/lib/ecs_helper/command/build_and_push.rb

@@ -0,0 +1,87 @@
+require 'terrapin'
+
+class ECSHelper::Command::BuildAndPush < ECSHelper::Command::Base
+  # attr_accessor :type, :client, :project, :application, :version
+
+  def cmd_option_parser
+    options = {}
+    parser = ::OptionParser.new do |opts|
+      opts.banner = "Usage: ecs_helper build_and_push [options]]"
+      opts.on("-v", "--verbose", "Show debug information") { o[:verbose] = true }
+      opts.on("-i VALUE", "--image VALUE", "Set image name, will be used to detect ecr repo where to push image, for example web/nginx/toolbox (required)") { |c| options[:image] = processEqual(c) }
+      opts.on("-d VALUE", "--directory VALUE", "Set directory for dockerfile and context, default = './'") { |c| options[:directory] = processEqual(c) }
+      opts.on("-p VALUE", "--project VALUE", "Set project name, if not specified will look at ENV['PROJECT'], will be used to detect cluster") { |p| options[:project] = processEqual(p) }
+      opts.on("-a VALUE", "--application VALUE", "Set application name, if not specified will look at ENV['APPLICATION'], will be used to detect service and task definition") { |a| options[:application] = processEqual(a) }
+    end
+    [parser, options]
+  end
+
+  def required
+    [:image]
+  end
+
+  def run
+    log("Command", type)
+    log("Options", options)
+    log("Repository", repository)
+    log("Auth", auth)
+    log("Pull", pull)
+    log("Build", build)
+    log("Push", push)
+  end
+
+  def auth
+    auth_cmd = Terrapin::CommandLine.new("aws ecr get-login --no-include-email | sh")
+    auth_cmd.run
+  end
+
+  def pull
+    pull_cmd = Terrapin::CommandLine.new("docker pull #{latest_tag}")
+    pull_cmd.run
+  rescue Terrapin::ExitStatusError => e
+    puts e.message
+  end
+
+  def build
+    build_cmd = Terrapin::CommandLine.new("docker build #{directory} --cache-from #{latest_tag} --tag #{latest_tag} --tag #{version_tag}")
+    puts "Building with two tags: #{latest_tag} & #{version_tag}"
+    build_cmd.run
+  end
+
+  def push
+    pull_cmd = Terrapin::CommandLine.new("docker push #{latest_tag} && docker push #{version_tag}")
+    pull_cmd.run
+  end
+
+  private
+
+  def image_name
+    options[:image]
+  end
+
+  def directory
+    options[:directory] || "./"
+  end
+
+  def latest_tag
+    "#{repository}:latest"
+  end
+
+  def version_tag
+    "#{repository}:#{helper.version}"
+  end
+
+
+  def repository
+    @repository ||= begin
+      all = client.repositories
+      with_name = all.select { |r| r.repository_arn.include?(image_name) }
+      return with_name[0].repository_uri if with_name.length === 1
+
+      exact = with_name.select { |r| r.repository_arn.include?(project) && r.repository_arn.include?(application) }
+      return exact[0].repository_uri if exact.length === 1
+
+      raise "Can't detect ECR repository"
+    end
+  end
+end

data/lib/ecs_helper/command/deploy.rb

@@ -0,0 +1,145 @@
+require 'terrapin'
+
+class ECSHelper::Command::Deploy < ECSHelper::Command::Base
+  attr_accessor :repositories, :task_definition, :new_task_definition, :service
+  TIMEOUT = 300
+  STEP = 5
+
+  def cmd_option_parser
+    options = {}
+    parser = ::OptionParser.new do |opts|
+      opts.banner = "Usage: ecs_helper deploy [options]]"
+      opts.on("-v", "--verbose", "Show debug information") { o[:verbose] = true }
+      opts.on("-p VALUE", "--project VALUE", "Set project name, if not specified will look at ENV['PROJECT'], will be used to detect cluster") { |p| options[:project] = processEqual(p) }
+      opts.on("-a VALUE", "--application VALUE", "Set application name, if not specified will look at ENV['APPLICATION'], will be used to detect service and task definition") { |a| options[:application] = processEqual(a) }
+      opts.on("-e VALUE", "--environment VALUE", "Set environment, if not specified will look at ENV['ENVIRONMENT'], it there is empty will try to detect based on the branch") { |e| options[:environment] = processEqual(e) }
+      opts.on("-t VALUE", "--tag VALUE", "Set tag which will be applied to all containers in the task if tag is present in the repo") { |t| options[:tag] = processEqual(t) }
+      opts.on("-c VALUE", "--cluster VALUE", "Set cluster name, could be autodetected if project and environment are specified") { |c| options[:cluster] = processEqual(c) }
+      opts.on("-s VALUE", "--service VALUE", "Set service, could be autodetected if application and environment are specified") { |s| options[:service] = processEqual(s) }
+    end
+    [parser, options]
+  end
+
+  def run
+    log("Command", type)
+    log("Options", options)
+    log("Environment", environment)
+    log("Cluster", cluster_arn)
+    log("Service", service_arn)
+    log("Tag", tag)
+    log("Service task definition", task_definition_arn)
+    log("Containers", pretty_container_definitions)
+    log("New task definition", new_task_definition.task_definition_arn)
+    update_service && log("Update service", "Service task definition was updated")
+    log("Waiting for deployment...")
+    wait_for_deployment && log("Success", "Application was succesfully deployed", :cyan)
+  end
+
+  def wait_for_deployment(time = 0)
+    service = helper.client.describe_service(cluster_arn, service_arn)
+    return true if service.deployments.count == 1
+    error("Deployment timeout (#{TIMEOUT})") if time > TIMEOUT
+    sleep STEP
+    wait_for_deployment(time + STEP)
+  end
+
+  private
+
+  def environment
+    helper.environment
+  end
+
+  def cluster_arn
+    helper.current_cluster
+  end
+
+  def service_arn
+    helper.current_service
+  end
+
+  def tag
+    options[:tag] || helper.version
+  end
+
+  def service
+    @service ||= helper.client.describe_service(cluster_arn, service_arn)
+  end
+
+  def task_definition_arn
+    service.task_definition
+  end
+
+  def task_definition
+    @task_definition ||= helper.client.describe_task_definition(task_definition_arn)
+  end
+
+  def container_definitions
+    task_definition.container_definitions
+  end
+
+  def repositories
+    @repositories ||= client.repositories
+  end
+
+  def tag_image(repo)
+    client.describe_images({repository_name: repo.repository_name, image_ids: [image_tag: tag]})
+  rescue
+    nil
+  end
+
+  def new_task_definition
+    @new_task_definition ||= begin
+      attributes_to_remove = list = [:task_definition_arn, :revision, :status, :requires_attributes, :compatibilities, :registered_at, :registered_by]
+      new_task_definition_attributes = task_definition.to_hash
+                    .reject { |k,v| attributes_to_remove.include?(k.to_sym) }
+                    .merge(container_definitions: new_container_definitions)
+      helper.client.register_task_definition(new_task_definition_attributes)
+    end
+  end
+
+  def container_definition_to_ecr(cd)
+    repo = repo_for(cd.name)
+    is_ecr = cd.image.include?(ecr_base)
+    image = repo && tag_image(repo)
+    should_update = is_ecr && repo && image
+    [repo, is_ecr, image, should_update]
+  end
+
+  def new_container_definitions
+    container_definitions.map do |cd|
+      repo, is_ecr, image, should_be_updated =  container_definition_to_ecr(cd)
+      cd.image = "#{repo.repository_uri}:#{tag}" if should_be_updated
+      cd.to_hash
+    end
+  end
+
+  def pretty_container_definitions
+    container_definitions.map do |cd|
+      repo, is_ecr, image, should_be_updated =  container_definition_to_ecr(cd)
+      [
+        cd.name,
+        cd.image,
+        is_ecr ? "ECR image" : "Not a ECR image",
+        repo ? "Repo #{repo.repository_name}" : "Repo not found",
+        image ? "Image tag #{tag}" : "Image tag #{tag} not found",
+        should_be_updated ? "Will be updated" : "Not applicable"
+      ].join(' | ')
+    end.join("\n")
+  end
+
+  def repo_for(name)
+    repositories.find do |r|
+      uri = r.repository_uri
+      uri.include?(helper.application) && uri.include?(helper.project) && uri.include?(name)
+    end
+  end
+
+  def ecr_base
+    repositories.first.repository_uri.split('/').first
+  end
+
+  def update_service
+    helper.update_service(cluster_arn, service_arn, new_task_definition.task_definition_arn)
+    helper.client.deregister_task_definition(task_definition: task_definition.task_definition_arn)
+  end
+end

data/lib/ecs_helper/command.rb

@@ -0,0 +1,66 @@
+
+class ECSHelper::Command
+  autoload :Base, 'ecs_helper/command/base'
+  autoload :BuildAndPush, 'ecs_helper/command/build_and_push'
+  autoload :Deploy, 'ecs_helper/command/deploy'
+
+  CMD_MAPPING  = {
+    "build_and_push" => BuildAndPush,
+    "deploy" => Deploy
+  }
+  AVAILABLE_COMMANDS = CMD_MAPPING.keys
+
+  attr_accessor :type, :helper, :command
+
+  def initialize(helper)
+    @helper = helper
+    @type = ARGV.shift
+    @command = klass.new(helper)
+  end
+
+  def klass
+    CMD_MAPPING[type] || begin
+      puts "Command not found".light_white
+      puts "Available commands are #{AVAILABLE_COMMANDS}".light_white
+      puts global_option_parser
+      exit
+    end
+  end
+
+  def options
+    command.options
+  end
+
+  def run
+    command.validate
+    command.run
+  end
+end
+
+def global_option_parser
+  ::OptionParser.new do |opts|
+    opts.banner = "Usage: ecs_helper command [options]"
+  end
+end
+
+
+def self.parse
+  options = {}
+  command = ARGV.shift
+
+  unless command && Command::AVAILABLE_COMMANDS.include?(command)
+    puts "Command not found".light_white
+    puts "Available commands are #{Command::AVAILABLE_COMMANDS}".light_white
+    puts global
+    exit
+  end
+
+  subcommands_parser, required = subcommands(command, options)
+  subcommands_parser.permute!(into: options)
+
+  validate(command, options, required, subcommands_parser)
+
+  [command, options]
+end
+
+

data/lib/ecs_helper/common_helper.rb

@@ -0,0 +1,33 @@
+BRANCH_TO_ENV_MAPPING = {
+  master: 'production',
+  qa: 'qa',
+  staging: 'staging',
+  demo: 'demo',
+}
+
+class ECSHelper::CommonHelper
+  attr_accessor :helper, :branch, :version, :env
+  def initialize(helper)
+    @helper = helper
+  end
+
+  def branch
+    @branch ||= ENV["CI_COMMIT_BRANCH"] || `git rev-parse --abbrev-ref HEAD`.strip
+  end
+
+  def version
+    @version ||= ENV["CI_COMMIT_SHA"] || `git rev-parse HEAD`.strip
+  end
+
+  def environment
+    @env ||= helper.options[:environment] || ENV["ENVIRONMENT"] || BRANCH_TO_ENV_MAPPING[branch.to_sym] || raise(StandardError.new("Environment not detected"))
+  end
+
+  def project
+    ENV["PROJECT"]
+  end
+
+  def application
+    ENV["APPLICATION"]
+  end
+end

data/lib/ecs_helper/logging.rb

@@ -0,0 +1,16 @@
+module ECSHelper::Logging
+  def log(title, message = nil, color = "light_white")
+    if message
+      puts title.send(color)
+      puts message
+    else
+      puts title
+    end
+  end
+
+  def error(message)
+    puts "Error".red
+    puts message
+    exit
+  end
+end

data/lib/ecs_helper/service_helper.rb

@@ -0,0 +1,41 @@
+require 'aws-sdk-ecs'
+
+class ECSHelper::ServiceHelper
+  attr_accessor :helper, :services, :cluster, :current_service
+
+  def initialize(helper)
+    @helper = helper
+  end
+
+  def services
+    @services ||= helper.client.services(helper.current_cluster)
+  end
+
+  def current_service
+    @current_service ||= from_options || only_one || from_env || raise(StandardError.new("Service not detected"))
+  end
+
+  def from_options
+    value = helper.options[:service]
+    return nil unless value
+    return value if services.include?(value)
+    raise(StandardError.new("Service specified in cli not exists, services you have: #{services}")) unless services.find {|r| r == value}
+  end
+
+  def from_env
+    services.find {|s| s.include?(helper.application) && s.include?(helper.environment)}
+  end
+
+  def only_one
+    return services[0] if services.length == 1
+  end
+
+  def update_service(cluster, service, task_definition)
+    helper.client.update_service({
+      cluster: cluster,
+      service: service,
+      task_definition: task_definition
+    })
+  end
+end
+

data/lib/ecs_helper.rb

@@ -0,0 +1,28 @@
+require 'json'
+require 'colorize'
+require 'forwardable'
+
+class ECSHelper
+  extend Forwardable
+  attr_accessor :options, :client, :command, :parser, :cluster_helper, :service_helper, :common_helper
+
+  autoload :Client, 'ecs_helper/client'
+  autoload :CommonHelper, 'ecs_helper/common_helper'
+  autoload :ClusterHelper, 'ecs_helper/cluster_helper'
+  autoload :ServiceHelper, 'ecs_helper/service_helper'
+  autoload :Command, 'ecs_helper/command'
+
+  def_delegators :client, :task_definitions, :clusters, :services, :tasks, :repositories, :repositories, :task_definition
+  def_delegators :common_helper, :version, :branch, :environment, :project, :application
+  def_delegators :cluster_helper, :current_cluster, :clusters
+  def_delegators :service_helper, :current_service, :services, :update_service
+  def_delegators :command, :run, :options, :type
+
+  def initialize
+    @client = Client.new
+    @common_helper = CommonHelper.new(self)
+    @cluster_helper = ClusterHelper.new(self)
+    @service_helper = ServiceHelper.new(self)
+    @command = Command.new(self)
+  end
+end

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: ecs_helper
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Artem Petrov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-ecs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.80'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.80'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.80'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.80'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-ecr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.42'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.42'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.42'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.42'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: terrapin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: A simple gem which make CI CD process easier for AWS ECS service
+email: artem.petrov@dualbootpartners.com
+executables:
+- ecs_helper
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ecs_helper
+- lib/ecs_helper.rb
+- lib/ecs_helper/client.rb
+- lib/ecs_helper/cluster_helper.rb
+- lib/ecs_helper/command.rb
+- lib/ecs_helper/command/base.rb
+- lib/ecs_helper/command/build_and_push.rb
+- lib/ecs_helper/command/deploy.rb
+- lib/ecs_helper/common_helper.rb
+- lib/ecs_helper/logging.rb
+- lib/ecs_helper/service_helper.rb
+homepage: https://rubygems.org/gems/ecs_helper
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: ECSHelper
+test_files: []