🆕 New version 0.2.0

Author: ProGM

CHANGELOG.md

@@ -1,7 +1,15 @@
 # Changelog
 All notable changes to this project made by Monade Team are documented in this file. For info refer to team@monade.io
 
-## [0.1.0-alpha] - 2021-03-21
+## [0.2.0] - 2021-03-25
+### Added
+- Command run-task
+- Command diff
+- Made automatic options explicit
+- Deploy scheduled tasks
+- Refactoring runners
+
+## [0.1.0] - 2021-03-21
 First functional version
 
 ### Added

README.md

@@ -2,7 +2,7 @@
 
 # ECS Deploy CLI
 
-A CLI + DSL to simplify deployments on ECS.
+A CLI + DSL to simplify deployments on AWS [Elastic Container Service](https://aws.amazon.com/it/ecs/).
 
 It's partial, incomplete and unstable. Use it at your own risk.
 
@@ -160,6 +160,16 @@ Deploy just scheduled tasks
   $ ecs-deploy deploy-scheduled-tasks
 ```
 
+Prints the diff between your local task_definitions and the ones in your AWS account. Useful to debug what has to be updated using `deploy`.
+```bash
+  $ ecs-deploy diff
+```
+
+Starts a task in the cluster based on a task definition.
+```bash
+  $ ecs-deploy run-task [task_name] --subnets subnet1,subnet2 --launch-type FARGATE|EC2 --security-groups sg-123,sg-234
+```
+
 Run SSH on a cluster container instance:
 ```bash
   $ ecs-deploy ssh

ecs-deploy-cli.gemspec

@@ -15,12 +15,15 @@ Gem::Specification.new do |s|
   s.test_files = Dir['spec/**/*']
   s.required_ruby_version = '>= 2.5.0'
   s.homepage    = 'https://rubygems.org/gems/ecs_deploy_cli'
+  s.metadata    = { 'source_code_uri' => 'https://github.com/monade/ecs-deploy-cli' }
   s.license     = 'MIT'
   s.executables << 'ecs-deploy'
   s.add_dependency 'activesupport', ['>= 5', '< 7']
   s.add_dependency 'aws-sdk-cloudwatchevents', '~> 1'
   s.add_dependency 'aws-sdk-ec2', '~> 1'
   s.add_dependency 'aws-sdk-ecs', '~> 1'
+  s.add_dependency 'colorize', '~> 0.8.1'
+  s.add_dependency 'hashdiff', '~> 1.0'
   s.add_dependency 'thor', '~> 1.1'
   s.add_development_dependency 'rspec', '~> 3'
   s.add_development_dependency 'rubocop', '~> 0.93'

lib/ecs_deploy_cli.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'logger'
 require 'thor'
 require 'aws-sdk-ecs'
 require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/concern'
 
 module EcsDeployCli
   def self.logger
     @logger ||= begin
       logger = Logger.new(STDOUT)
-      logger.formatter = proc { |severity, datetime, progname, msg|
+      logger.formatter = proc { |_severity, _datetime, _progname, msg|
         "#{msg}\n"
       }
       logger.level = Logger::INFO

lib/ecs_deploy_cli/cli.rb

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
 module EcsDeployCli
   class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
     desc 'validate', 'Validates your ECSFile'
     option :file, default: 'ECSFile'
     def validate
@@ -8,6 +14,13 @@ def validate
       puts 'Your ECSFile looks fine! 🎉'
     end
 
+    desc 'diff', 'Check differences between task definitions'
+    option :file, default: 'ECSFile'
+    def diff
+      @parser = load(options[:file])
+      runner.diff
+    end
+
     desc 'version', 'Updates all services defined in your ECSFile'
     def version
       puts "ECS Deploy CLI Version #{EcsDeployCli::VERSION}."
@@ -29,7 +42,7 @@ def deploy_services
       runner.update_services! timeout: options[:timeout], service: options[:only]
     end
 
-    desc 'deploy', 'Updates a single service defined in your ECSFile'
+    desc 'deploy', 'Updates all services and scheduled tasks at once'
     option :file, default: 'ECSFile'
     option :timeout, type: :numeric, default: 500
     def deploy
@@ -38,6 +51,21 @@ def deploy
       runner.update_crons!
     end
 
+    desc 'run-task NAME', 'Manually runs a task defined in your ECSFile'
+    option :launch_type, default: 'FARGATE'
+    option :security_groups, default: '', type: :string
+    option :subnets, required: true, type: :string
+    option :file, default: 'ECSFile'
+    def run_task(task_name)
+      @parser = load(options[:file])
+      runner.run_task!(
+        task_name,
+        launch_type: options[:launch_type],
+        security_groups: options[:security_groups].split(','),
+        subnets: options[:subnets].split(',')
+      )
+    end
+
     desc 'ssh', 'Connects to ECS instance via SSH'
     option :file, default: 'ECSFile'
     def ssh

lib/ecs_deploy_cli/dsl/auto_options.rb

@@ -1,9 +1,25 @@
+# frozen_string_literal: true
+
 module EcsDeployCli
   module DSL
     module AutoOptions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def allowed_options(*value)
+          @allowed_options = value
+        end
+
+        def _allowed_options
+          @allowed_options ||= []
+        end
+      end
+
       def method_missing(name, *args, &block)
         if args.count == 1 && !block
-          EcsDeployCli.logger.info("Auto-added option security_group #{name.to_sym} = #{args.first}")
+          unless self.class._allowed_options.include?(name)
+            EcsDeployCli.logger.info("Used unhandled option #{name.to_sym} = #{args.first} in #{self.class.name}")
+          end
           _options[name.to_sym] = args.first
         else
           super

lib/ecs_deploy_cli/dsl/container.rb

@@ -5,25 +5,23 @@ module DSL
     class Container
       include AutoOptions
 
+      allowed_options :image, :cpu, :working_directory
+
       def initialize(name, config)
         @config = config
         _options[:name] = name.to_s
       end
 
-      def image(value)
-        _options[:image] = value
-      end
-
       def command(*command)
         _options[:command] = command
       end
 
       def load_envs(name)
-        _options[:environment] = (_options[:environment] || []) + YAML.safe_load(File.open(name))
+        _options[:environment] = (_options[:environment] || []) + YAML.safe_load(File.open(name), symbolize_names: true)
       end
 
       def env(key:, value:)
-        (_options[:environment] ||= []) << { 'name' => key, 'value' => value }
+        (_options[:environment] ||= []) << { name: key, value: value }
       end
 
       def secret(key:, value:)
@@ -34,10 +32,6 @@ def expose(**options)
         (_options[:port_mappings] ||= []) << options
       end
 
-      def cpu(value)
-        _options[:cpu] = value
-      end
-
       def memory(limit:, reservation:)
         _options[:memory] = limit
         _options[:memory_reservation] = reservation

lib/ecs_deploy_cli/dsl/parser.rb

@@ -55,9 +55,9 @@ def ensure_required_params!
       end
 
       def resolve
-        resolved_containers = @containers.transform_values(&:as_definition)
-        resolved_tasks = @tasks.transform_values { |t| t.as_definition(resolved_containers) }
-        resolved_crons = @crons.transform_values { |t| t.as_definition(resolved_tasks) }
+        resolved_containers = (@containers || {}).transform_values(&:as_definition)
+        resolved_tasks = (@tasks || {}).transform_values { |t| t.as_definition(resolved_containers) }
+        resolved_crons = (@crons || {}).transform_values { |t| t.as_definition(resolved_tasks) }
         [@services, resolved_tasks, resolved_crons]
       end
 

lib/ecs_deploy_cli/dsl/task.rb

@@ -5,6 +5,8 @@ module DSL
     class Task
       include AutoOptions
 
+      allowed_options :requires_compatibilities, :network_mode
+
       def initialize(name, config)
         @config = config
         _options[:family] = name.to_s

lib/ecs_deploy_cli/runner.rb

@@ -1,153 +1,49 @@
+# frozen_string_literal: true
+
+require 'ecs_deploy_cli/runners/base'
+require 'ecs_deploy_cli/runners/ssh'
+require 'ecs_deploy_cli/runners/validate'
+require 'ecs_deploy_cli/runners/diff'
+require 'ecs_deploy_cli/runners/update_crons'
+require 'ecs_deploy_cli/runners/update_services'
+require 'ecs_deploy_cli/runners/run_task'
+
 module EcsDeployCli
   class Runner
     def initialize(parser)
       @parser = parser
     end
 
     def validate!
-      @parser.resolve
+      EcsDeployCli::Runners::Validate.new(@parser).run!
     end
 
     def update_crons!
-      _, tasks, crons = @parser.resolve
-
-      crons.each do |cron_name, cron_definition|
-        task_definition = tasks[cron_definition[:task_name]]
-        raise "Undefined task #{cron_definition[:task_name].inspect} in (#{tasks.keys.inspect})" unless task_definition
-
-        updated_task = _update_task(task_definition)
-
-        current_target = cwe_client.list_targets_by_rule(
-          {
-            rule: cron_name,
-            limit: 1
-          }
-        ).to_h[:targets].first
-
-        cwe_client.put_rule(
-          cron_definition[:rule]
-        )
+      EcsDeployCli::Runners::UpdateCrons.new(@parser).run!
+    end
 
-        cwe_client.put_targets(
-          rule: cron_name,
-          targets: [
-            id: current_target[:id],
-            arn: current_target[:arn],
-            role_arn: current_target[:role_arn],
-            input: cron_definition[:input].to_json,
-            ecs_parameters: cron_definition[:ecs_parameters].merge(task_definition_arn: updated_task[:task_definition_arn])
-          ]
-        )
-        EcsDeployCli.logger.info "Deployed scheduled task \"#{cron_name}\"!"
-      end
+    def run_task!(task_name, launch_type:, security_groups:, subnets:)
+      EcsDeployCli::Runners::RunTask.new(@parser).run!(task_name, launch_type: launch_type, security_groups: security_groups, subnets: subnets)
     end
 
     def ssh
-      instances = ecs_client.list_container_instances(
-        cluster: config[:cluster]
-      ).to_h[:container_instance_arns]
-
-      response = ecs_client.describe_container_instances(
-        cluster: config[:cluster],
-        container_instances: instances
-      )
-
-      EcsDeployCli.logger.info "Found instances: #{response.container_instances.map(&:ec2_instance_id).join(', ')}"
-
-      response = ec2_client.describe_instances(
-        instance_ids: response.container_instances.map(&:ec2_instance_id)
-      )
-
-      dns_name = response.reservations[0].instances[0].public_dns_name
-      EcsDeployCli.logger.info "Connecting to ec2-user@#{dns_name}..."
+      EcsDeployCli::Runners::SSH.new(@parser).run!
+    end
 
-      Process.fork { exec("ssh ec2-user@#{dns_name}") }
-      Process.wait
+    def diff
+      EcsDeployCli::Runners::Diff.new(@parser).run!
     end
 
     def update_services!(service: nil, timeout: 500)
-      services, resolved_tasks = @parser.resolve
-
-      services.each do |service_name, service_definition|
-        next if !service.nil? && service != service_name
-
-        task_definition = _update_task resolved_tasks[service_definition.options[:task]]
-        task_name = "#{task_definition[:family]}:#{task_definition[:revision]}"
-
-        ecs_client.update_service(
-          cluster: config[:cluster],
-          service: service_name,
-          task_definition: "#{task_definition[:family]}:#{task_name}"
-        )
-        wait_for_deploy(service_name, task_name, timeout: timeout)
-        EcsDeployCli.logger.info "Deployed service \"#{service_name}\"!"
-      end
+      EcsDeployCli::Runners::UpdateServices.new(@parser).run!(service: service, timeout: timeout)
     end
 
     private
 
-    def wait_for_deploy(service_name, task_name, timeout:)
-      wait_data = { cluster: config[:cluster], services: [service_name] }
-
-      started_at = Time.now
-      ecs_client.wait_until(
-        :services_stable, wait_data,
-        max_attempts: nil,
-        before_wait: lambda { |_, response|
-          deployments = response.services.first.deployments
-          log_deployments task_name, deployments
-
-          throw :success if deployments.count == 1 && deployments[0].task_definition.end_with?(task_name)
-          throw :failure if Time.now - started_at > timeout
-        }
-      )
-    end
-
     def _update_task(definition)
       ecs_client.register_task_definition(
         definition
       ).to_h[:task_definition]
     end
-
-    def log_deployments(task_name, deployments)
-      EcsDeployCli.logger.info "Waiting for task: #{task_name} to become ok."
-      EcsDeployCli.logger.info 'Deployment status:'
-      deployments.each do |deploy|
-        EcsDeployCli.logger.info "[#{deploy.status}] task=#{deploy.task_definition.split('/').last}, "\
-                                 "desired_count=#{deploy.desired_count}, pending_count=#{deploy.pending_count}, running_count=#{deploy.running_count}, failed_tasks=#{deploy.failed_tasks}"
-      end
-      EcsDeployCli.logger.info ''
-    end
-
-    def ec2_client
-      @ec2_client ||= begin
-        require 'aws-sdk-ec2'
-        Aws::EC2::Client.new(
-          profile: ENV.fetch('AWS_PROFILE', 'default'),
-          region: config[:aws_region]
-        )
-      end
-    end
-
-    def ecs_client
-      @ecs_client ||= Aws::ECS::Client.new(
-        profile: ENV.fetch('AWS_PROFILE', 'default'),
-        region: config[:aws_region]
-      )
-    end
-
-    def cwe_client
-      @cwe_client ||= begin
-        require 'aws-sdk-cloudwatchevents'
-        Aws::CloudWatchEvents::Client.new(
-          profile: ENV.fetch('AWS_PROFILE', 'default'),
-          region: config[:aws_region]
-        )
-      end
-    end
-
-    def config
-      @parser.config
-    end
   end
 end