🆕 Refactor ssh command to prompt for multiple instances. Accepting also instance filter

Author: ProGM

lib/ecs_deploy_cli/cli.rb

@@ -75,9 +75,12 @@ def run_task(task_name)
 
     desc 'ssh', 'Connects to ECS instance via SSH'
     option :file, default: 'ECSFile'
+    option :service, default: nil
+    option :task, default: nil
     def ssh
       @parser = load(options[:file])
-      runner.ssh
+      ssh_options = { family: options[:task], service_name: options[:service] }.delete_if { |_, v| v.nil? }
+      runner.ssh(**ssh_options)
     end
 
     private

lib/ecs_deploy_cli/runner.rb

@@ -31,8 +31,8 @@ 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
-      EcsDeployCli::Runners::SSH.new(@parser).run!
+    def ssh(**options)
+      EcsDeployCli::Runners::SSH.new(@parser).run!(options)
     end
 
     def diff

lib/ecs_deploy_cli/runners/ssh.rb

@@ -3,29 +3,63 @@
 module EcsDeployCli
   module Runners
     class SSH < Base
-      def run!
-        instance_ids = load_container_instances
-        EcsDeployCli.logger.info "Found instances: #{instance_ids.join(', ')}"
+      def run!(params = {})
+        instance_ids = load_container_instances(params)
 
-        dns_name = load_dns_name_from_instance_ids(instance_ids)
+        instance_id = choose_instance_id(instance_ids)
+        dns_name = load_dns_name_from_instance_id(instance_id)
         run_ssh(dns_name)
       end
 
       private
 
-      def load_dns_name_from_instance_ids(instance_ids)
+      def choose_instance_id(instance_ids)
+        raise 'No instance found' if instance_ids.empty?
+        return instance_ids[0] if instance_ids.length == 1
+
+        instances_selection_text = instance_ids.map.with_index do |instance, index|
+          "#{index + 1}) #{instance}"
+        end.join("\n")
+
+        EcsDeployCli.logger.info(
+          "Found #{instance_ids.count} instances:\n#{instances_selection_text}\nSelect which one you want to access:"
+        )
+
+        index = select_index_from_array(instance_ids, retry_message: 'Invalid option. Select which one you want to access:')
+
+        instance_ids[index]
+      end
+
+      def select_index_from_array(array, retry_message:)
+        while (index = STDIN.gets.chomp)
+          if index =~ /\A[1-9][0-9]*\Z/ && (index.to_i - 1) < array.count
+            index = index.to_i - 1
+            break
+          end
+
+          EcsDeployCli.logger.info(retry_message)
+        end
+        index
+      end
+
+      def load_dns_name_from_instance_id(instance_id)
         response = ec2_client.describe_instances(
-          instance_ids: instance_ids
+          instance_ids: [instance_id]
         )
 
         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]
+      def load_container_instances(params = {})
+        task_arns = ecs_client.list_tasks(
+          **params.merge(cluster: config[:cluster])
+        ).to_h[:task_arns]
+
+        tasks = ecs_client.describe_tasks(
+          tasks: task_arns, cluster: config[:cluster]
+        ).to_h[:tasks]
 
+        instances = tasks.map { |task| task[:container_instance_arn] }.uniq
         response = ecs_client.describe_container_instances(
           cluster: config[:cluster],
           container_instances: instances

spec/ecs_deploy_cli/runner_spec.rb

@@ -110,28 +110,67 @@
         subject.setup!
       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')])
-                   ])
-          )
+      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)
 
-        expect(Process).to receive(:fork) do |&block|
-          block.call
+          subject.ssh
         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)
+        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')
 
-        subject.ssh
+          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