ecs_deploy_cli 0.1.0 → 0.4.0

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.4.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,71 @@ 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 setup' do
+      expect(runner).to receive(:setup!)
+      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(['setup', '--file', 'spec/support/ECSFile']) }.to output(/[WARNING]/).to_stdout
+    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/cluster_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe EcsDeployCli::DSL::Cluster do
+  context 'defines cluster data' do
+    subject { described_class.new('mydata-cluster', { aws_profile_id: '123123', aws_region: 'eu-central-1' }) }
+
+    it '#vpc' do
+      subject.instances_count 1
+      subject.instance_type 't2.small'
+      subject.keypair_name 'test'
+
+      subject.vpc do
+        cidr '11.0.0.0/16'
+        subnet1 '11.0.0.0/24'
+        subnet2 '11.0.1.0/24'
+        subnet3 '11.0.2.0/24'
+        subnet_ids 'subnet-123', 'subnet-321', 'subnet-333'
+
+        availability_zones 'eu-central-1a', 'eu-central-1b', 'eu-central-1c'
+      end
+
+      expect(subject.as_definition).to eq(
+        {
+          device_name: '/dev/xvda',
+          ebs_volume_size: 22,
+          ebs_volume_type: 'gp2',
+          instances_count: 1,
+          instance_type: 't2.small',
+          keypair_name: 'test',
+          name: 'mydata-cluster',
+          root_device_name: '/dev/xvdcz',
+          root_ebs_volume_size: 30,
+          vpc: {
+            availability_zones: 'eu-central-1a,eu-central-1b,eu-central-1c',
+            cidr: '11.0.0.0/16',
+            id: nil,
+            subnet1: '11.0.0.0/24',
+            subnet2: '11.0.1.0/24',
+            subnet3: '11.0.2.0/24',
+            subnet_ids: 'subnet-123,subnet-321,subnet-333'
+          }
+        }
+      )
+    end
+  end
+end

data/spec/ecs_deploy_cli/dsl/container_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe EcsDeployCli::DSL::Container do
@@ -20,10 +22,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 +91,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/cron_spec.rb

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

data/spec/ecs_deploy_cli/dsl/parser_spec.rb

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

data/spec/ecs_deploy_cli/dsl/service_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe EcsDeployCli::DSL::Service do
+  context 'defines service data' do
+    subject { described_class.new('test', { aws_profile_id: '123123', aws_region: 'eu-central-1' }) }
+
+    it 'has the correct name' do
+      expect(subject.as_definition({})[:service]).to eq('test')
+    end
+
+    it '#load_balancer' do
+      subject.load_balancer :'yourproject-load-balancer' do
+        target_group_arn 'loader-target-group/123abc'
+        container_name :web
+        container_port 80
+      end
+
+      expect(subject.as_definition({})[:load_balancers]).to eq(
+        [
+          {
+            container_name: :web,
+            container_port: 80,
+            target_group_arn: 'arn:aws:elasticloadbalancing:eu-central-1:123123:targetgroup/loader-target-group/123abc'
+          }
+        ]
+      )
+    end
+  end
+end

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,19 +1,84 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'aws-sdk-cloudwatchevents'
+require 'aws-sdk-cloudwatchlogs'
 require 'aws-sdk-ec2'
+require 'aws-sdk-ssm'
+require 'aws-sdk-cloudformation'
 
 describe EcsDeployCli::Runner do
   context 'defines task data' do
     let(:parser) { EcsDeployCli::DSL::Parser.load('spec/support/ECSFile') }
     subject { described_class.new(parser) }
+    let(:mock_cf_client) { Aws::CloudFormation::Client.new(stub_responses: true) }
+    let(:mock_ssm_client) { Aws::SSM::Client.new(stub_responses: true) }
     let(:mock_ecs_client) { Aws::ECS::Client.new(stub_responses: true) }
     let(:mock_ec2_client) { Aws::EC2::Client.new(stub_responses: true) }
+    let(:mock_cwl_client) { Aws::CloudWatchLogs::Client.new(stub_responses: true) }
     let(:mock_cwe_client) 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
@@ -25,29 +90,109 @@ describe EcsDeployCli::Runner do
         ENV['AWS_REGION'] = nil
       end
 
-      it '#ssh' do
-        expect(mock_ecs_client).to receive(:list_container_instances).and_return({ container_instance_arns: ['arn:123123'] })
-        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')])
-                                      ]
-                                    )
-                                   )
-
-        expect(Process).to receive(:fork) do |&block|
-          block.call
+      it '#setup!' do
+        mock_ssm_client.stub_responses(:get_parameter, {
+                                         parameter: {
+                                           name: '/aws/service/ecs/optimized-ami/amazon-linux-2/recommended',
+                                           type: 'String',
+                                           value: '{"schema_version":1,"image_name":"amzn2-ami-ecs-hvm-2.0.20210331-x86_64-ebs","image_id":"ami-03bbf53329af34379","os":"Amazon Linux 2","ecs_runtime_version":"Docker version 19.03.13-ce","ecs_agent_version":"1.51.0"}'
+                                         }
+                                       })
+
+        expect(mock_cf_client).to receive(:wait_until)
+        expect(mock_ecs_client).to receive(:create_service)
+
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cwl_client).at_least(:once).and_return(mock_cwl_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(:ssm_client).at_least(:once).and_return(mock_ssm_client)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:cf_client).at_least(:once).and_return(mock_cf_client)
+
+        subject.setup!
+      end
+
+      context '#ssh' do
+        it 'runs ssh on a single container instance' do
+          expect(mock_ecs_client).to receive(:list_tasks).and_return({ task_arns: ['arn:123123'] })
+          expect(mock_ecs_client).to receive(:describe_tasks).and_return({ tasks: [{ container_instance_arn: 'arn:instance:123123' }] })
+          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')])
+                    ])
+            )
+
+          expect(Process).to receive(:fork) do |&block|
+            block.call
+          end
+          expect(Process).to receive(:wait)
+
+          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
-        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)
+        it 'prompts which instance if there are multiple ones' do
+          expect(mock_ecs_client).to receive(:list_tasks).and_return({ task_arns: ['arn:123123', 'arn:321321'] })
+          expect(mock_ecs_client).to receive(:describe_tasks).and_return(
+            {
+              tasks: [
+                { container_instance_arn: 'arn:instance:123123' },
+                { container_instance_arn: 'arn:instance:321321' }
+              ]
+            }
+          )
+          expect(mock_ecs_client).to receive(:describe_container_instances).and_return(
+            double(container_instances: [double(ec2_instance_id: 'i-123123'), double(ec2_instance_id: 'i-321321')])
+          )
+
+          expect(STDIN).to receive(:gets).and_return('2')
+
+          expect(mock_ec2_client).to receive(:describe_instances)
+            .with(instance_ids: ['i-321321'])
+            .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_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
+      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(:cwl_client).at_least(:once).and_return(mock_cwl_client)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
 
-        subject.ssh
+        subject.run_task!('yourproject-cron', launch_type: 'FARGATE', security_groups: [], subnets: [])
       end
 
       it '#update_crons!' do
@@ -55,18 +200,24 @@ describe EcsDeployCli::Runner do
 
         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(:cwl_client).at_least(:once).and_return(mock_cwl_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
 
       it '#update_services!' do
         expect(mock_ecs_client).to receive(:register_task_definition).at_least(:once).and_return({ task_definition: { family: 'some', revision: '1' } })
-        expect(mock_ecs_client).to receive(:update_service)
+        expect(mock_ecs_client).to receive(:update_service).with(
+          cluster: 'yourproject-cluster',
+          service: 'yourproject-service',
+          task_definition: 'some:1'
+        )
         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(:cwl_client).at_least(:once).and_return(mock_cwl_client)
+        expect_any_instance_of(EcsDeployCli::Runners::Base).to receive(:ecs_client).at_least(:once).and_return(mock_ecs_client)
 
         subject.update_services!
       end