cf_deployer 1.2.8

data/lib/cf_deployer/deployment_strategy/auto_scaling_group_swap.rb

@@ -0,0 +1,102 @@
+module CfDeployer
+  module DeploymentStrategy
+    class AutoScalingGroupSwap < BlueGreen
+
+      
+      def deploy
+        check_blue_green_not_both_active 'Deployment'
+        Log.info "Found active stack #{active_stack.name}" if active_stack
+        delete_stack inactive_stack
+        create_inactive_stack
+        swap_group
+        run_hook(:'after-swap')
+        Log.info "Active stack has been set to #{inactive_stack.name}"
+        delete_stack(active_stack) if active_stack && !keep_previous_stack
+        Log.info "#{component_name} deployed successfully"
+      end
+
+
+      def kill_inactive
+        check_blue_green_not_both_active 'Kill Inactive'
+        raise ApplicationError.new('Only one color stack exists, cannot kill a non-existant version!') unless both_stacks_exist?
+        delete_stack inactive_stack
+      end
+
+      def switch
+        check_blue_green_not_both_active 'Switch'
+        raise ApplicationError.new('Only one color stack exists, cannot switch to a non-existent version!') unless both_stacks_exist?
+        warm_up_cooled = true
+        swap_group warm_up_cooled
+      end
+
+      private
+
+
+      def check_blue_green_not_both_active action
+        active_stacks = get_active_asg(active_stack) + get_active_asg(inactive_stack)
+        raise BothStacksActiveError.new("Found both auto-scaling-groups, #{active_stacks}, in green and blue stacks are active. #{action} aborted!") if both_stacks_active?
+      end
+
+      def swap_group is_switching_to_cooled = false
+        is_switching_to_cooled ? warm_up_cooled_stack : warm_up_inactive_stack
+        cool_down_active_stack if active_stack && (is_switching_to_cooled || keep_previous_stack)
+      end
+
+      def keep_previous_stack
+        context[:settings][:'keep-previous-stack']
+      end
+
+      def create_inactive_stack
+        inactive_stack.deploy
+        get_parameters_outputs(inactive_stack)
+        run_hook(:'after-create')
+      end
+
+      def both_stacks_active?
+        active_stack && stack_active?(inactive_stack)
+      end
+
+
+      def warm_up_cooled_stack
+        group_ids(active_stack).each_with_index do |id, index|
+          min_max_desired = asg_driver(id).describe
+          asg_driver(group_ids(inactive_stack)[index]).warm_up_cooled_group min_max_desired
+        end
+      end
+
+      def cool_down_active_stack
+        group_ids(active_stack).each do |id|
+          asg_driver(id).cool_down
+        end
+
+      end
+
+    
+      def stack_active?(stack)
+        return false unless stack.exists?
+        get_active_asg(stack).any?
+      end
+
+
+      
+      def get_active_asg stack
+        return [] unless stack && stack.exists?
+        group_ids(stack).select do |id|
+          result = asg_driver(id).describe
+          result[:min] > 0  && result[:max] > 0 && result[:desired] > 0
+        end
+      end
+
+      def asg_driver name
+        @auto_scaling_group_drivers[name] ||= CfDeployer::Driver::AutoScalingGroup.new name
+      end
+
+      def asg_id_outputs
+        @context[:settings][:'auto-scaling-group-name-output']
+      end
+
+      class BothStacksActiveError < ApplicationError
+      end
+    end
+  end
+end

data/lib/cf_deployer/deployment_strategy/base.rb

@@ -0,0 +1,88 @@
+
+module CfDeployer
+  module DeploymentStrategy
+
+    def self.create application_name, environment_name, component_name, context
+      context[:'deployment-strategy'] ||= 'create-or-update'
+      strategy_class_name = 'CfDeployer::DeploymentStrategy::' + context[:'deployment-strategy'].split('-').map(&:capitalize).join
+      begin
+        eval(strategy_class_name).new  application_name, component_name, environment_name, context
+      rescue
+        raise ApplicationError.new 'strategy_name: ' + strategy_class_name + ' not supported'
+      end
+    end
+
+    class Base
+      BLUE_GREEN_STRATEGY = true
+
+      attr_reader :context, :component_name, :application_name, :environment_name
+      def initialize(application_name, component_name, environment_name, context)
+        @application_name = application_name
+        @component_name = component_name
+        @environment_name = environment_name
+        @context = context
+        @auto_scaling_group_drivers = {}
+      end
+
+      def blue_green_strategy?
+        BLUE_GREEN_STRATEGY
+      end
+
+      protected
+
+      def stack_prefix
+        "#{@application_name}-#{@environment_name}-#{@component_name}"
+      end
+
+      def delete_stack(stack)
+        # Should this be stack.ready?  Outputs won't exist if the stack is still starting.
+        unless stack.exists?
+          CfDeployer::Log.info "Skipping deleting stack #{stack.name} since it doesn't exist."
+          return
+        end
+        get_parameters_outputs stack
+        run_hook :'before-destroy'
+        stack.delete
+      end
+
+      def run_hook(hook_name)
+        CfDeployer::Driver::DryRun.guard "Skipping hook #{hook_name}" do
+          hook = Hook.new hook_name, context[hook_name]
+          hook.run context
+        end
+      end
+
+      def get_parameters_outputs(stack)
+        CfDeployer::Driver::DryRun.guard "Skipping get_parameters_outputs" do
+          context[:parameters] = stack.parameters
+          context[:outputs] = stack.outputs
+        end
+      end
+
+      def warm_up_inactive_stack
+        group_ids(inactive_stack).each_with_index do |id, index|
+          asg_driver(id).warm_up get_desired(id, index)
+        end
+      end
+
+      def get_desired(id, index)
+        group_id =  active_stack ? group_ids(active_stack)[index] : id
+        asg_driver(group_id).describe[:desired]
+      end
+
+      def group_ids(stack)
+        return [] unless asg_id_outputs
+        asg_id_outputs.map { |id| stack.output id }
+      end
+
+      def asg_driver name
+        @auto_scaling_group_drivers[name] ||= CfDeployer::Driver::AutoScalingGroup.new name
+      end
+
+      def asg_id_outputs
+        @context[:settings][:'auto-scaling-group-name-output']
+      end
+
+    end
+  end
+end

data/lib/cf_deployer/deployment_strategy/blue_green.rb

@@ -0,0 +1,70 @@
+module CfDeployer
+  module DeploymentStrategy
+    class BlueGreen < Base
+
+      def exists?
+        green_stack.exists? || blue_stack.exists?
+      end
+
+      def destroy
+        delete_stack green_stack
+        delete_stack blue_stack
+      end
+
+
+      def output_value(key)
+        active_stack ? active_stack.output(key) : "The value will be referenced from the output #{key} of undeployed component #{component_name}"
+      end
+
+      def status get_resource_statuses = false
+        my_status = {}
+        [blue_stack, green_stack].each do |the_stack|
+          my_status[the_stack.name] = {}
+          my_status[the_stack.name][:active] = stack_active?(the_stack)
+          my_status[the_stack.name][:status] = the_stack.status
+          my_status[the_stack.name][:resources] = the_stack.resource_statuses if the_stack.exists? && get_resource_statuses
+        end
+        my_status
+      end
+
+      private
+
+      def blue_stack
+        name = "#{stack_prefix}-B"
+        Stack.new(name, component_name, context)
+      end
+
+      def green_stack
+        name = "#{stack_prefix}-G"
+        Stack.new(name, component_name, context)
+      end
+
+      def both_stacks_exist?
+        blue_stack.exists? && green_stack.exists?
+      end
+
+      def active_stack
+        @active_stack = get_active_stack unless @active_stack_checked
+        @active_stack
+      end
+
+      def inactive_stack
+        @inactive_stack ||= get_inactive_stack
+      end
+
+      def get_inactive_stack
+        return blue_stack unless active_stack
+        stack_active?(green_stack) ? blue_stack : green_stack
+      end
+
+      def get_active_stack
+        @active_stack_checked = true
+        return green_stack if stack_active?(green_stack)
+        return blue_stack if stack_active?(blue_stack)
+        nil
+      end
+
+
+    end
+  end
+end

data/lib/cf_deployer/deployment_strategy/cname_swap.rb

@@ -0,0 +1,108 @@
+module CfDeployer
+  module DeploymentStrategy
+    class CnameSwap < BlueGreen
+
+      def deploy
+        Log.info "Found active stack #{active_stack.name}" if active_stack
+        delete_stack inactive_stack
+        create_inactive_stack
+        warm_up_inactive_stack
+        swap_cname
+        Kernel.sleep 60
+        run_hook(:'after-swap')
+        Log.info "Active stack has been set to #{inactive_stack.name}"
+        delete_stack(active_stack) if active_stack && !settings[:'keep-previous-stack']
+        Log.info "#{component_name} deployed successfully"
+      end
+
+
+      def kill_inactive
+        raise ApplicationError.new("Stack: #{inactive_stack.name} does not exist, cannot kill it.") unless inactive_stack.exists?
+        delete_stack inactive_stack
+      end
+
+      def switch
+        raise ApplicationError.new('There is only one color stack active, you cannot switch back to a non-existent version') unless both_stacks_exist?
+        swap_cname
+        Log.info "Active stack has been set to #{inactive_stack.name}"
+        Log.info "#{component_name} switched successfully"
+      end
+
+      private
+
+
+      def active_cname
+        @active_cname ||= get_active_cname
+      end
+
+
+
+      def create_inactive_stack
+        inactive_stack.deploy
+        get_parameters_outputs(inactive_stack)
+        run_hook(:'after-create')
+      end
+
+      def swap_cname
+        set_cname_to(inactive_stack)
+      end
+
+      def set_cname_to(stack)
+        cname, zone_id =  find_elb_cname_for_stack(stack, elb_output_key)
+        dns_driver.set_alias_target(dns_zone, dns_fqdn, zone_id, cname)
+      end
+
+
+      def stack_active?(stack)
+        return false unless stack.exists?
+        return false unless active_cname.length > 0
+        cname, zone_id = find_elb_cname_for_stack(stack, elb_output_key)
+        active_cname.downcase == cname.downcase
+      end
+
+
+      def get_active_cname
+        dns_driver.find_alias_target(dns_zone, dns_fqdn) || ""
+      end
+
+
+      def elb_output_key
+        settings[:'elb-name-output']
+      end
+
+      def dns_fqdn
+        settings[:'dns-fqdn']
+      end
+
+      def dns_zone
+        settings[:'dns-zone']
+      end
+
+      def dns_driver
+        context[:dns_driver] || string_to_class(settings[:'dns-driver'])
+      end
+
+      def elb_driver
+        context[:elb_driver] || CfDeployer::Driver::Elb.new
+      end
+
+      def settings
+        context[:settings]
+      end
+
+      def find_elb_cname_for_stack(stack, elb_name_output_key)
+        return ['', ''] unless stack.exists?
+        elb_id = stack.output(elb_name_output_key)
+        attrs = elb_driver.find_dns_and_zone_id(elb_id)
+        [attrs[:dns_name] || '', attrs[:canonical_hosted_zone_name_id] || '']
+      end
+
+      def string_to_class class_string
+        class_string.split('::').inject(Object) do |mod, class_name|
+          mod.const_get(class_name)
+        end.new
+      end
+
+    end
+  end
+end

data/lib/cf_deployer/deployment_strategy/create_or_update.rb

@@ -0,0 +1,57 @@
+module CfDeployer
+  module DeploymentStrategy
+    class CreateOrUpdate < Base
+      BLUE_GREEN_STRATEGY = false
+
+      def exists?
+        stack.exists?
+      end
+
+      def status get_resource_statuses = false
+        my_status = {}
+        my_status[stack.name] = {}
+        my_status[stack.name][:status] = stack.status
+        my_status[stack.name][:resources] = stack.resource_statuses if stack.exists? && get_resource_statuses
+        my_status
+      end
+
+
+      def deploy
+        stack.deploy
+        warm_up_inactive_stack
+        get_parameters_outputs(inactive_stack)
+        run_hook(:'after-create')
+      end
+
+      def output_value(key)
+        exists? ? stack.output(key) : "The value will be referenced from the output #{key} of undeployed component #{component_name}"
+      end
+
+      def destroy
+        delete_stack stack
+      end
+
+      def kill_inactive
+        raise ApplicationError.new('There is no inactive version to kill for Create or Update Deployments.')
+      end
+
+      def switch
+        raise ApplicationError.new('There is no inactive version to switch to for Create or Update Deployments.  Redeploy the version you want')
+      end
+
+      private
+
+      def stack
+        Stack.new(stack_prefix, @component_name, @context)
+      end
+
+      def inactive_stack
+        stack
+      end
+
+      def active_stack
+        nil
+      end
+    end
+  end
+end

data/lib/cf_deployer/driver/auto_scaling_group.rb

@@ -0,0 +1,86 @@
+module CfDeployer
+  module Driver
+    class AutoScalingGroup
+      extend Forwardable
+
+      def_delegators :aws_group, :auto_scaling_instances, :ec2_instances, :load_balancers
+
+      attr_reader :group_name, :group
+
+      def initialize name, timeout = CfDeployer::Defaults::Timeout
+        @group_name = name
+        @timeout = timeout
+      end
+
+      def describe
+        { desired: aws_group.desired_capacity, min: aws_group.min_size, max: aws_group.max_size }
+      end
+
+      def warm_up desired
+        return if desired < aws_group.min_size
+        desired = aws_group.max_size if desired > aws_group.max_size
+        Log.info "warming up auto scaling group #{group_name} to #{desired}"
+
+        CfDeployer::Driver::DryRun.guard "Skipping ASG warmup" do
+          aws_group.set_desired_capacity desired
+          wait_for_healthy_instance desired
+        end
+      end
+
+      def warm_up_cooled_group options
+        CfDeployer::Driver::DryRun.guard 'Skipping update of ASG min & max instance count' do
+          aws_group.update :min_size =>  options[:min], :max_size => options[:max]
+        end
+        warm_up options[:desired]
+      end
+
+      def cool_down
+        Log.info "Cooling down #{group_name}"
+        CfDeployer::Driver::DryRun.guard "Skipping ASG cooldown" do
+          aws_group.update :min_size => 0, :max_size => 0
+          aws_group.set_desired_capacity 0
+        end
+      end
+
+      def instance_statuses
+        instance_info = {}
+        ec2_instances.each do |instance|
+          instance_info[instance.id] = CfDeployer::Driver::Instance.new(instance).status
+        end
+        instance_info
+      end
+
+      private
+
+      def healthy_instance_count
+        count = auto_scaling_instances.count do |instance|
+          instance.health_status == 'HEALTHY' && (load_balancers.empty? || instance_in_service?( instance.ec2_instance ))
+        end
+        Log.info "Healthy instance count: #{count}"
+        count
+      end
+
+      def instance_in_service? instance
+        load_balancers.all? do |load_balancer|
+          load_balancer.instances.health.any? do |health|
+            health[:instance] == instance ? health[:state] == 'InService' : false
+          end
+        end
+      end
+
+      def wait_for_healthy_instance number
+        Timeout::timeout(@timeout){
+          while healthy_instance_count != number
+            sleep 15
+          end
+        }
+      end
+
+
+      def aws_group
+        @my_group ||= AWS::AutoScaling.new.groups[group_name]
+      end
+
+    end
+  end
+end

data/lib/cf_deployer/driver/cloud_formation_driver.rb

@@ -0,0 +1,85 @@
+module CfDeployer
+  module Driver
+    class CloudFormation
+
+      def initialize stack_name
+        @stack_name = stack_name
+      end
+
+      def stack_exists?
+        aws_stack.exists?
+      end
+
+      def create_stack template, opts
+        CfDeployer::Driver::DryRun.guard "Skipping create_stack" do
+          cloud_formation.stacks.create @stack_name, template, opts
+        end
+      end
+
+      def update_stack template, opts
+        begin
+          CfDeployer::Driver::DryRun.guard "Skipping update_stack" do
+            aws_stack.update opts.merge(:template => template)
+          end
+        rescue AWS::CloudFormation::Errors::ValidationError => e
+          if e.message =~ /No updates are to be performed/
+            Log.info e.message
+          else
+            raise
+          end
+        end
+      end
+
+      def stack_status
+        aws_stack.status.downcase.to_sym
+      end
+
+      def outputs
+        aws_stack.outputs.inject({}) do |memo, o|
+          memo[o.key] = o.value
+          memo
+        end
+      end
+
+      def parameters
+        aws_stack.parameters
+      end
+
+      def query_output key
+        output = aws_stack.outputs.find { |o| o.key == key }
+        output && output.value
+      end
+
+      def delete_stack
+        if stack_exists?
+          CfDeployer::Driver::DryRun.guard "Skipping create_stack" do
+            aws_stack.delete
+          end
+        else
+          Log.info "Stack #{@stack_name} does not exist!"
+        end
+      end
+
+      def resource_statuses
+        resources = {}
+        aws_stack.resource_summaries.each do |rs|
+          resources[rs[:resource_type]] ||= {}
+          resources[rs[:resource_type]][rs[:physical_resource_id]] = rs[:resource_status]
+        end
+        resources
+      end
+
+      private
+
+      def cloud_formation
+        AWS::CloudFormation.new
+      end
+
+      def aws_stack
+        cloud_formation.stacks[@stack_name]
+      end
+
+    end
+
+  end
+end

data/lib/cf_deployer/driver/dry_run.rb

@@ -0,0 +1,27 @@
+module CfDeployer
+  module Driver
+    class DryRun
+
+      @@enabled = false
+
+      def self.enable
+        CfDeployer::Log.info "Enabling Dry-Run Mode"
+        @@enabled = true
+      end
+
+      def self.disable
+        CfDeployer::Log.info "Disabling Dry-Run Mode"
+        @@enabled = false
+      end
+
+      def self.guard description
+        if @@enabled
+          CfDeployer::Log.info "<Dry Run Enabled>  #{description}"
+        else
+          yield
+        end
+      end
+
+    end
+  end
+end

data/lib/cf_deployer/driver/elb_driver.rb

@@ -0,0 +1,17 @@
+module CfDeployer
+  module Driver
+    class Elb
+      def find_dns_and_zone_id elb_id
+        elb = elb_driver.load_balancers[elb_id]
+        { :canonical_hosted_zone_name_id => elb.canonical_hosted_zone_name_id, :dns_name => elb.dns_name }
+      end
+
+      private
+
+      def elb_driver
+        AWS::ELB.new
+      end
+
+    end
+  end
+end

data/lib/cf_deployer/driver/instance.rb

@@ -0,0 +1,29 @@
+module CfDeployer
+  module Driver
+    class Instance
+
+      GOOD_STATUSES = [ :running, :pending ]
+
+      def initialize instance_obj_or_id
+        if instance_obj_or_id.is_a?(String)
+          @id = instance_obj_or_id
+        else
+          @instance_obj = instance_obj_or_id
+        end
+      end
+
+      def status
+        instance_info = { }
+        [:status, :public_ip_address, :private_ip_address, :image_id].each do |stat|
+          instance_info[stat] = aws_instance.send(stat)
+        end
+        instance_info[:key_pair] = aws_instance.key_pair.name
+        instance_info
+      end
+
+      def aws_instance
+        @instance_obj ||= AWS::EC2.new.instances[@id]
+      end
+    end
+  end
+end