cf_deployer 1.2.8

data/lib/cf_deployer/driver/route53_driver.rb

@@ -0,0 +1,79 @@
+module CfDeployer
+  module Driver
+    class Route53
+      def initialize(aws_route53 = nil)
+        @aws_route53 = aws_route53 || AWS::Route53.new
+      end
+
+      def find_alias_target(target_zone_name, target_host_name)
+        target_zone = @aws_route53.hosted_zones.find { |z| z.name == trailing_dot(target_zone_name.downcase) }
+        raise ApplicationError.new('Target zone not found!') if target_zone.nil?
+
+        target_host = target_zone.resource_record_sets.find { |r| r.name == trailing_dot(target_host_name.downcase) }
+        return nil if target_host.nil? || target_host.alias_target.nil?
+
+        remove_trailing_dot(target_host.alias_target[:dns_name])
+      end
+
+      def set_alias_target(target_zone_name, target_host_name, elb_hosted_zone_id, elb_dnsname)
+        Log.info "set alias target --Hosted Zone: #{target_zone_name} --Host Name: #{target_host_name} --ELB DNS Name: #{elb_dnsname} --ELB Zone ID: #{elb_hosted_zone_id}"
+        target_zone_name = trailing_dot(target_zone_name)
+        target_host_name = trailing_dot(target_host_name)
+        target_zone = @aws_route53.hosted_zones.find { |z| z.name == target_zone_name }
+        raise ApplicationError.new('Target zone not found!') if target_zone.nil?
+
+        change = {
+          action: "UPSERT",
+          resource_record_set: {
+            name: target_host_name,
+            type: "A",
+            alias_target: {
+              dns_name: elb_dnsname,
+              hosted_zone_id: elb_hosted_zone_id,
+              evaluate_target_health: false
+            }
+          }
+        }
+
+        batch = {
+          hosted_zone_id: target_zone.path,
+          change_batch: {
+            changes: [change]
+          }
+        }
+
+        CfDeployer::Driver::DryRun.guard "Skipping Route53 DNS update" do
+          change_resource_record_sets_with_retry(batch)
+        end
+      end
+
+      private
+
+      def change_resource_record_sets_with_retry(batch)
+        attempts = 0
+        while attempts < 20
+          begin
+            attempts = attempts + 1
+            @aws_route53.client.change_resource_record_sets(batch)
+            return
+          rescue Exception => e
+            Log.info "Failed to update alias target, trying again in 20 seconds."
+            sleep(20)
+          end
+        end
+
+        raise ApplicationError.new('Failed to update Route53 alias target record!')
+      end
+
+      def trailing_dot(text)
+        return text if text[-1] == '.'
+        "#{text}."
+      end
+
+      def remove_trailing_dot(text)
+        return text[0..-2] if text && text[-1] == '.'
+        text
+      end
+    end
+  end
+end

data/lib/cf_deployer/driver/verisign_driver.rb

@@ -0,0 +1,21 @@
+##  To use this driver instead of Route53 (the default), use the setting 'dns-driver'
+
+module CfDeployer
+  module Driver
+    class Verisign
+
+      def find_alias_target dns_zone, dns_fqdn
+        raise "Not Implemented"
+      end
+
+      def set_alias_target dns_zone, dns_fqdn, elb_hosted_zone_id, elb_dnsname
+        raise "Not Implemented"
+
+        CfDeployer::Driver::DryRun.guard "Skipping Verisign DNS update" do
+          # do update here
+        end
+      end
+
+    end
+  end
+end

data/lib/cf_deployer/hook.rb

@@ -0,0 +1,32 @@
+module CfDeployer
+  class Hook
+    def initialize(name, body)
+      @name = name
+      @body = body
+    end
+
+    def run(context)
+      case @body
+      when Hash
+        if @body[:file]
+          file = File.expand_path(@body[:file], context[:config_dir])
+          execute(File.read(file), context, @body[:timeout])
+        else
+          execute(@body[:code], context, @body[:timeout])
+        end
+      when String
+        execute(@body, context)
+      end
+    end
+
+    private
+    def execute(hook, context, timeout = nil)
+      CfDeployer::Log.info("Running hook #{@name}")
+      context = context.dup
+      timeout = timeout || Defaults::Timeout
+      Timeout.timeout(timeout.to_f) do
+        eval(hook, binding)
+      end
+    end
+  end
+end

data/lib/cf_deployer/logger.rb

@@ -0,0 +1,34 @@
+module CfDeployer
+  class Log
+    require 'log4r'
+    include Log4r
+
+    def self.debug(message)
+      log.debug message
+    end
+
+    def self.info(message)
+      log.info message
+    end
+
+    def self.log
+      return @log if @log
+      @log = Logger.new('cf_deployer')
+      outputter = Outputter.stdout
+      outputter.formatter = PatternFormatter.new(:pattern => "%d [%l] (%c) %M", :date_pattern => "%y-%m-%d %H:%M:%S")
+      @log.outputters = outputter
+      @log.level = Log4r::INFO
+      @log
+    end
+
+    def self.level=(trace_level)
+      trace_level ||= 'info'
+      case trace_level.downcase
+       when 'debug'
+         log.level = Log4r::DEBUG
+       else
+         log.level = Log4r::INFO
+      end
+    end
+  end
+end

data/lib/cf_deployer/stack.rb

@@ -0,0 +1,154 @@
+module CfDeployer
+  class ResourceNotInReadyState < ApplicationError
+  end
+
+  class Stack
+    SUCCESS_STATS = [:create_complete, :update_complete, :update_rollback_complete, :delete_complete]
+    READY_STATS = SUCCESS_STATS - [:delete_complete]
+    FAILED_STATS = [:create_failed, :update_failed, :delete_failed]
+
+
+    def initialize(stack_name, component, context)
+      @stack_name = stack_name
+      @cf_driver = context[:cf_driver] || CfDeployer::Driver::CloudFormation.new(stack_name)
+      @context = context
+      @component = component
+    end
+
+    def deploy
+      config_dir = @context[:config_dir]
+      template = CfDeployer::ConfigLoader.component_json(@component, @context)
+      capabilities = @context[:capabilities] || []
+      tags = @context[:tags] || []
+      params = to_str(@context[:inputs].select{|key, value| @context[:defined_parameters].keys.include?(key)})
+      CfDeployer::Driver::DryRun.guard "Skipping deploy" do
+        exists? ? update_stack(template, params, capabilities, tags) : create_stack(template, params, capabilities, tags)
+      end
+    end
+
+    def outputs
+      return {} unless ready?
+      @cf_driver.outputs
+    end
+
+    def parameters
+      return {} unless ready?
+      @cf_driver.parameters
+    end
+
+    def output key
+      begin
+        @cf_driver.query_output(key) || (raise ApplicationError.new("'#{key}' is empty from stack #{name} output"))
+      rescue AWS::CloudFormation::Errors::ValidationError => e
+        raise ResourceNotInReadyState.new("Resource stack not in ready state yet, perhaps you should provision it first?")
+      end
+    end
+
+    def delete
+      if exists?
+        CfDeployer::Driver::DryRun.guard "Skipping delete" do
+          Log.info "deleting stack #{@stack_name}"
+          @cf_driver.delete_stack
+          wait_for_stack_to_delete
+        end
+      end
+    end
+
+    def exists?
+      @cf_driver.stack_exists?
+    end
+
+    def ready?
+      READY_STATS.include? @cf_driver.stack_status
+    end
+
+    def status
+      if exists?
+        ready? ? :ready : :exists
+      else
+        :does_not_exist
+      end
+    end
+
+    def resource_statuses
+      AWS.memoize do
+        resources = @cf_driver.resource_statuses.merge( { :asg_instances => {}, :instances => {} } )
+        if resources['AWS::AutoScaling::AutoScalingGroup']
+          resources['AWS::AutoScaling::AutoScalingGroup'].keys.each do |asg_name|
+            resources[:asg_instances][asg_name] = CfDeployer::Driver::AutoScalingGroup.new(asg_name).instance_statuses
+          end
+        end
+        if resources['AWS::EC2::Instance']
+          resources['AWS::EC2::Instance'].keys.each do |instance_id|
+            resources[:instances][instance_id] = CfDeployer::Driver::Instance.new(instance_id).status
+          end
+        end
+        resources
+      end
+    end
+
+    def name
+      @stack_name
+    end
+
+
+    private
+
+    def to_str(hash)
+      hash.each { |k,v| hash[k] = v.to_s }
+    end
+
+    def update_stack(template, params, capabilities, tags)
+      Log.info "Updating stack #{@stack_name}..."
+      @cf_driver.update_stack template,
+                              :capabilities => capabilities,
+                              :parameters => params
+      wait_for_stack_op_terminate
+    end
+
+    def create_stack(template, params, capabilities, tags)
+      Log.info "Creating stack #{@stack_name}..."
+      @cf_driver.create_stack template,
+                              :disable_rollback => true,
+                              :capabilities => capabilities,
+                              :tags => reformat_tags(tags),
+                              :parameters => params
+      wait_for_stack_op_terminate
+    end
+
+    def stack_status
+      @cf_driver.stack_status
+    end
+
+    def wait_for_stack_op_terminate
+      stats = stack_status
+      while !SUCCESS_STATS.include?(stats)
+        sleep 15
+        stats = stack_status
+        raise ApplicationError.new("Resource stack update failed!") if FAILED_STATS.include? stats
+        Log.info "current status: #{stack_status}"
+      end
+    end
+
+    def wait_for_stack_to_delete
+      Timeout::timeout(900){
+        while exists?
+          begin
+            Log.info "current status: #{stack_status}"
+            sleep 15
+          rescue AWS::CloudFormation::Errors::ValidationError => e
+            if e.message =~ /does not exist/
+              break # This is what we wanted anyways
+            else
+              raise e
+            end
+          end
+        end
+      }
+    end
+
+    def reformat_tags tags_hash
+      tags_hash.keys.map { |key| { 'Key' => key.to_s, 'Value' => tags_hash[key].to_s } }
+    end
+  end
+end

data/lib/cf_deployer/status_presenter.rb

@@ -0,0 +1,195 @@
+require 'rainbow'
+require 'rainbow/ext/string'
+
+module CfDeployer
+  class StatusPresenter
+
+    VERBOSITY_3_SKIP = ['AWS::AutoScaling::AutoScalingGroup','AWS::EC2::Instance',:asg_instances, :instances]
+
+    PAD = "  "
+    UNPADDED_TABLE_CELL_WIDTH = 85
+
+    def initialize status_info, verbosity
+      @verbosity = verbosity
+      @info = status_info
+      @output = []
+    end
+
+    def to_json
+      filter_for_verbosity(@info).to_json
+    end
+
+    def output
+      @output << table_seperator
+      @info.each do |component_name, stacks_hash|
+        @output << "\n#{centered(component_name.upcase)}\n"
+        @output << table_seperator
+        stack_cells = []
+        stacks_hash.each do |stack_name, stack_hash|
+          stack_output = ['']
+
+          stack_output << PAD + [ colorized_stack_name(stack_name, stack_hash),
+                            stack_active_str(stack_hash[:active]).ljust(15),
+                            stack_hash[:status].capitalize
+                          ].join(PAD)
+
+          if stack_hash[:resources]  && @verbosity != 'stacks'
+            instances_status stack_output, component_name, stack_name, stack_hash[:resources][:instances], false
+            asgs_status stack_output, component_name, stack_name, stack_hash[:resources][:asg_instances]
+            resource_status stack_output, stack_hash[:resources] if @verbosity == 'all'
+          end
+          stack_output << ''
+          stack_cells << stack_output
+        end
+        stack_cells[1] ||= ['']
+        @output += tableize( stack_cells )
+      end
+      @output.join "\n"
+    end
+
+    private
+
+    def filter_for_verbosity info_hash
+      if @verbosity == 'stacks'
+        info_hash.each do |component, component_hash|
+          component_hash.each { |stack, stack_hash| stack_hash.delete :resources }
+        end
+      elsif @verbosity == 'instances'
+        info_hash.each do |component, component_hash|
+          component_hash.each do |stack, stack_hash|
+            if stack_hash[:resources]
+              stack_hash[:resources].select! do |resource_type, resources|
+                [:instances, :asg_instances].include? resource_type
+              end
+            end
+          end
+        end
+      end
+      info_hash
+    end
+
+    def colorized_stack_name stack_name, stack_hash
+      stack_color = case stack_name.split('').last
+        when 'B' then :cyan
+        when 'G' then :green
+        else :white
+      end
+      colorized_stack_name = " #{stack_name} ".color(stack_color).bright
+      stack_hash[:active] ? colorized_stack_name.inverse : colorized_stack_name
+    end
+
+    def stack_active_str active
+      case active
+        when true then 'Active'
+        when false then 'Inactive'
+        else ''
+      end
+    end
+
+    def asgs_status output, component_name, stack_name, asg_hash
+      return if asg_hash.empty?
+      output << ''
+      output << "#{PAD * 2}AutoScalingGroups:"
+      asg_hash.each do |asg_name, asg_instances|
+        asg_color = status_color @info[component_name][stack_name][:resources]['AWS::AutoScaling::AutoScalingGroup'][asg_name]
+        output << ''
+        output << "#{PAD * 3}#{ Rainbow(asg_name).color asg_color }"
+        instances_status output, component_name, stack_name, asg_instances, true
+      end
+    end
+
+    def instances_status output, component_name, stack_name, instances_hash, in_asg
+      pad = PAD * 2
+      output << ''
+      output << "#{pad}Instances:" if (instances_hash.any? && !in_asg)
+      instances_hash.each do |instance_id, instance|
+        instance_pad = in_asg ? pad + PAD : pad
+        instance_color = instance_status_color instance[:status]
+        instance_line_parts = [ Rainbow(instance_id).color(instance_color),
+                                instance[:public_ip_address],
+                                instance[:private_ip_address],
+                                instance[:image_id],
+                                instance[:key_pair]
+                              ]
+        output << "#{PAD}#{instance_pad}" + instance_line_parts.join(PAD)
+      end
+    end
+
+    def resource_status output, resource_hash
+      resources_to_report = resource_hash.reject { |resource_type| VERBOSITY_3_SKIP.include? resource_type }
+      max_length = resources_to_report.map { |rtype, r| r.keys }.flatten.group_by(&:size).max.last.first.size
+      new_max = [ max_length, (UNPADDED_TABLE_CELL_WIDTH - 17 - (PAD.size * 4))].sort.first
+
+      resources_to_report.each do |resource_type, resources|
+        output << ''
+        output << "#{PAD * 2}#{resource_type.split('::').last}"
+        resources.each do |resource_id, resource_status|
+          truncated_id = middle_truncate_ljust(resource_id, new_max).color(status_color(resource_status))
+          output << "#{PAD * 3}#{truncated_id}#{PAD}#{resource_status}"
+        end
+      end
+    end
+
+    def instance_status_color status
+      CfDeployer::Driver::Instance::GOOD_STATUSES.include?(status) ? :green : :red
+    end
+
+    def status_color status
+      status = status.downcase.to_sym
+      if CfDeployer::Stack::READY_STATS.include? status
+        :green
+      elsif CfDeployer::Stack::FAILED_STATS.include? status
+        :red
+      else
+        :white
+      end
+    end
+
+    def tableize stack_cells
+      my_output = []
+
+      (col1, col2) = stack_cells
+      rows = stack_cells.map(&:size).max
+
+      rows.times do |i|
+        col1[i] ||= ''
+        col2[i] ||= ''
+
+        line = ''
+        line << col1[i].ljust(UNPADDED_TABLE_CELL_WIDTH + PAD.size + invisible_length(col1[i]))
+        line << '|'
+        line << col2[i]
+        my_output << line
+      end
+      my_output << table_seperator
+      my_output
+    end
+
+    def middle_truncate_ljust str, len
+      return str.ljust(len) if str.size <= len
+
+      replace_start = (len / 2).to_i - 4
+      replace_end = str.size - (len / 2).to_i
+      truncated  = str[0..replace_start] + '...' + str[replace_end..str.size]
+      truncated.ljust len
+    end
+
+    def invisible_length str
+      str.size - visible_length(str)
+    end
+
+    def visible_length str
+      str.gsub(/\e\[[\d;]+m/,'').size
+    end
+
+    def table_seperator
+      "-" * (UNPADDED_TABLE_CELL_WIDTH + PAD.size) * 2
+    end
+
+    def centered the_string
+      width = (UNPADDED_TABLE_CELL_WIDTH + PAD.size) + (the_string.size / 2).to_i
+      the_string.rjust width
+    end
+
+  end
+end

data/lib/cf_deployer/version.rb

@@ -0,0 +1,3 @@
+module CfDeployer
+  VERSION = "1.2.8"
+end

data/lib/cf_deployer.rb

@@ -0,0 +1,97 @@
+require 'digest'
+require 'set'
+require 'time'
+require 'json'
+require 'timeout'
+require 'aws-sdk'
+require 'erb'
+require 'fileutils'
+require 'log4r'
+require 'pp'
+require 'forwardable'
+
+require_relative 'cf_deployer/application_error'
+require_relative 'cf_deployer/cli'
+require_relative 'cf_deployer/application'
+require_relative 'cf_deployer/aws_constants'
+require_relative 'cf_deployer/component'
+require_relative 'cf_deployer/config_loader'
+require_relative 'cf_deployer/config_validation'
+require_relative 'cf_deployer/stack'
+require_relative 'cf_deployer/version'
+require_relative 'cf_deployer/status_presenter'
+require_relative 'cf_deployer/deployment_strategy/base'
+require_relative 'cf_deployer/deployment_strategy/blue_green'
+require_relative 'cf_deployer/deployment_strategy/auto_scaling_group_swap'
+require_relative 'cf_deployer/deployment_strategy/cname_swap'
+require_relative 'cf_deployer/deployment_strategy/create_or_update'
+require_relative 'cf_deployer/driver/auto_scaling_group'
+require_relative 'cf_deployer/driver/cloud_formation_driver'
+require_relative 'cf_deployer/driver/dry_run'
+require_relative 'cf_deployer/driver/elb_driver'
+require_relative 'cf_deployer/driver/instance'
+require_relative 'cf_deployer/driver/route53_driver'
+require_relative 'cf_deployer/driver/verisign_driver'
+require_relative 'cf_deployer/logger'
+require_relative 'cf_deployer/hook'
+require_relative 'cf_deployer/defaults'
+
+module CfDeployer
+
+  AWS.config(:max_retries => 5)
+
+  def self.config opts
+    config = self.parseconfig opts, false
+    config[:components].each do |component, c_hash|
+      c_hash.delete :defined_parameters
+    end
+    puts config.select { |k,v| [:components, :environments, :environment, :application, :'config-file'].include? k.to_sym }.to_yaml
+  end
+
+  def self.deploy opts
+    config = self.parseconfig opts
+    # AWS.config(:logger => Logger.new($stdout))
+    Application.new(config).deploy
+  end
+
+  def self.destroy opts
+    config = self.parseconfig opts, false
+    # AWS.config(:logger => Logger.new($stdout))
+    Application.new(config).destroy
+  end
+
+  def self.json opts
+    config = self.parseconfig opts, false
+    Application.new(config).json
+  end
+
+  def self.status opts
+    config = self.parseconfig opts, false
+    status_info = Application.new(config).status opts[:component].first, opts[:verbosity]
+    presenter = CfDeployer::StatusPresenter.new status_info, opts[:verbosity]
+
+    puts opts[:'output-format'] == 'json' ? presenter.to_json : presenter.output
+  end
+
+  def self.switch opts
+    config = self.parseconfig opts, false
+    Application.new(config).switch
+  end
+
+  def self.kill_inactive opts
+    config = self.parseconfig opts, false
+    Application.new(config).kill_inactive
+  end
+
+  private
+
+  def self.parseconfig options, validate_inputs = true
+    AWS.config(:region => options[:region]) if options[:region]
+    split_settings = options.dup
+    split_settings.merge!({:cli_overrides => {:settings => split_settings.delete(:settings), :inputs => split_settings.delete(:inputs)} })
+    config = ConfigLoader.new.load split_settings
+    ConfigValidation.new.validate config, validate_inputs
+    config
+  end
+
+end

data/spec/fakes/instance.rb

@@ -0,0 +1,32 @@
+module Fakes
+  class Instance
+
+    SIMPLE_ATTRIBS = [ :id, :status, :public_ip_address, :private_ip_address, :image_id ]
+
+    attr_reader *SIMPLE_ATTRIBS
+    attr_reader :key_pair
+
+    def initialize(options)
+      defaults = {
+        :id => 'i-abcd1234',
+        :status => :running,
+        :public_ip_address => '1.2.3.4',
+        :private_ip_address => '192.168.100.200',
+        :image_id => 'ami-abcd1234',
+        :key_pair => 'awesome_users'
+      }
+
+      SIMPLE_ATTRIBS.each do |attrib|
+        instance_variable_set "@#{attrib}", (options[attrib] || defaults[attrib])
+      end
+
+      @key_pair = ::AWS::EC2::KeyPair.new (options[:key_pair] || defaults[:key_pair] )
+    end
+
+    def inspect
+      "#{self.class}<#{@name}>"
+    end
+    alias_method :to_s, :inspect
+
+  end
+end

data/spec/fakes/route53_client.rb

@@ -0,0 +1,23 @@
+module Fakes
+  class AWSRoute53
+    attr_reader :fail_counter, :hosted_zones, :client
+    def initialize(opts = {})
+      @client = AWSRoute53Client.new(opts)
+      @hosted_zones = opts[:hosted_zones]
+      @fail_counter = 0
+    end
+  end
+
+  class AWSRoute53Client
+    attr_reader :fail_counter
+    def initialize(opts = {})
+      @times_to_fail = opts[:times_to_fail]
+      @fail_counter = 0
+    end
+
+    def change_resource_record_sets(*args)
+      @fail_counter = @fail_counter + 1
+      raise 'Error' if @fail_counter <= @times_to_fail
+    end
+  end
+end