ecs_deploy_cli 0.1.0 → 0.4.0

data/lib/ecs_deploy_cli/runners/diff.rb

@@ -0,0 +1,74 @@
+# 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 = cleanup_source_task(result[:task_definition])
+          definition = cleanup_source_task(definition)
+
+          print_diff Hashdiff.diff(current.except(:container_definitions), definition.except(:container_definitions))
+
+          diff_container_definitions(
+            current[:container_definitions],
+            definition[:container_definitions]
+          )
+
+          EcsDeployCli.logger.info '---'
+        end
+      end
+
+      private
+
+      def diff_container_definitions(first, second)
+        first.zip(second).each do |a, b|
+          EcsDeployCli.logger.info "Container #{a&.dig(:name) || 'NONE'} <=> #{b&.dig(:name) || 'NONE'}"
+
+          next if !a || !b
+
+          sort_envs! a
+          sort_envs! b
+
+          print_diff Hashdiff.diff(a.delete_if { |_, v| v.nil? }, b.delete_if { |_, v| v.nil? })
+        end
+      end
+
+      def sort_envs!(definition)
+        return unless definition[:environment]
+
+        definition[:environment].sort_by! { |e| e[:name] }
+      end
+
+      def cleanup_source_task(task)
+        task.except(
+          :revision, :compatibilities, :status, :registered_at, :registered_by,
+          :requires_attributes, :task_definition_arn
+        ).delete_if { |_, v| v.nil? }
+      end
+
+      def print_diff(diff)
+        diff.each do |(op, path, *values)|
+          case op
+          when '-'
+            EcsDeployCli.logger.info "#{op} #{path} => #{values.join(' ')}".colorize(:red)
+          when '+'
+            EcsDeployCli.logger.info "#{op} #{path} => #{values.join(' ')}".colorize(:green)
+          else
+            EcsDeployCli.logger.info "#{op} #{path} => #{values.join(' ')}".colorize(:yellow)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/runners/logs.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class Logs < Base
+      def run!
+        # _, tasks, = @parser.resolve
+
+        # tasks.
+        # cwl_client.
+      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/setup.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class Setup < Base
+      def run!
+        services, resolved_tasks, _, cluster_options = @parser.resolve
+
+        setup_cluster! cluster_options
+        setup_services! services, resolved_tasks: resolved_tasks
+      end
+
+      private
+
+      def setup_cluster!(cluster_options)
+        clusters = ecs_client.describe_clusters(clusters: [config[:cluster]]).to_h[:clusters]
+        if clusters.length == 1
+          EcsDeployCli.logger.info 'Cluster already created, skipping.'
+          return
+        end
+
+        EcsDeployCli.logger.info "Creating cluster #{config[:cluster]}..."
+
+        params = create_params(cluster_options)
+
+        ecs_client.create_cluster(
+          cluster_name: config[:cluster]
+        )
+
+        stack_name = "EC2ContainerService-#{config[:cluster]}"
+
+
+        cf_client.create_stack(
+          stack_name: stack_name,
+          template_body: File.read(File.join(__dir__, '..', 'cloudformation', 'default.yml')),
+          on_failure: 'ROLLBACK',
+          parameters: format_cloudformation_params(params)
+        )
+
+        cf_client.wait_until(:stack_create_complete, { stack_name: stack_name }, delay: 30, max_attempts: 120)
+        EcsDeployCli.logger.info "Cluster #{config[:cluster]} created!"
+      end
+
+      def setup_services!(services, resolved_tasks:)
+        services.each do |service_name, service_definition|
+          if ecs_client.describe_services(cluster: config[:cluster], services: [service_name]).to_h[:services].any?
+            EcsDeployCli.logger.info "Service #{service_name} already created, skipping."
+            next
+          end
+
+          EcsDeployCli.logger.info "Creating service #{service_name}..."
+          task_definition = _update_task resolved_tasks[service_definition.options[:task]]
+          task_name = "#{task_definition[:family]}:#{task_definition[:revision]}"
+
+          ecs_client.create_service(
+            cluster: config[:cluster],
+            desired_count: 1,
+            load_balancers: service_definition.as_definition(task_definition)[:load_balancers],
+            service_name: service_name,
+            task_definition: task_name
+          )
+          EcsDeployCli.logger.info "Service #{service_name} created!"
+        end
+      end
+
+      def create_params(cluster_options)
+        raise ArgumentError, 'Missing vpc configuration' unless cluster_options[:vpc]
+
+        {
+          'AsgMaxSize' => cluster_options[:instances_count],
+          'AutoAssignPublicIp' => 'INHERIT',
+          'ConfigureDataVolume' => false,
+          'ConfigureRootVolume' => true,
+          'DeviceName' => cluster_options[:device_name],
+          'EbsVolumeSize' => cluster_options[:ebs_volume_size],
+          'EbsVolumeType' => cluster_options[:ebs_volume_type],
+          'EcsAmiId' => load_ami_id,
+          'EcsClusterName' => config[:cluster],
+          'EcsEndpoint' => nil,
+          'EcsInstanceType' => cluster_options[:instance_type],
+          'IamRoleInstanceProfile' => "arn:aws:iam::#{config[:aws_profile_id]}:instance-profile/ecsInstanceRole",
+          'IamSpotFleetRoleArn' => nil,
+          'IsWindows' => false,
+          'KeyName' => cluster_options[:keypair_name],
+          'RootDeviceName' => cluster_options[:root_device_name],
+          'RootEbsVolumeSize' => cluster_options[:root_ebs_volume_size],
+
+          ##### TODO: Implement this feature
+          'SecurityGroupId' => nil,
+          'SecurityIngressCidrIp' => '0.0.0.0/0',
+          'SecurityIngressFromPort' => 80,
+          'SecurityIngressToPort' =>	80,
+          #####
+
+          ##### TODO: Implement this feature
+          'SpotAllocationStrategy' =>	'diversified',
+          'SpotPrice' => nil,
+          'UseSpot' =>	false,
+          #####
+
+          'UserData' => "#!/bin/bash\necho ECS_CLUSTER=#{config[:cluster]} >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config;",
+          'VpcAvailabilityZones' => cluster_options.dig(:vpc, :availability_zones),
+          'VpcCidr' => cluster_options.dig(:vpc, :cidr),
+          'SubnetCidr1' => cluster_options.dig(:vpc, :subnet1),
+          'SubnetCidr2' => cluster_options.dig(:vpc, :subnet2),
+          'SubnetCidr3' => cluster_options.dig(:vpc, :subnet3),
+
+          'VpcId' => cluster_options.dig(:vpc, :id),
+          'SubnetIds' => cluster_options.dig(:vpc, :subnet_ids)
+        }
+      end
+
+      def format_cloudformation_params(params)
+        params.map { |k, v| { parameter_key: k, parameter_value: v.to_s } }
+      end
+
+      def load_ami_id
+        ami_data = ssm_client.get_parameter(
+          name: '/aws/service/ecs/optimized-ami/amazon-linux-2/recommended'
+        ).to_h[:parameter]
+
+        ami_details = JSON.parse(ami_data[:value]).with_indifferent_access
+
+        ami_details[:image_id]
+      end
+    end
+  end
+end

data/lib/ecs_deploy_cli/runners/ssh.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class SSH < Base
+      def run!(params = {})
+        instance_ids = load_container_instances(params)
+
+        instance_id = choose_instance_id(instance_ids)
+        dns_name = load_dns_name_from_instance_id(instance_id)
+        run_ssh(dns_name)
+      end
+
+      private
+
+      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_id]
+        )
+
+        response.reservations[0].instances[0].public_dns_name
+      end
+
+      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
+        )
+
+        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/status.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class Status < Base
+      def run!(service)
+        services, = @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]}"
+
+          puts ecs_client.describe_service(
+            cluster: config[:cluster],
+            service: service_name
+          )
+        end
+      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_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