ecs_deploy_cli 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5f34210100053703e0137631635b625ea37cc1cb140e4fa432c3375c6cdf87a
-  data.tar.gz: '08d8ead32a4b87cddb19b36539d661fc954e006a8ac3986a8dc60aaac93cd560'
+  metadata.gz: de429c09d039ddd636e85d23ec40bc20d7e91a09af10fefcc4124086494a8127
+  data.tar.gz: 57e24e217b08edf956a8b43894486a6db702756fedd2016b13e635fa9f5c2f3a
 SHA512:
-  metadata.gz: 90cb49d9d8de03d5b82946493d2df2466dec05cd01c190e9673ed6023adf9b5167465032bc47076ac12f7f8bfc451fd78c8568aec3aede6fd82467b7369914ad
-  data.tar.gz: f3dedd74c575d671fc65afb974086d8683c4eb3ee38074aec7d1dacb0b31632dd52813127bb39f1b3df95167353a8871308da8fbd885fd57cbb7f3ef34ca9941
+  metadata.gz: cecc078f5afcd85d0ca3600fd8d7db360dbf99d3cf27901aca2b15f15500864cc860de616b4bcf49bc29024b0301e3a6af41bb74808e1a94e216d45f1076346c
+  data.tar.gz: 4c66c16a9948dd255ca23f626341a3b052fda205297e71f8ffe185d4e3add1cca7dfe18e7d69800c735db55c606db3275a08a41f63bdafae9eba7a0a88de0abe

data/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

data/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 @@ module EcsDeployCli
       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 @@ module EcsDeployCli
       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 @@ module EcsDeployCli
       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

data/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

data/lib/ecs_deploy_cli/dsl/container.rb

@@ -5,25 +5,23 @@ module EcsDeployCli
     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 @@ module EcsDeployCli
         (_options[:port_mappings] ||= []) << options
       end
 
-      def cpu(value)
-        _options[:cpu] = value
-      end
-
       def memory(limit:, reservation:)
         _options[:memory] = limit
         _options[:memory_reservation] = reservation

data/lib/ecs_deploy_cli/dsl/parser.rb

@@ -55,9 +55,9 @@ module EcsDeployCli
       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
 

data/lib/ecs_deploy_cli/dsl/task.rb

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

data/lib/ecs_deploy_cli/runner.rb

@@ -1,3 +1,13 @@
+# 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)
@@ -5,149 +15,35 @@ module EcsDeployCli
     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

data/lib/ecs_deploy_cli/runners/base.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class Base
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def run!
+        raise NotImplementedError, 'abstract method'
+      end
+
+      protected
+
+      def _update_task(definition)
+        ecs_client.register_task_definition(
+          definition
+        ).to_h[:task_definition]
+      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
+end

data/lib/ecs_deploy_cli/runners/diff.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class Diff < Base
+      def run!
+        require 'hashdiff'
+        require 'colorize'
+
+        _, tasks, = @parser.resolve
+
+        tasks.each do |task_name, definition|
+          EcsDeployCli.logger.info '---'
+          EcsDeployCli.logger.info "Task: #{task_name}"
+
+          result = ecs_client.describe_task_definition(task_definition: "#{task_name}").to_h
+
+          current = result[:task_definition].except(:revision, :status, :registered_at, :registered_by, :requires_attributes, :task_definition_arn)
+
+          print_diff Hashdiff.diff(current.except(:container_definitions), definition.except(:container_definitions))
+
+          current[:container_definitions].zip(definition[:container_definitions]).each do |a, b|
+            EcsDeployCli.logger.info "Container #{a&.dig(:name) || 'NONE'} <=> #{b&.dig(:name) || 'NONE'}"
+
+            print_diff Hashdiff.diff(a, b) if a && b
+          end
+          EcsDeployCli.logger.info '---'
+        end
+      end
+
+      def print_diff(diff)
+        diff.each do |(op, path, *values)|
+          if op == '-'
+            EcsDeployCli.logger.info "#{op} #{path} => #{values.join(' ')}".colorize(:red)
+          elsif op == '+'
+            EcsDeployCli.logger.info "#{op} #{path} => #{values.join(' ')}".colorize(:green)
+          else
+            EcsDeployCli.logger.info "#{op} #{path} => #{values.join(' ')}".colorize(:light_blue)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/runners/run_task.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class RunTask < Base
+      def run!(task, launch_type:, security_groups:, subnets:)
+        _, tasks, = @parser.resolve
+
+        task_definition = _update_task tasks[task]
+        task_name = "#{task_definition[:family]}:#{task_definition[:revision]}"
+
+        ecs_client.run_task(
+          cluster: config[:cluster],
+          task_definition: task_name,
+          network_configuration: {
+            awsvpc_configuration: {
+              subnets: subnets,
+              security_groups: security_groups,
+              assign_public_ip: 'ENABLED'
+            }
+          },
+          launch_type: launch_type
+        )
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/runners/ssh.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class SSH < Base
+      def run!
+        instance_ids = load_container_instances
+        EcsDeployCli.logger.info "Found instances: #{instance_ids.join(', ')}"
+
+        dns_name = load_dns_name_from_instance_ids(instance_ids)
+        run_ssh(dns_name)
+      end
+
+      private
+
+      def load_dns_name_from_instance_ids(instance_ids)
+        response = ec2_client.describe_instances(
+          instance_ids: instance_ids
+        )
+
+        response.reservations[0].instances[0].public_dns_name
+      end
+
+      def load_container_instances
+        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
+        )
+
+        response.container_instances.map(&:ec2_instance_id)
+      end
+
+      def run_ssh(dns_name)
+        EcsDeployCli.logger.info "Connecting to ec2-user@#{dns_name}..."
+
+        Process.fork { exec("ssh ec2-user@#{dns_name}") }
+        Process.wait
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/runners/update_crons.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class UpdateCrons < Base
+      def run!
+        _, 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]
+          )
+
+          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
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/runners/update_services.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class UpdateServices < Base
+      def run!(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
+      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 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
+    end
+  end
+end

data/lib/ecs_deploy_cli/runners/validate.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class Validate < Base
+      def run!
+        services, _, crons = @parser.resolve
+
+        validate_cluster!
+        validate_services!(services)
+        validate_crons!(crons)
+      end
+
+      private
+
+      def validate_cluster!
+        data = ecs_client.describe_clusters(clusters: [config[:cluster]])
+
+        raise "No such cluster #{config[:cluster]}." if data.to_h[:failures]&.any? || data.to_h[:clusters].length == 0
+      rescue Aws::ECS::Errors::ClusterNotFoundException
+        raise "No such cluster #{config[:cluster]}."
+      end
+
+      def validate_services!(services)
+        services&.each do |service_name, _|
+          data = ecs_client.describe_services(cluster: config[:cluster], services: [service_name])
+
+          raise "No such service #{service_name}." if data.to_h[:failures]&.any? || data.to_h[:services].length == 0
+        end
+      end
+
+      def validate_crons!(crons)
+        crons&.each do |cron_name, _|
+          items = cwe_client.list_targets_by_rule(
+            {
+              rule: cron_name,
+              limit: 1
+            }
+          )
+          raise "No such cron #{cron_name}." if items.targets.empty?
+        rescue Aws::CloudWatchEvents::Errors::ResourceNotFoundException
+          raise "No such cron #{cron_name}."
+        end
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module EcsDeployCli
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/ecs_deploy_cli/cli_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe EcsDeployCli::CLI do
@@ -20,33 +22,63 @@ describe EcsDeployCli::CLI do
       expect { described_class.start(['version']) }.to output(/Version #{EcsDeployCli::VERSION}/).to_stdout
     end
 
+    it 'runs diff' do
+      expect(runner).to receive(:diff)
+      described_class.no_commands do
+        expect_any_instance_of(described_class).to receive(:runner).at_least(:once).and_return(runner)
+      end
+
+      described_class.start(['diff', '--file', 'spec/support/ECSFile'])
+    end
+
     it 'runs validate' do
+      expect(runner).to receive(:validate!)
+      described_class.no_commands do
+        expect_any_instance_of(described_class).to receive(:runner).at_least(:once).and_return(runner)
+      end
       expect { described_class.start(['validate', '--file', 'spec/support/ECSFile']) }.to output(/Your ECSFile looks fine! 🎉/).to_stdout
     end
 
+    it 'runs run-task' do
+      expect(runner).to receive(:run_task!)
+      described_class.no_commands do
+        expect_any_instance_of(described_class).to receive(:runner).at_least(:once).and_return(runner)
+      end
+
+      described_class.start(['run-task', 'yourproject', '--subnets', 'subnet-123123', '--file', 'spec/support/ECSFile'])
+    end
+
     it 'runs deploy' do
       expect(runner).to receive(:update_crons!)
       expect(runner).to receive(:update_services!).with(timeout: 500)
-      expect_any_instance_of(described_class).to receive(:runner).at_least(:once).and_return(runner)
+      described_class.no_commands do
+        expect_any_instance_of(described_class).to receive(:runner).at_least(:once).and_return(runner)
+      end
       expect { described_class.start(['deploy', '--file', 'spec/support/ECSFile']) }.to output(/[WARNING]/).to_stdout
     end
 
     it 'runs deploy-services' do
       expect(runner).to receive(:update_services!)
-      expect_any_instance_of(described_class).to receive(:runner).and_return(runner)
+      described_class.no_commands do
+        expect_any_instance_of(described_class).to receive(:runner).and_return(runner)
+      end
       expect { described_class.start(['deploy-services', '--file', 'spec/support/ECSFile']) }.to output(/[WARNING]/).to_stdout
     end
 
     it 'runs ssh' do
       expect(runner).to receive(:ssh)
-      expect_any_instance_of(described_class).to receive(:runner).and_return(runner)
+      described_class.no_commands do
+        expect_any_instance_of(described_class).to receive(:runner).and_return(runner)
+      end
 
       described_class.start(['ssh', '--file', 'spec/support/ECSFile'])
     end
 
     it 'runs deploy-scheduled-tasks' do
       expect(runner).to receive(:update_crons!)
-      expect_any_instance_of(described_class).to receive(:runner).and_return(runner)
+      described_class.no_commands do
+        expect_any_instance_of(described_class).to receive(:runner).at_least(:once).and_return(runner)
+      end
 
       described_class.start(['deploy-scheduled-tasks', '--file', 'spec/support/ECSFile'])
     end

data/spec/ecs_deploy_cli/dsl/container_spec.rb

@@ -20,10 +20,10 @@ describe EcsDeployCli::DSL::Container do
       expect(subject.as_definition[:environment]).to eq(
         [
           {
-            'name' => 'SOME', 'value' => 'env'
+            name: 'SOME', value: 'env'
           },
           {
-            'name' => 'SOME2', 'value' => 'env2'
+            name: 'SOME2', value: 'env2'
           }
         ]
       )
@@ -89,10 +89,10 @@ describe EcsDeployCli::DSL::Container do
       expect(subject.as_definition[:environment]).to eq(
         [
           {
-            'name' => 'RAILS_ENV', 'value' => 'production'
+            name: 'RAILS_ENV', value: 'production'
           },
           {
-            'name' => 'API_KEY', 'value' => '123123123'
+            name: 'API_KEY', value: '123123123'
           }
         ]
       )

data/spec/ecs_deploy_cli/dsl/task_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe EcsDeployCli::DSL::Task do

data/spec/ecs_deploy_cli/runner_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'aws-sdk-cloudwatchevents'
 require 'aws-sdk-ec2'
@@ -12,8 +14,65 @@ describe EcsDeployCli::Runner do
       Aws::CloudWatchEvents::Client.new(stub_responses: true)
     end
 
-    it '#validate!' do
-      expect { subject.validate! }.to raise_error('Missing required parameter aws_profile_id')
+    context '#validate!' do
+      it 'fails on missing params' do
+        expect { subject.validate! }.to raise_error('Missing required parameter aws_profile_id')
+      end
+
+      context 'with a minimal set of options' do
+        let(:parser) { EcsDeployCli::DSL::Parser.load('spec/support/ECSFile.minimal') }
+        it 'fails on missing params' do
+          mock_ecs_client.stub_responses(:describe_clusters, { clusters: [{ cluster_arn: 'arn:xxx', cluster_name: 'yourproject-cluster' }] })
+          expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+          subject.validate!
+        end
+      end
+
+      context 'with envs set' do
+        around(:each) do |example|
+          ENV['AWS_PROFILE_ID'] = '123123123'
+          ENV['AWS_REGION'] = 'us-east-1'
+          example.run
+          ENV['AWS_PROFILE_ID'] = nil
+          ENV['AWS_REGION'] = nil
+        end
+
+        it 'fails on missing cluster' do
+          mock_ecs_client.stub_responses(:describe_clusters, { failures: [{ arn: 'arn:xxx', reason: 'MISSING' }] })
+          expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+          expect { subject.validate! }.to raise_error('No such cluster yourproject-cluster.')
+        end
+
+        it 'fails on missing service' do
+          expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+
+          mock_ecs_client.stub_responses(:describe_clusters, { clusters: [{ cluster_arn: 'arn:xxx', cluster_name: 'yourproject-cluster' }] })
+          mock_ecs_client.stub_responses(:describe_services, { services: [], failures: [{}] })
+
+          expect { subject.validate! }.to raise_error('No such service yourproject-service.')
+        end
+
+        it 'fails on missing crons' do
+          expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwe_client).at_least(:once).and_return(mock_cwe_client)
+          expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+
+          mock_ecs_client.stub_responses(:describe_clusters, { clusters: [{ cluster_arn: 'arn:xxx', cluster_name: 'yourproject-cluster' }] })
+          mock_ecs_client.stub_responses(:describe_services, { services: [{ service_arn: 'arn:xxx', service_name: 'yourproject-service' }] })
+
+          expect { subject.validate! }.to raise_error('No such cron scheduled_emails.')
+        end
+
+        it 'makes API calls to check if everything is there' do
+          expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+          expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwe_client).at_least(:once).and_return(mock_cwe_client)
+
+          mock_ecs_client.stub_responses(:describe_clusters, { clusters: [{ cluster_arn: 'arn:xxx', cluster_name: 'yourproject-cluster' }] })
+          mock_cwe_client.stub_responses(:list_targets_by_rule, { targets: [{ id: '123', arn: 'arn:123' }] })
+          mock_ecs_client.stub_responses(:describe_services, { services: [{ service_arn: 'arn:xxx', service_name: 'yourproject-service' }] })
+
+          subject.validate!
+        end
+      end
     end
 
     context 'with envs set' do
@@ -30,33 +89,53 @@ describe EcsDeployCli::Runner do
         expect(mock_ecs_client).to receive(:describe_container_instances).and_return(double(container_instances: [double(ec2_instance_id: 'i-123123')]))
 
         expect(mock_ec2_client).to receive(:describe_instances)
-                                   .with(instance_ids: ['i-123123'])
-                                   .and_return(
-                                     double(reservations: [
-                                       double(instances: [double(public_dns_name: 'test.com')])
-                                      ]
-                                    )
-                                   )
+          .with(instance_ids: ['i-123123'])
+          .and_return(
+            double(reservations: [
+                     double(instances: [double(public_dns_name: 'test.com')])
+                   ])
+          )
 
         expect(Process).to receive(:fork) do |&block|
           block.call
         end
         expect(Process).to receive(:wait)
 
-        expect(subject).to receive(:exec).with('ssh ec2-user@test.com')
-        expect(subject).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
-        expect(subject).to receive(:ec2_client).at_least(:once).and_return(mock_ec2_client)
+        expect_any_instance_of(EcsDeployCli::Runners::SSH).to receive(:exec).with('ssh ec2-user@test.com')
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ec2_client).at_least(:once).and_return(mock_ec2_client)
 
         subject.ssh
       end
 
+      it '#diff' do
+        mock_ecs_client.stub_responses(:describe_task_definition)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+
+        expect(EcsDeployCli.logger).to receive(:info).at_least(:once) do |message|
+          puts message
+        end
+
+        expect { subject.diff }.to output(/Task: yourproject/).to_stdout
+      end
+
+      it '#run_task!' do
+        mock_ecs_client.stub_responses(:register_task_definition, { task_definition: { family: 'some', revision: 1, task_definition_arn: 'arn:task:eu-central-1:xxxx' } })
+
+        mock_cwe_client.stub_responses(:run_task)
+
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+
+        subject.run_task!('yourproject-cron', launch_type: 'FARGATE', security_groups: [], subnets: [])
+      end
+
       it '#update_crons!' do
         mock_ecs_client.stub_responses(:register_task_definition, { task_definition: { family: 'some', revision: 1, task_definition_arn: 'arn:task:eu-central-1:xxxx' } })
 
         mock_cwe_client.stub_responses(:list_targets_by_rule, { targets: [{ id: '123', arn: 'arn:123' }] })
 
-        expect(subject).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
-        expect(subject).to receive(:cwe_client).at_least(:once).and_return(mock_cwe_client)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwe_client).at_least(:once).and_return(mock_cwe_client)
 
         subject.update_crons!
       end
@@ -66,7 +145,7 @@ describe EcsDeployCli::Runner do
         expect(mock_ecs_client).to receive(:update_service)
         expect(mock_ecs_client).to receive(:wait_until)
 
-        expect(subject).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
 
         subject.update_services!
       end

data/spec/support/ECSFile.minimal

@@ -0,0 +1,12 @@
+aws_region ENV.fetch('AWS_REGION', 'eu-central-1')
+
+# Used to create ARNs
+aws_profile_id '123123'
+
+# Defining the cluster name
+cluster 'yourproject-cluster'
+
+# A container to exec cron jobs
+container :cron do
+  command 'rails', 'runner'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ecs_deploy_cli
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mònade
@@ -73,6 +73,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: hashdiff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -134,6 +162,13 @@ files:
 - lib/ecs_deploy_cli/dsl/service.rb
 - lib/ecs_deploy_cli/dsl/task.rb
 - lib/ecs_deploy_cli/runner.rb
+- lib/ecs_deploy_cli/runners/base.rb
+- lib/ecs_deploy_cli/runners/diff.rb
+- lib/ecs_deploy_cli/runners/run_task.rb
+- lib/ecs_deploy_cli/runners/ssh.rb
+- lib/ecs_deploy_cli/runners/update_crons.rb
+- lib/ecs_deploy_cli/runners/update_services.rb
+- lib/ecs_deploy_cli/runners/validate.rb
 - lib/ecs_deploy_cli/version.rb
 - spec/ecs_deploy_cli/cli_spec.rb
 - spec/ecs_deploy_cli/dsl/container_spec.rb
@@ -143,12 +178,14 @@ files:
 - spec/ecs_deploy_cli/runner_spec.rb
 - spec/spec_helper.rb
 - spec/support/ECSFile
+- spec/support/ECSFile.minimal
 - spec/support/env_file.ext.yml
 - spec/support/env_file.yml
 homepage: https://rubygems.org/gems/ecs_deploy_cli
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/monade/ecs-deploy-cli
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -164,13 +201,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.7
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: A command line interface to make ECS deployments easier
 test_files:
 - spec/spec_helper.rb
 - spec/support/ECSFile
+- spec/support/ECSFile.minimal
 - spec/support/env_file.yml
 - spec/support/env_file.ext.yml
 - spec/ecs_deploy_cli/runner_spec.rb