ecs_helper 0.0.8 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69c2a9f0e010f46fd746986748e14f9a08ee5a0255a2779b7ea453d8dc47c685
-  data.tar.gz: b59a0b7bd4a045834a741dd34586dd87a8eec88c84fb11d63daeba3cfc5bbe8a
+  metadata.gz: b451016256ba9f8702c05a3a6507cfe6789b14bd1c7cfca7594b61a8a8f11d7e
+  data.tar.gz: 7df2ee01acfb1b6dfed290d2f6d2b4953d073312f64def840ab407bc5899aa94
 SHA512:
-  metadata.gz: 65f11ad6c8120a872900dbc61b91d08ad66e9b999931f298760de9baf0639d0a691bcd5bc7c37be095d94d7ed18a5fb5c34a205b8e22dd117f43f12b6239ced3
-  data.tar.gz: 20126689d683994f8ade23d02de2f81a25406b86ace18890be6f013c8bc64a467de567e9ccb23f3cf1fbf31ac3bec754400913ca23faad623fe1559495f7aecf
+  metadata.gz: 491a4d8f3418a9ec91fd020a7132bb22682e56dea115941b2a8e3ef49018530577ef7a7b35d43a686e504482f69057ccae25376da3c49fae3a2cbe4ef467455d
+  data.tar.gz: 734ab8f3f409c3a60c13ed8cf0c1443c7548b18b3f88140c6a565ea77af2d64948bfcc6c4814b31974bbaf8f1c0202331809f19a63071e8c0c0150b43850163c

data/lib/ecs_helper.rb

@@ -10,9 +10,10 @@ class ECSHelper
   autoload :CommonHelper, 'ecs_helper/common_helper'
   autoload :ClusterHelper, 'ecs_helper/cluster_helper'
   autoload :ServiceHelper, 'ecs_helper/service_helper'
+  autoload :TaskDefinitionHelper, 'ecs_helper/task_definition_helper'
   autoload :Command, 'ecs_helper/command'
 
-  def_delegators :client, :task_definitions, :clusters, :services, :tasks, :repositories, :repositories, :task_definition
+  def_delegators :client, :task_definitions, :clusters, :services, :tasks, :repositories, :repositories, :task_definition, :run_task
   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

data/lib/ecs_helper/client.rb

@@ -48,6 +48,14 @@ class ECSHelper::Client
     ecs.update_service(params)
   end
 
+  def run_task(params = {})
+    ecs.run_task(params).tasks[0]
+  end
+
+  def describe_tasks(params = {})
+    ecs.describe_tasks(params).tasks
+  end
+
   # ECR
   def private_repositories(params = {})
     ecr.describe_repositories(params).repositories

data/lib/ecs_helper/command.rb

@@ -5,12 +5,14 @@ class ECSHelper::Command
   autoload :Deploy, 'ecs_helper/command/deploy'
   autoload :ExportImages, 'ecs_helper/command/export_images'
   autoload :ECRLogin, 'ecs_helper/command/ecr_login'
+  autoload :RunCommand, 'ecs_helper/command/run_command'
 
   CMD_MAPPING  = {
     "build_and_push" => BuildAndPush,
     "deploy" => Deploy,
     "export_images" => ExportImages,
     "ecr_login" => ECRLogin,
+    "run_command" => RunCommand,
   }
   AVAILABLE_COMMANDS = CMD_MAPPING.keys
 

data/lib/ecs_helper/command/build_and_push.rb

@@ -10,6 +10,7 @@ class ECSHelper::Command::BuildAndPush < ECSHelper::Command::Base
       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) }
+      opts.on("-c", "--cache", "Cache image before build, default false") { options[:cache] = true }
     end
     [parser, options]
   end
@@ -24,7 +25,7 @@ class ECSHelper::Command::BuildAndPush < ECSHelper::Command::Base
     log("Repository", repository)
     log("Auth Private", auth_private)
     log("Auth Public", auth_public)
-    log("Pull", pull)
+    should_cache? && log("Pull", pull)
     log("Build", build)
     log("Push", push)
   end
@@ -39,6 +40,10 @@ class ECSHelper::Command::BuildAndPush < ECSHelper::Command::Base
     auth_cmd.run
   end
 
+  def should_cache?
+    options[:cache]
+  end
+
   def pull
     pull_cmd = Terrapin::CommandLine.new("docker pull #{latest_tag}")
     pull_cmd.run
@@ -47,7 +52,11 @@ class ECSHelper::Command::BuildAndPush < ECSHelper::Command::Base
   end
 
   def build
-    build_cmd = Terrapin::CommandLine.new("docker build #{directory} --cache-from #{latest_tag} --tag #{latest_tag} --tag #{version_tag}")
+    build_command = ["docker build #{directory}"]
+    cache_command = should_cache? ? ["--cache-from #{latest_tag}"] : []
+    tags_command = ["--tag #{latest_tag} --tag #{version_tag}"]
+    command = (build_command + cache_command + tags_command).join(' ')
+    build_cmd = Terrapin::CommandLine.new(command)
     puts "Building with two tags: #{latest_tag} & #{version_tag}"
     build_cmd.run
   end

data/lib/ecs_helper/command/deploy.rb

@@ -2,7 +2,7 @@ require 'terrapin'
 
 class ECSHelper::Command::Deploy < ECSHelper::Command::Base
   attr_accessor :repositories, :task_definition, :new_task_definition, :service
-  TIMEOUT = 300
+  DEFAULT_TIMEOUT = 300
   STEP = 5
 
   def cmd_option_parser
@@ -12,32 +12,41 @@ class ECSHelper::Command::Deploy < ECSHelper::Command::Base
       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("-v VALUE", "--version VALUE", "Set version which will be applied to all containers in the task if tag is present in the repo") { |t| options[:version] = processEqual(t) }
+      opts.on("-cl 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) }
+      opts.on("-t VALUE", "--timeout VALUE", "Set timeout how long to wait until deployment finished") { |t| options[:timeout] = processEqual(t) }
     end
     [parser, options]
   end
 
   def run
+    task_definition_helper = ECSHelper::TaskDefinitionHelper.new(helper, service)
+    service_task_definition = task_definition_helper.service_task_definition
+    new_task_definition_hash = task_definition_helper.new_task_definition_hash
+    new_task_definition = task_definition_helper.register_task_definition(new_task_definition_hash)
     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("Version", version)
+    log("Service task definition", service_task_definition.task_definition_arn)
+    log("Containers", task_definition_helper.pretty_container_definitions)
     log("New task definition", new_task_definition.task_definition_arn)
-    update_service && log("Update service", "Service task definition was updated")
+    update_service(new_task_definition.task_definition_arn) && log("Update service", "Service task definition was updated")
     log("Waiting for deployment...")
     wait_for_deployment && log("Success", "Application was succesfully deployed", :cyan)
   end
 
+  def update_service(task_definition_arn)
+    helper.update_service(cluster_arn, service_arn, task_definition_arn)
+    helper.client.deregister_task_definition(task_definition: task_definition_arn)
+  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
+    error("Deployment timeout (#{timeout})") if time > timeout
     sleep STEP
     wait_for_deployment(time + STEP)
   end
@@ -56,89 +65,15 @@ class ECSHelper::Command::Deploy < ECSHelper::Command::Base
     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
+  def version
+    options[:version] || helper.version
   end
 
-  def task_definition
-    @task_definition ||= helper.client.describe_task_definition(task_definition_arn)
+  def timeout
+    options[:timeout] || DEFAULT_TIMEOUT
   end
 
-  def container_definitions
-    task_definition.container_definitions
-  end
-
-  def repositories
-    @repositories ||= client.private_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)
+  def service
+    helper.client.describe_service(cluster_arn, service_arn)
   end
 end

data/lib/ecs_helper/command/run_command.rb

@@ -0,0 +1,145 @@
+require 'terrapin'
+
+class ECSHelper::Command::RunCommand < ECSHelper::Command::Base
+  attr_accessor :repositories, :task_definition, :new_task_definition, :service
+  DEFAULT_TIMEOUT = 300
+  STEP = 5
+
+  def cmd_option_parser
+    options = {}
+    parser = ::OptionParser.new do |opts|
+      opts.banner = "Usage: ecs_helper run_command [options]"
+      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("-v VALUE", "--version VALUE", "Set version which will be applied to all containers in the task if tag is present in the repo") { |t| options[:version] = processEqual(t) }
+      opts.on("--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) }
+      opts.on("-t VALUE", "--timeout VALUE", "Set timeout how long to wait until deployment finished") { |t| options[:timeout] = processEqual(t) }
+      opts.on("--command VALUE", "Set command, should not demonize container") { |c| options[:command] = processEqual(c) }
+      opts.on("-n VALUE", "--name VALUE", "Set name (will be used for task definition name and log prefix") { |l| options[:name] = processEqual(l) }
+      opts.on("--container-name VALUE", "Set container name (default is the first container") { |cn| options[:container_name] = processEqual(cn) }
+    end
+    [parser, options]
+  end
+
+  def required
+    [:name, :command]
+  end
+
+  def run
+    task_definition_helper = ECSHelper::TaskDefinitionHelper.new(helper, service)
+    service_task_definition = task_definition_helper.service_task_definition
+    new_task_definition_hash = task_definition_helper.new_task_definition_hash
+    custom_task_definition_hash = custom_task_definition(new_task_definition_hash)
+    custom_task_definition = task_definition_helper.register_task_definition(custom_task_definition_hash)
+
+    log("Command", type)
+    log("Options", options)
+    log("Environment", environment)
+    log("Cluster", cluster_arn)
+    log("Service", service_arn)
+    log("Version", version)
+    log("New task definition", custom_task_definition.task_definition_arn)
+    task = run_task(custom_task_definition.task_definition_arn)
+    log("Start task", "Task #{task.task_arn} was started")
+    log("Waiting for task job...")
+    wait_for_task(task.task_arn) && log("Success", "Task finished successfully", :cyan)
+  end
+
+  def run_task(task_definition_arn)
+    helper.client.run_task({
+      cluster: cluster_arn,
+      task_definition: task_definition_arn,
+      network_configuration: service.network_configuration.to_hash,
+      launch_type: service.launch_type
+    })
+  end
+
+  def task(arn)
+    helper.client.describe_tasks({ cluster: cluster_arn, tasks: [arn] })[0]
+  end
+
+  def wait_for_task(task_arn, time = 0)
+    task = task(task_arn)
+    container = task.containers[0];
+    log("container: #{container.name}, time: #{time}, timeout: #{timeout}, status: #{container.last_status}, exit_code: #{container.exit_code || 'NONE'}")
+    if container.last_status == "STOPPED"
+      return true if container.exit_code == 0
+      error("Task #{task_arn} finished with exit code #{container.exit_code}")
+    end
+
+    error("Task run timeout (#{timeout})") if time > timeout
+    sleep STEP
+    wait_for_task(task_arn, time + STEP)
+  end
+
+  def custom_task_definition(hash)
+    hash.merge({
+      container_definitions: new_container_definition(hash),
+      family: "#{hash[:family]}-#{name}",
+    })
+  end
+
+  private
+
+  def new_container_definition(hash)
+    cds = hash[:container_definitions]
+    cds = [cds] if cds.is_a?(Hash)
+    cd = container_name ? cds.find {|cd| cd[:name] === container_name} : cds.first
+    error("Container not found") unless cd
+    new_cd = cd.merge({
+      command: command,
+      log_configuration: new_log_configuration(cd[:log_configuration]),
+      name: "#{cd[:name]}-#{name}"
+    })
+    [new_cd]
+  end
+
+  def new_log_configuration(log_configuration)
+    options = log_configuration[:options]
+    prefix = options["awslogs-stream-prefix"]
+    new_prefix = "#{prefix}-#{name}"
+    log_configuration.merge(options: options.merge("awslogs-stream-prefix" => new_prefix))
+  end
+
+  def command
+    ['bash', '-c', "#{options[:command]}"]
+  end
+
+  def environment
+    helper.environment
+  end
+
+  def cluster_arn
+    helper.current_cluster
+  end
+
+  def service_arn
+    helper.current_service
+  end
+
+  def version
+    options[:version] || helper.version
+  end
+
+  def timeout
+    options[:timeout] || DEFAULT_TIMEOUT
+  end
+
+  def service
+    helper.client.describe_service(cluster_arn, service_arn)
+  end
+
+  def name
+    options[:name]
+  end
+
+  def service
+    helper.client.describe_service(cluster_arn, service_arn)
+  end
+
+  def container_name
+    options[:container_name]
+  end
+end

data/lib/ecs_helper/task_definition_helper.rb

@@ -0,0 +1,93 @@
+require 'aws-sdk-ecs'
+
+class ECSHelper::TaskDefinitionHelper
+  attr_accessor :helper, :service, :service_task_definition, :repositories, :new_task_definition_hash
+  def initialize(helper, service)
+    @helper = helper
+    @service = service
+  end
+
+  def service_task_definition
+    @service_task_definition ||= helper.client.describe_task_definition(service.task_definition)
+  end
+
+  def container_definitions
+    service_task_definition.container_definitions
+  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 version #{version}" : "Image version #{version} not found",
+        should_be_updated ? "Will be updated" : "Not applicable"
+      ].join(' | ')
+    end.join("\n")
+  end
+
+  def register_task_definition(hash)
+    helper.client.register_task_definition(hash)
+  end
+
+  def new_task_definition_hash
+      attributes_to_remove = list = [:task_definition_arn, :revision, :status, :requires_attributes, :compatibilities, :registered_at, :registered_by]
+      service_task_definition.to_hash
+        .reject { |k,v| attributes_to_remove.include?(k.to_sym) }
+        .merge(container_definitions: new_container_definitions)
+  end
+
+  def container_definition_to_ecr(cd)
+    repo = repo_for(cd.name)
+    is_ecr = cd.image.include?(ecr_base)
+    image = repo && version_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}:#{version}" if should_be_updated
+      cd.to_hash
+    end
+  end
+
+  private
+
+  def container_definition_to_ecr(cd)
+    repo = repo_for(cd.name)
+    is_ecr = cd.image.include?(ecr_base)
+    image = repo && version_image(repo)
+    should_update = is_ecr && repo && image
+    [repo, is_ecr, image, should_update]
+  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 repositories
+    @repositories ||= helper.client.private_repositories
+  end
+
+  def ecr_base
+    repositories.first.repository_uri.split('/').first
+  end
+
+  def version_image(repo)
+    client.describe_images({repository_name: repo.repository_name, image_ids: [image_tag: version]})
+  rescue
+    nil
+  end
+
+  def version
+    helper.options[:version] || helper.version
+  end
+end

metadata

@@ -1,133 +1,133 @@
 --- !ruby/object:Gem::Specification
 name: ecs_helper
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.14
 platform: ruby
 authors:
 - Artem Petrov
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-17 00:00:00.000000000 Z
+date: 2021-06-22 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: aws-sdk-ecrpublic
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.3'
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.3'
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !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: 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: 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
@@ -147,14 +147,16 @@ files:
 - lib/ecs_helper/command/deploy.rb
 - lib/ecs_helper/command/ecr_login.rb
 - lib/ecs_helper/command/export_images.rb
+- lib/ecs_helper/command/run_command.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
+- lib/ecs_helper/task_definition_helper.rb
+homepage: https://github.com/artempartos/ecs_helper
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -169,8 +171,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.0.3
+signing_key: 
 specification_version: 4
 summary: ECSHelper
 test_files: []