capistrano-asg-rolling 0.1.0

data/lib/capistrano/asg/rolling/autoscale_group.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-autoscaling'
+
+module Capistrano
+  module ASG
+    module Rolling
+      # AWS EC2 Auto Scaling Group.
+      class AutoscaleGroup
+        include AWS
+
+        LIFECYCLE_STATE_IN_SERVICE = 'InService'
+        LIFECYCLE_STATE_STANDBY = 'Standby'
+
+        attr_reader :name, :properties
+
+        def initialize(name, properties = {})
+          @name = name
+          @properties = properties
+        end
+
+        def exists?
+          aws_autoscaling_group.exists?
+        end
+
+        def launch_template
+          @launch_template ||= begin
+            template = aws_autoscaling_group.launch_template
+            raise Capistrano::ASG::Rolling::NoLaunchTemplate if template.nil?
+
+            LaunchTemplate.new(template.launch_template_id, template.version)
+          end
+        end
+
+        def subnet_ids
+          aws_autoscaling_group.vpc_zone_identifier.split(',')
+        end
+
+        def instance_warmup_time
+          aws_autoscaling_group.health_check_grace_period
+        end
+
+        def start_instance_refresh
+          aws_autoscaling_client.start_instance_refresh(
+            auto_scaling_group_name: name,
+            strategy: 'Rolling',
+            preferences: {
+              instance_warmup: instance_warmup_time,
+              min_healthy_percentage: 100
+            }
+          )
+        end
+
+        # Returns instances with lifecycle state "InService" for this Auto Scaling Group.
+        def instances
+          instance_ids = aws_autoscaling_group.instances.select { |i| i.lifecycle_state == LIFECYCLE_STATE_IN_SERVICE }.map(&:instance_id)
+          return [] if instance_ids.empty?
+
+          response = aws_ec2_client.describe_instances(instance_ids: instance_ids)
+          response.reservations.flat_map(&:instances).map do |instance|
+            Instance.new(instance.instance_id, instance.private_ip_address, instance.public_ip_address, instance.image_id, self)
+          end
+        end
+
+        def enter_standby(instance)
+          instance = aws_autoscaling_group.instances.find { |i| i.id == instance.id }
+          return if instance.nil?
+
+          instance.enter_standby(should_decrement_desired_capacity: true)
+
+          loop do
+            instance.load
+            break if instance.lifecycle_state == LIFECYCLE_STATE_STANDBY
+
+            sleep 1
+          end
+        end
+
+        def exit_standby(instance)
+          instance = aws_autoscaling_group.instances.find { |i| i.id == instance.id }
+          return if instance.nil?
+
+          instance.exit_standby
+        end
+
+        def rolling?
+          properties.fetch(:rolling, true)
+        end
+
+        def name_tag
+          "Deployment for #{name}"
+        end
+
+        private
+
+        def aws_autoscaling_group
+          @aws_autoscaling_group ||= ::Aws::AutoScaling::AutoScalingGroup.new(name: name, client: aws_autoscaling_client)
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/asg/rolling/autoscale_groups.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Capistrano
+  module ASG
+    module Rolling
+      # Collection of Auto Scaling Groups.
+      class AutoscaleGroups
+        include Enumerable
+
+        def initialize(groups = [])
+          @groups = groups
+        end
+
+        def <<(group)
+          @groups << group
+        end
+
+        def each(&block)
+          @groups.reject { |group| filtered?(group) }.each(&block)
+        end
+
+        def with_launch_template(launch_template)
+          self.class.new(select { |group| group.launch_template == launch_template })
+        end
+
+        def update_launch_templates(amis:, description: nil)
+          launch_templates = Set.new
+
+          amis.each do |ami|
+            old_image_id = ami.instance.image_id
+            new_image_id = ami.id
+
+            find_launch_templates_for(image_id: old_image_id).each do |launch_template|
+              launch_templates << launch_template.create_version(image_id: new_image_id, description: description)
+            end
+          end
+
+          launch_templates
+        end
+
+        def start_instance_refresh
+          each(&:start_instance_refresh)
+        end
+
+        private
+
+        def filtered?(group)
+          return false if Configuration.auto_scaling_group_name.nil?
+
+          Configuration.auto_scaling_group_name != group.name
+        end
+
+        def find_launch_templates_for(image_id:)
+          launch_templates = Set.new
+
+          each do |group|
+            launch_template = group.launch_template
+            next if launch_template.image_id != image_id
+
+            launch_templates << launch_template
+          end
+
+          launch_templates
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/asg/rolling/aws.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-autoscaling'
+require 'aws-sdk-ec2'
+
+module Capistrano
+  module ASG
+    module Rolling
+      # AWS SDK.
+      module AWS
+        def aws_autoscaling_client
+          @aws_autoscaling_client ||= ::Aws::AutoScaling::Client.new(aws_options)
+        end
+
+        def aws_ec2_client
+          @aws_ec2_client ||= ::Aws::EC2::Client.new(aws_options)
+        end
+
+        private
+
+        def aws_options
+          options = {}
+          options[:region] = aws_region if aws_region
+          options[:credentials] = aws_credentials if aws_credentials.set?
+          options[:http_wire_trace] = true if ENV['AWS_HTTP_WIRE_TRACE'] == '1'
+          options
+        end
+
+        def aws_credentials
+          ::Aws::Credentials.new(aws_access_key_id, aws_secret_access_key)
+        end
+
+        def aws_access_key_id
+          Configuration.aws_access_key_id
+        end
+
+        def aws_secret_access_key
+          Configuration.aws_secret_access_key
+        end
+
+        def aws_region
+          Configuration.aws_region
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/asg/rolling/configuration.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Capistrano
+  module ASG
+    module Rolling
+      # Singleton that holds the configuration.
+      module Configuration
+        extend Capistrano::DSL
+
+        module_function
+
+        # Registered Auto Scaling Groups.
+        def autoscale_groups
+          @autoscale_groups ||= AutoscaleGroups.new
+        end
+
+        # Launched Instances.
+        def instances
+          @instances ||= Instances.new
+        end
+
+        # Updated Launch Templates.
+        def launch_templates
+          @launch_templates ||= Set.new
+        end
+
+        def aws_access_key_id
+          fetch(:aws_access_key_id)
+        end
+
+        def aws_secret_access_key
+          fetch(:aws_secret_access_key)
+        end
+
+        def aws_region
+          fetch(:aws_region)
+        end
+
+        def auto_scaling_group_name
+          fetch(:asg_rolling_group_name)
+        end
+
+        def ssh_options
+          fetch(:asg_rolling_ssh_options, fetch(:ssh_options))
+        end
+
+        def instance_overrides
+          fetch(:asg_rolling_instance_overrides)
+        end
+
+        def use_private_ip_address?
+          fetch(:asg_rolling_use_private_ip_address)
+        end
+
+        def keep_versions
+          fetch(:asg_rolling_keep_versions, fetch(:keep_releases))
+        end
+
+        def verbose?
+          fetch(:asg_rolling_verbose)
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/asg/rolling/dsl.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module ASG
+    module Rolling
+      # Adds the autoscale DSL to the Capistrano configuration:
+      #
+      # autoscale 'my-asg', user: 'deployer', roles: %w(app assets)
+      #
+      module DSL
+        def autoscale(name, properties = {})
+          group = Capistrano::ASG::Rolling::AutoscaleGroup.new(name, properties)
+          raise Capistrano::ASG::Rolling::NoAutoScalingGroup, "Auto Scaling Group #{name} could not be found." unless group.exists?
+
+          Capistrano::ASG::Rolling::Configuration.autoscale_groups << group
+        end
+      end
+    end
+  end
+end
+
+extend Capistrano::ASG::Rolling::DSL # rubocop:disable Style/MixinUsage

data/lib/capistrano/asg/rolling/exception.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module ASG
+    module Rolling
+      # Base class for exceptions.
+      class Exception < StandardError
+      end
+
+      class NoAutoScalingGroup < Capistrano::ASG::Rolling::Exception
+      end
+
+      class NoLaunchTemplate < Capistrano::ASG::Rolling::Exception
+      end
+    end
+  end
+end

data/lib/capistrano/asg/rolling/instance.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Capistrano
+  module ASG
+    module Rolling
+      # AWS EC2 instance.
+      class Instance
+        include AWS
+
+        attr_reader :id, :private_ip_address, :public_ip_address, :image_id, :autoscale_group
+        attr_accessor :auto_terminate, :terminated
+        alias auto_terminate? auto_terminate
+        alias terminated? terminated
+
+        def initialize(id, private_ip_address, public_ip_address, image_id, autoscale_group)
+          @id = id
+          @private_ip_address = private_ip_address
+          @public_ip_address = public_ip_address
+          @image_id = image_id
+          @autoscale_group = autoscale_group
+          @auto_terminate = true
+          @terminated = false
+        end
+
+        # Launch a new instance based on settings from Auto Scaling Group and associated Launch Template.
+        def self.run(autoscaling_group:, overrides: nil)
+          launch_template = autoscaling_group.launch_template
+
+          aws_ec2_client = autoscaling_group.aws_ec2_client
+          options = {
+            min_count: 1,
+            max_count: 1,
+            launch_template: {
+              launch_template_id: launch_template.id,
+              version: launch_template.version
+            }
+          }
+
+          # Add a subnet defined in the Auto Scaling Group, but only when the Launch Template
+          # does not define a network interface. Otherwise it will trigger the following error:
+          # => Network interfaces and an instance-level subnet ID may not be specified on the same request
+          options[:subnet_id] = autoscaling_group.subnet_ids.sample if launch_template.network_interfaces.empty?
+
+          # Optionally override settings in the Launch Template.
+          options.merge!(overrides) if overrides
+
+          options[:tag_specifications] = [
+            { resource_type: 'instance', tags: [{ key: 'Name', value: autoscaling_group.name_tag }] },
+            { resource_type: 'volume', tags: [{ key: 'Name', value: autoscaling_group.name_tag }] }
+          ]
+
+          response = aws_ec2_client.run_instances(options)
+
+          instance = response.instances.first
+
+          # Wait until the instance is running and has a public IP address.
+          aws_instance = ::Aws::EC2::Instance.new(instance.instance_id, client: aws_ec2_client)
+          instance = aws_instance.wait_until_running
+
+          new(instance.instance_id, instance.private_ip_address, instance.public_ip_address, instance.image_id, autoscaling_group)
+        end
+
+        def wait_for_ssh
+          started_at = Time.now
+
+          loop do
+            result = SSH.test?(ip_address, autoscale_group.properties[:user], Configuration.ssh_options)
+
+            break if result || Time.now - started_at > 300
+
+            sleep 1
+          end
+        end
+
+        def ip_address
+          Configuration.use_private_ip_address? ? private_ip_address : public_ip_address
+        end
+
+        def stop
+          aws_ec2_client.stop_instances(instance_ids: [id])
+          aws_ec2_client.wait_until(:instance_stopped, instance_ids: [id])
+        end
+
+        def terminate(wait: false)
+          aws_ec2_client.terminate_instances(instance_ids: [id])
+          aws_ec2_client.wait_until(:instance_terminated, instance_ids: [id]) if wait
+
+          @terminated = true
+        end
+
+        def create_ami(name: nil, description: nil)
+          now = Time.now
+          name ||= "#{autoscale_group.name_tag} on #{now.strftime('%Y-%m-%d')} at #{now.strftime('%H.%M.%S')}"
+
+          AMI.create(instance: self, name: name, description: description, tags: { 'Name' => autoscale_group.name_tag })
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/asg/rolling/instances.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module ASG
+    module Rolling
+      # Collection of Instances. Runs commands on instances in parallel.
+      class Instances
+        include Enumerable
+
+        def initialize(instances = [])
+          @instances = instances
+        end
+
+        def <<(instance)
+          @instances << instance
+        end
+
+        def each(&block)
+          instances.each(&block)
+        end
+
+        def empty?
+          instances.empty?
+        end
+
+        def auto_terminate
+          self.class.new(select(&:auto_terminate?))
+        end
+
+        def with_image(image_id)
+          self.class.new(select { |instance| instance.image_id == image_id })
+        end
+
+        def wait_for_ssh
+          Parallel.run(instances, &:wait_for_ssh)
+        end
+
+        def stop
+          Parallel.run(instances, &:stop)
+        end
+
+        def terminate
+          Parallel.run(instances, &:terminate)
+        end
+
+        def create_ami(name: nil, description: nil)
+          Parallel.run(instances) do |instance|
+            instance.create_ami(name: name, description: description)
+          end
+        end
+
+        private
+
+        def instances
+          @instances.reject(&:terminated?)
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/asg/rolling/launch_template.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module ASG
+    module Rolling
+      # AWS EC2 Launch Template.
+      class LaunchTemplate
+        include AWS
+
+        attr_reader :id, :version, :default_version
+        alias default_version? default_version
+
+        def initialize(id, version, default_version: false)
+          @id = id
+          @version = version.to_s
+          @default_version = default_version
+        end
+
+        def create_version(image_id:, description: nil)
+          response = aws_ec2_client.create_launch_template_version(
+            launch_template_data: { image_id: image_id },
+            launch_template_id: id,
+            source_version: version,
+            version_description: description
+          )
+          version = response.launch_template_version
+
+          self.class.new(version.launch_template_id, version.version_number, default_version: version.default_version)
+        end
+
+        def delete
+          aws_ec2_client.delete_launch_template_versions(
+            launch_template_id: id,
+            versions: [version]
+          )
+        end
+
+        def ami
+          @ami ||= AMI.new(image_id)
+        end
+
+        def previous_versions
+          aws_ec2_client.describe_launch_template_versions(launch_template_id: id)
+                        .launch_template_versions
+                        .sort_by { |v| -v.version_number }
+                        .select { |v| v.version_number < version_number }
+                        .map { |v| self.class.new(v.launch_template_id, v.version_number, default_version: v.default_version) }
+        end
+
+        def version_number
+          aws_describe_launch_template_version.version_number
+        end
+
+        def image_id
+          aws_describe_launch_template_version.launch_template_data.image_id
+        end
+
+        def network_interfaces
+          aws_describe_launch_template_version.launch_template_data.network_interfaces
+        end
+
+        def security_group_ids
+          aws_describe_launch_template_version.launch_template_data.security_group_ids
+        end
+
+        # Object equality for Launch Templates is only by ID. Version number is deliberately not taken in account.
+        def ==(other)
+          id == other.id
+        end
+
+        alias eql? ==
+
+        def hash
+          id.hash
+        end
+
+        private
+
+        def aws_describe_launch_template_version
+          @aws_describe_launch_template_version ||=
+            aws_ec2_client.describe_launch_template_versions(launch_template_id: id, versions: [version])
+                          .launch_template_versions.first
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/asg/rolling/logger.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module ASG
+    module Rolling
+      # Logging support.
+      class Logger
+        def initialize(verbose: false)
+          @verbose = verbose
+        end
+
+        def info(text)
+          $stdout.puts format_text(text)
+        end
+
+        def error(text)
+          $stderr.puts color(format_text(text), :red) # rubocop:disable Style/StderrPuts
+        end
+
+        def verbose(text)
+          info(text) if @verbose
+        end
+
+        def bold(text, color = :light_white)
+          color(text, color, :bold)
+        end
+
+        def color(text, color, mode = nil)
+          _color.colorize(text, color, mode)
+        end
+
+        private
+
+        def format_text(text)
+          text.gsub(/\*\*(.+?)\*\*/, bold('\\1'))
+        end
+
+        def _color
+          @_color ||= SSHKit::Color.new($stdout)
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/asg/rolling/parallel.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'concurrent/array'
+
+module Capistrano
+  module ASG
+    module Rolling
+      # Simple helper for running code in parallel.
+      module Parallel
+        module_function
+
+        def run(work)
+          result = Concurrent::Array.new
+          threads = []
+
+          work.each do |w|
+            threads << Thread.new do
+              result << yield(w)
+            end
+          end
+
+          threads.each(&:join)
+
+          result
+        end
+      end
+    end
+  end
+end