ecs_deploy_cli 0.1.0 → 0.4.0

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/cluster.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module DSL
+    class Cluster
+      include AutoOptions
+
+      allowed_options :instances_count, :instance_type, :ebs_volume_size, :keypair_name
+
+      def initialize(name, config)
+        @config = config
+        _options[:name] = name.to_s
+      end
+
+      def vpc(id = nil, &block)
+        @vpc = VPC.new(id)
+        @vpc.instance_exec(&block)
+      end
+
+      def as_definition
+        {
+          instances_count: 1,
+
+          device_name: '/dev/xvda',
+          ebs_volume_size: 22,
+          ebs_volume_type: 'gp2',
+
+          root_device_name: '/dev/xvdcz',
+          root_ebs_volume_size: 30,
+
+          vpc: @vpc&.as_definition
+        }.merge(_options)
+      end
+
+      class VPC
+        include AutoOptions
+        allowed_options :cidr, :subnet1, :subnet2, :subnet3
+
+        def initialize(id)
+          _options[:id] = id
+        end
+
+        def availability_zones(*values)
+          _options[:availability_zones] = values.join(',')
+        end
+
+        def subnet_ids(*values)
+          _options[:subnet_ids] = values.join(',')
+        end
+
+        def as_definition
+          validate! if _options[:id]
+
+          {
+            cidr: '10.0.0.0/16',
+            subnet1: '10.0.0.0/24',
+            subnet2: '10.0.1.0/24',
+            subnet3: '10.0.2.0/24'
+          }.merge(_options)
+        end
+
+        def validate!
+          [
+            :subnet1, :subnet_ids, :availability_zones
+          ].each { |key| raise "Missing required parameter #{key}" unless _options[key] }
+        end
+      end
+    end
+  end
+end

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
@@ -62,6 +56,10 @@ module EcsDeployCli
 
       def as_definition
         {
+          cpu: 0,
+          mount_points: [],
+          port_mappings: [],
+          volumes_from: [],
           memory_reservation: nil,
           essential: true
         }.merge(_options)

data/lib/ecs_deploy_cli/dsl/parser.rb

@@ -40,8 +40,11 @@ module EcsDeployCli
         @crons[name].instance_exec(&block)
       end
 
-      def cluster(name)
+      def cluster(name, &block)
         config[:cluster] = name
+        @cluster ||= {}.with_indifferent_access
+        @cluster = Cluster.new(name, config)
+        @cluster.instance_exec(&block) if block
       end
 
       def config
@@ -55,10 +58,11 @@ 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) }
-        [@services, resolved_tasks, resolved_crons]
+        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_cluster = @cluster.as_definition
+        [@services, resolved_tasks, resolved_crons, resolved_cluster]
       end
 
       def self.load(file)

data/lib/ecs_deploy_cli/dsl/service.rb

@@ -18,13 +18,42 @@ module EcsDeployCli
         _options
       end
 
+      def load_balancer(name, &block)
+        @load_balancers ||= []
+
+        load_balancer = LoadBalancer.new(name, @config)
+        load_balancer.instance_exec(&block)
+
+        @load_balancers << load_balancer
+      end
+
       def as_definition(task)
         {
           cluster: @config[:cluster],
-          service: service_name,
-          task_definition: task
+          service: _options[:service],
+          task_definition: task,
+          load_balancers: @load_balancers&.map(&:as_definition) || []
         }
       end
+
+      class LoadBalancer
+        include AutoOptions
+        allowed_options :container_name, :container_port
+
+        def initialize(name, config)
+          _options[:load_balancer_name] = name
+          @config = config
+        end
+
+        def target_group_arn(value)
+          _options[:target_group_arn] = "arn:aws:elasticloadbalancing:#{@config[:aws_region]}:#{@config[:aws_profile_id]}:targetgroup/#{value}"
+          _options.delete(:load_balancer_name)
+        end
+
+        def as_definition
+          _options
+        end
+      end
     end
   end
 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,153 +1,54 @@
+# 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'
+require 'ecs_deploy_cli/runners/setup'
+
 module EcsDeployCli
   class Runner
     def initialize(parser)
       @parser = parser
     end
 
+    def setup!
+      EcsDeployCli::Runners::Setup.new(@parser).run!
+    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]
-        )
-
-        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
+      EcsDeployCli::Runners::UpdateCrons.new(@parser).run!
     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)
-      )
+    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
 
-      dns_name = response.reservations[0].instances[0].public_dns_name
-      EcsDeployCli.logger.info "Connecting to ec2-user@#{dns_name}..."
+    def ssh(**options)
+      EcsDeployCli::Runners::SSH.new(@parser).run!(options)
+    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,105 @@
+# frozen_string_literal: true
+
+module EcsDeployCli
+  module Runners
+    class Base
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def run!
+        raise NotImplementedError, 'abstract method'
+      end
+
+      def update_task(definition)
+        _update_task(definition)
+      end
+
+      protected
+
+      def _update_task(definition)
+        definition[:container_definitions].each do |container|
+          next unless container.dig(:log_configuration, :log_driver) == 'awslogs'
+
+          _create_cloudwatch_logs_if_needed(container.dig(:log_configuration, :options, 'awslogs-group'))
+        end
+
+        ecs_client.register_task_definition(
+          definition
+        ).to_h[:task_definition]
+      end
+
+      def _create_cloudwatch_logs_if_needed(prefix)
+        log_group = cwl_client.describe_log_groups(log_group_name_prefix: prefix, limit: 1).to_h[:log_groups]
+        return if log_group.any?
+
+        cwl_client.create_log_group(log_group_name: prefix)
+        cwl_client.put_retention_policy(
+          log_group_name: prefix,
+          retention_in_days: 14
+        )
+      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 ssm_client
+        @cwl_client ||= begin
+          require 'aws-sdk-ssm'
+          Aws::SSM::Client.new(
+            profile: ENV.fetch('AWS_PROFILE', 'default'),
+            region: config[:aws_region]
+          )
+        end
+      end
+
+      def cwl_client
+        @cwl_client ||= begin
+          require 'aws-sdk-cloudwatchlogs'
+          Aws::CloudWatchLogs::Client.new(
+            profile: ENV.fetch('AWS_PROFILE', 'default'),
+            region: config[:aws_region]
+          )
+        end
+      end
+
+      def cf_client
+        @cl_client ||= begin
+          require 'aws-sdk-cloudformation'
+          Aws::CloudFormation::Client.new(
+            profile: ENV.fetch('AWS_PROFILE', 'default'),
+            region: config[:aws_region]
+          )
+        end
+      end
+
+      def config
+        @parser.config
+      end
+    end
+  end
+end