eb_deployer 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in eb_deployer.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 tworker
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# EbDeployer
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'eb_deployer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install eb_deployer
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/eb_deployer.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/eb_deployer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["wpc", "betarelease"]
+  gem.email         = ["alex.hal9000@gmail.com", "sudhindra.r.rao@gmail.com"]
+  gem.description   = %q{Elastic Beanstalk Deployer with different deployment strategies.}
+  gem.summary       = %q{Pick strategies like InplaceUpdate, Blue/Green.}
+  gem.homepage      = "https://github.com/ThoughtWorksStudios/eb_deployer"
+
+  gem.add_runtime_dependency 'aws-sdk'
+  gem.add_development_dependency 'minitest'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "eb_deployer"
+  gem.require_paths = ["lib"]
+  gem.version       = EbDeployer::VERSION
+end

data/lib/eb_deployer/beanstalk.rb

@@ -0,0 +1,82 @@
+module EbDeployer
+  class Beanstalk
+    attr_reader :client
+    def initialize(client=AWS::ElasticBeanstalk.new.client)
+      @client = client
+    end
+
+    def update_environment(app_name, env_name, version, settings)
+      env_id = convert_env_name_to_id(app_name, [env_name]).first
+      @client.update_environment(:environment_id => env_id,
+                                 :version_label => version,
+                                 :option_settings => settings)
+    end
+
+    def environment_exists?(app_name, env_name)
+      alive_envs(app_name, [env_name]).any?
+    end
+
+    def create_environment(app_name, env_name, stack_name, cname_prefix, version, settings)
+      request = {:application_name => app_name,
+        :environment_name => env_name,
+        :solution_stack_name => stack_name,
+        :version_label => version,
+        :option_settings => settings }
+      request[:cname_prefix] = cname_prefix if cname_prefix
+      @client.create_environment(request)
+    end
+
+    def create_application_version(app_name, version_label, source_bundle)
+      @client.create_application_version(:application_name => app_name,
+                                         :source_bundle => source_bundle,
+                                         :version_label => version_label)
+    end
+
+    def application_version_labels
+      @client.describe_application_versions[:application_versions].map { |apv| apv[:version_label] }
+    end
+
+    def fetch_events(app_name, env_name, params, &block)
+      response = @client.describe_events(params.merge(:application_name => app_name,
+                                                      :environment_name => env_name))
+      return [response[:events], response[:next_token]]
+    end
+
+    def environment_cname_prefix(app_name, env_name)
+      cname = environment_cname(app_name, env_name)
+      if cname =~ /^(.+)\.elasticbeanstalk\.com/
+        $1
+      end
+    end
+
+    def environment_cname(app_name, env_name)
+      env = alive_envs(app_name, [env_name]).first
+      env && env[:cname]
+    end
+
+    def environment_health_state(app_name, env_name)
+      env = alive_envs(app_name, [env_name]).first
+      env && env[:health]
+    end
+
+    def environment_swap_cname(app_name, env1, env2)
+      env1_id, env2_id = convert_env_name_to_id(app_name, [env1, env2])
+      @client.swap_environment_cnam_es(:source_environment_id => env1_id,
+                                       :destination_environment_id => env2_id)
+    end
+
+    private
+
+    def convert_env_name_to_id(app_name, env_names)
+      envs = alive_envs(app_name, env_names)
+      envs.map { |env| env[:environment_id] }
+    end
+
+    def alive_envs(app_name, env_names=[])
+      envs = @client.describe_environments(:application_name => app_name, :environment_names => env_names)[:environments]
+
+      envs.select {|e| e[:status] != 'Terminated' }
+    end
+
+  end
+end

data/lib/eb_deployer/cloud_formation_provisioner.rb

@@ -0,0 +1,82 @@
+module EbDeployer
+  class CloudFormationProvisioner
+    SUCCESS_STATS = [:create_complete, :update_complete, :update_rollback_complete]
+    FAILED_STATS = [:create_failed, :update_failed]
+
+    def initialize(stack_name)
+      @stack_name = stack_name
+    end
+
+    def provision(resources)
+      params = extract_params
+      template = File.read(resources[:template])
+      transforms = resources[:transforms]
+
+      stack.exists? ? update_stack(template, params) : create_stack(template, params)
+      wait_for_stack_op_terminate
+      transform_output_to_settings(transforms)
+    end
+
+    private
+
+    def update_stack(template, params)
+      begin
+        stack.update(:template => template, :parameters => params)
+      rescue AWS::CloudFormation::Errors::ValidationError => e
+        if e.message =~ /No updates are to be performed/
+          log(e.message)
+        else
+          raise
+        end
+      end
+    end
+
+    def create_stack(template, params)
+      cloud_formation.stacks.create(@stack_name, template, {
+                                      :disable_rollback => true,
+                                      :parameters => params
+                                    })
+    end
+
+    def transform_output_to_settings(transforms)
+      (transforms || []).inject([]) do |settings, pair|
+        key, transform = pair
+        settings << transform.call(output(key))
+        settings
+      end.flatten
+    end
+
+    def wait_for_stack_op_terminate
+      begin
+        sleep 15
+        stats = stack_status
+        raise "Resource stack update failed!" if FAILED_STATS.include?(stats)
+        log "current status: #{stack_status}"
+      end while !SUCCESS_STATS.include?(stats)
+    end
+
+    def output(key)
+      stack.outputs.find { |o| o.key == key }.try(:value)
+    end
+
+    def extract_params
+      Hash[ENV.map {|k, v| k =~ /^AWSRESOURCES_(.*)/ ? [$1, v] : nil }.compact]
+    end
+
+    def log(msg)
+      puts "[#{Time.now.utc}][resources-stack] #{msg}"
+    end
+
+    def stack_status
+      stack.status.downcase.to_sym
+    end
+
+    def stack
+      cloud_formation.stacks[@stack_name]
+    end
+
+    def cloud_formation
+      AWS::CloudFormation.new
+    end
+  end
+end

data/lib/eb_deployer/deployment_strategy.rb

@@ -0,0 +1,74 @@
+module EbDeployer
+  module DeploymentStrategy
+    class InplaceUpdate
+      def initialize(app, env_name, eb_driver, env_creation_opts)
+        @app = app
+        @env_name = env_name
+        @eb_driver = eb_driver
+        @env_creation_opts = env_creation_opts
+      end
+
+      def deploy(version_label, env_settings)
+        Environment.new(@app, @env_name, @eb_driver, @env_creation_opts).
+          deploy(version_label, env_settings)
+      end
+    end
+
+    class BlueGreen
+      def initialize(app, env_name, eb_driver, env_creation_opts)
+        @app = app
+        @env_name = env_name
+        @eb_driver = eb_driver
+        @major_cname_prefix = env_creation_opts[:cname_prefix]
+        @solution_stack = env_creation_opts[:solution_stack]
+        @smoke_test = env_creation_opts[:smoke_test]
+      end
+
+      def deploy(version_label, env_settings)
+        if !envs.any?(&method(:active_env?))
+          env('blue', @major_cname_prefix).
+            deploy(version_label, env_settings)
+          return
+        end
+
+        active_env = envs.detect(&method(:active_env?))
+        inactive_env = envs.reject(&method(:active_env?)).first
+
+        inactive_env.deploy(version_label, env_settings)
+        active_env.swap_cname_with(inactive_env)
+      end
+
+      private
+      def active_env?(env)
+        env.cname_prefix == @major_cname_prefix
+      end
+
+      def envs
+        [env('blue'), env('green')]
+      end
+
+      def env(color, cname_prefix=nil)
+        Environment.new(@app, @env_name + '-' + color, @eb_driver,
+                        :solution_stack => @solution_stack,
+                        :cname_prefix => cname_prefix || inactive_cname_prefix,
+                        :smoke_test => @smoke_test)
+      end
+
+      def inactive_cname_prefix
+        "#{@app}-#{@env_name}-inactive"
+      end
+    end
+
+    def self.create(strategy_name, app, env_name, eb_driver, env_creation_opts={})
+      case strategy_name.to_sym
+      when :inplace_update
+        InplaceUpdate.new(app, env_name, eb_driver, env_creation_opts)
+      when :blue_green
+        BlueGreen.new(app, env_name, eb_driver, env_creation_opts)
+      else
+        raise 'strategy_name:' + strategy_name + ' not supported'
+      end
+
+    end
+  end
+end

data/lib/eb_deployer/environment.rb

@@ -0,0 +1,82 @@
+module EbDeployer
+  class Environment
+    attr_reader :app, :name
+    def initialize(app, env_name, eb_driver, creation_opts={})
+      @app = app
+      @name = env_name
+      @bs = eb_driver
+      @creation_opts = creation_opts
+      @poller = EventPoller.new(@app, @name, @bs)
+    end
+
+    def deploy(version_label, settings)
+      create_or_update_env(version_label, settings)
+      poll_events
+      smoke_test
+      wait_for_env_become_healthy
+    end
+
+    def cname_prefix
+      @bs.environment_cname_prefix(@app, @name)
+    end
+
+    def ==(another)
+      self.app == another.app && self.name == another.name
+    end
+
+    def swap_cname_with(another)
+      @bs.environment_swap_cname(self.app, self.name, another.name)
+    end
+
+    private
+
+    def create_or_update_env(version_label, settings)
+      if @bs.environment_exists?(@app, @name)
+        @bs.update_environment(@app, @name, version_label, settings)
+      else
+        @bs.create_environment(@app, @name, @creation_opts[:solution_stack], @creation_opts[:cname_prefix], version_label, settings)
+      end
+    end
+
+    def smoke_test
+      if smoke = @creation_opts[:smoke_test]
+        host = @bs.environment_cname(@app, @name)
+        log("running smoke test for #{host}...")
+        smoke.call(host)
+        log("smoke test succeeded.")
+      end
+    end
+
+    def poll_events
+      @poller.poll do |event|
+        raise event[:message] if event[:message] =~ /Failed to deploy application/
+
+        log_event(event)
+        break if event[:message] =~ /Environment update completed successfully/ ||
+          event[:message] =~ /Successfully launched environment/
+      end
+    end
+
+    def wait_for_env_become_healthy
+      Timeout.timeout(600) do
+        current_health_status = @bs.environment_health_state(@app, @name)
+
+        while current_health_status != 'Green'
+          log("health status: #{current_health_status}")
+          sleep 15
+          current_health_status = @bs.environment_health_state(@app, @name)
+        end
+
+        log("health status: #{current_health_status}")
+      end
+    end
+
+    def log(msg)
+      puts "[#{Time.now.utc}][beanstalk-#{@name}] #{msg}"
+    end
+
+    def log_event(event)
+      puts "[#{event[:event_date]}][beanstalk-#{@name}] #{event[:message]}"
+    end
+  end
+end

data/lib/eb_deployer/event_poller.rb

@@ -0,0 +1,41 @@
+module EbDeployer
+  class EventPoller
+    def initialize(app, env, beanstalk)
+      @app, @env, @beanstalk, @start_time = app, env, beanstalk, Time.now
+    end
+
+    def poll(&block)
+      handled = Set.new
+      loop do
+        fetch_events do |events|
+          new_events = events.reject { |e| handled.include?(digest(e)) }
+          handle(new_events, &block)
+          handled += new_events.map { |e| digest(e) }
+        end
+        sleep 15
+      end
+    end
+
+    private
+
+    def digest(event)
+      JSON.dump(event)
+    end
+
+    def handle(events, &block)
+      events.reverse.each(&block)
+    end
+
+    def fetch_events(&block)
+      events, next_token = @beanstalk.fetch_events(@app, @env, :start_time => @start_time.iso8601)
+      yield(events)
+      fetch_next(next_token, &block) if next_token
+    end
+
+    def fetch_next(next_token, &block)
+      events, next_token = @beanstalk.fetch_events(@app, @env, :next_token => next_token)
+      yield(events)
+      fetch_next(next_token, &block) if next_token
+    end
+  end
+end

data/lib/eb_deployer/package.rb

@@ -0,0 +1,33 @@
+module EbDeployer
+  class Package
+    def initialize(file, bucket_name, s3_driver)
+      @file, @bucket_name = file, bucket_name
+      @s3 = s3_driver
+    end
+
+    def upload
+      ensure_bucket(@bucket_name)
+      upload_if_not_exists(@file, @bucket_name)
+    end
+
+    def source_bundle
+      { :s3_bucket => @bucket_name, :s3_key => s3_path }
+    end
+
+    private
+
+    def s3_path
+      @_s3_path ||= Digest::MD5.file(@file).hexdigest + "-" + File.basename(@file)
+    end
+
+    def ensure_bucket(bucket_name)
+      @s3.create_bucket(@bucket_name) unless @s3.bucket_exists?(@bucket_name)
+    end
+
+    def upload_if_not_exists(file, bucket_name)
+      if @s3.object_length(@bucket_name, s3_path) != File.size(file)
+        @s3.upload_file(@bucket_name, s3_path, file)
+      end
+    end
+  end
+end

data/lib/eb_deployer/s3_driver.rb

@@ -0,0 +1,33 @@
+module EbDeployer
+  class S3Driver
+    def create_bucket(bucket_name)
+      buckets.create(bucket_name)
+    end
+
+    def bucket_exists?(bucket_name)
+      buckets[bucket_name].exists?
+    end
+
+    def object_length(bucket_name, obj_name)
+      obj(bucket_name, obj_name).content_length rescue nil
+    end
+
+    def upload_file(bucket_name, obj_name, file)
+      o = obj(bucket_name, obj_name)
+      File.open(file) { |f| o.write(f) }
+    end
+
+    private
+    def s3
+      AWS::S3.new
+    end
+
+    def obj(bucket_name, obj_name)
+      buckets[bucket_name].objects[obj_name]
+    end
+
+    def buckets
+      s3.buckets
+    end
+  end
+end

data/lib/eb_deployer/version.rb

@@ -0,0 +1,3 @@
+module EbDeployer
+  VERSION = "0.0.1"
+end

data/lib/eb_deployer.rb

@@ -0,0 +1,54 @@
+require "eb_deployer/version"
+require "eb_deployer/deployment_strategy"
+require "eb_deployer/beanstalk"
+require "eb_deployer/cloud_formation_provisioner"
+require "eb_deployer/environment"
+require "eb_deployer/event_poller"
+require "eb_deployer/package"
+require 'eb_deployer/s3_driver'
+require 'digest'
+require 'set'
+require 'time'
+require 'json'
+require 'timeout'
+
+module EbDeployer
+  def self.deploy(opts)
+    # AWS.config(:logger => Logger.new($stdout))
+    if region = opts[:region]
+      AWS.config(:region => region)
+    end
+
+    bs = opts[:bs_driver] || Beanstalk.new
+    s3 = opts[:s3_driver] || S3Driver.new
+    stack_name = opts[:solution_stack_name] || "64bit Amazon Linux running Tomcat 7"
+    app = opts[:application]
+    env_name = opts[:environment]
+    version_label = opts[:version_label].to_s.strip
+    cname = opts[:cname]
+    env_settings = opts[:settings] || []
+    strategy_name = opts[:strategy] || :inplace_update
+    cname_prefix = opts[:cname_prefix] || [app, env_name].join('-')
+    smoke_test = opts[:smoke_test] || Proc.new {}
+
+    package = Package.new(opts[:package], app + "-packages", s3)
+    cf = CloudFormationProvisioner.new("#{app}-#{env_name}")
+    strategy = DeploymentStrategy.create(strategy_name, app, env_name, bs,
+                                         :solution_stack => stack_name,
+                                         :cname_prefix => cname_prefix,
+                                         :smoke_test => smoke_test)
+
+    if resources = opts[:resources]
+      env_settings += cf.provision(resources)
+    end
+
+    package.upload
+
+    unless bs.application_version_labels.include?(version_label)
+      bs.create_application_version(app, version_label, package.source_bundle)
+    end
+
+    strategy.deploy(version_label, env_settings)
+  end
+
+end

data/test/aws_driver_stubs.rb

@@ -0,0 +1,93 @@
+class EBStub
+  def initialize
+    @envs = {}
+    @versions = {}
+  end
+
+  def create_environment(app, env, solution_stack, cname_prefix, version, settings)
+    raise 'cname prefix is not avaible' if @envs.values.detect { |env| env[:cname_prefix] == cname_prefix }
+    @envs[env_key(app, env)] = {
+      :solution_stack => solution_stack,
+      :version => version,
+      :cname_prefix => cname_prefix,
+      :settings => settings}
+  end
+
+  def update_environment(app, env, version, settings)
+    @envs[env_key(app, env)].merge!(:version => version, :settings => settings)
+  end
+
+  def environment_exists?(app_name, env_name)
+    @envs.has_key?(env_key(app_name, env_name))
+  end
+
+  def create_application_version(app_name, version_label, source_bundle)
+    @versions[app_name] ||= []
+    @versions[app_name] = { version_label => source_bundle }
+  end
+
+  def application_version_labels
+    @versions.values.map(&:keys).flatten
+  end
+
+  def fetch_events(app_name, env_name, options={})
+    [[{:event_date => Time.now.utc,
+        :message => 'Environment update completed successfully'}],
+     nil]
+  end
+
+  def environment_cname_prefix(app_name, env_name)
+    return unless @envs[env_key(app_name, env_name)]
+    @envs[env_key(app_name, env_name)][:cname_prefix] || app_name + "-" + SecureRandom.hex
+  end
+
+  def environment_cname(app_name, env_name)
+    return unless @envs[env_key(app_name, env_name)]
+    environment_cname_prefix(app_name, env_name) + ".elasticbeanstalk.com"
+  end
+
+
+  def environment_swap_cname(app_name, env1_name, env2_name)
+    env1, env2 = @envs[env_key(app_name, env1_name)], @envs[env_key(app_name, env2_name)]
+    temp = env1[:cname_prefix]
+    env1[:cname_prefix] = env2[:cname_prefix]
+    env2[:cname_prefix] = temp
+  end
+
+  def environment_health_state(app_name, env_name)
+    'Green'
+  end
+
+  #test only
+  def environment_verion_label(app_name, env_name)
+    @envs[env_key(app_name, env_name)][:version]
+  end
+
+  private
+  def env_key(app, name)
+    [app, name].join("-")
+  end
+
+end
+
+class S3Stub
+  def initialize
+    @buckets = {}
+  end
+
+  def create_bucket(bucket_name)
+    @buckets[bucket_name] = {}
+  end
+
+  def bucket_exists?(bucket_name)
+    @buckets.has_key?(bucket_name)
+  end
+
+  def object_length(bucket_name, obj_name)
+    @buckets[bucket_name][obj_name] && File.size(@buckets[bucket_name][obj_name])
+  end
+
+  def upload_file(bucket_name, obj_name, file)
+    @buckets[bucket_name][obj_name] = file
+  end
+end

data/test/deploy_test.rb

@@ -0,0 +1,147 @@
+require 'eb_deployer'
+require 'aws_driver_stubs'
+require 'minitest/autorun'
+
+class DeployTest < Minitest::Test
+  def setup
+    @eb_driver = EBStub.new
+    @s3_driver = S3Stub.new
+    @sample_package = '/tmp/app-package.war'
+    File.open(@sample_package, 'w') { |f| f << 's' * 100 }
+  end
+
+  def deploy(opts)
+    EbDeployer.deploy({:package => @sample_package,
+                        :bs_driver => @eb_driver,
+                        :s3_driver => @s3_driver,
+                        :version_label => 1}.merge(opts))
+  end
+
+
+  def test_first_deployment_create_environment
+    assert !@eb_driver.environment_exists?('simple', 'production')
+    deploy(:application => 'simple', :environment => "production")
+    assert @eb_driver.environment_exists?('simple', 'production')
+  end
+
+
+  def test_update_environment_with_new_version_should_change_version_that_deployed
+    deploy(:application => 'simple',
+           :environment => "production",
+           :version_label => 1)
+    assert_equal '1', @eb_driver.environment_verion_label('simple', 'production')
+
+    deploy(:application => 'simple',
+           :environment => "production",
+           :version_label => 2)
+
+    assert_equal '2', @eb_driver.environment_verion_label('simple', 'production')
+  end
+
+  def test_default_cname_that_deployed_should_app_env_name
+    deploy(:application => 'simple',
+           :environment => "production",
+           :version_label => 42)
+    assert_equal "simple-production", @eb_driver.environment_cname_prefix('simple', 'production')
+  end
+
+  def test_cname_prefix_can_be_override
+    deploy(:application => 'simple',
+           :environment => "production",
+           :cname_prefix => 'sports123',
+           :version_label => 42)
+    assert_equal "sports123", @eb_driver.environment_cname_prefix('simple', 'production')
+  end
+
+
+  def test_smoke_test_should_be_run_after_env_created_or_update
+    host_for_smoke_test = nil
+    deploy(:application => 'simple',
+           :environment => "production",
+           :cname_prefix => 'foobar',
+           :smoke_test => lambda { |host| host_for_smoke_test = host },
+           :version_label => 42)
+    assert_equal 'foobar.elasticbeanstalk.com', host_for_smoke_test
+
+    host_for_smoke_test = nil
+    deploy(:application => 'simple',
+           :environment => "production",
+           :cname_prefix => 'foobar',
+           :smoke_test => lambda { |host| host_for_smoke_test = host },
+           :version_label => 43)
+
+    assert_equal 'foobar.elasticbeanstalk.com', host_for_smoke_test
+  end
+
+
+
+  def test_blue_green_deployment_strategy_should_create_blue_env_on_first_deployment
+    deploy(:application => 'simple',
+           :environment => "production",
+           :strategy => 'blue_green',
+           :version_label => 42)
+
+    assert @eb_driver.environment_exists?('simple', 'production-blue')
+    assert_equal 'simple-production',  @eb_driver.environment_cname_prefix('simple', 'production-blue')
+  end
+
+
+  def test_blue_green_deployment_should_create_green_env_if_blue_exists
+    deploy(:application => 'simple',
+           :environment => "production",
+           :strategy => 'blue_green',
+           :version_label => 42)
+
+    deploy(:application => 'simple',
+           :environment => "production",
+           :strategy => 'blue_green',
+           :version_label => 43)
+
+    assert @eb_driver.environment_exists?('simple', 'production-blue')
+    assert @eb_driver.environment_exists?('simple', 'production-green')
+  end
+
+
+  def test_blue_green_deployment_should_swap_cname_to_make_active_most_recent_updated_env
+    deploy(:application => 'simple',
+           :environment => "production",
+           :strategy => 'blue_green',
+           :version_label => 42)
+
+    deploy(:application => 'simple',
+           :environment => "production",
+           :strategy => 'blue_green',
+           :version_label => 43)
+
+    assert_match(/simple-production-inactive/,  @eb_driver.environment_cname_prefix('simple', 'production-blue'))
+
+    assert_equal 'simple-production',  @eb_driver.environment_cname_prefix('simple', 'production-green')
+
+
+    deploy(:application => 'simple',
+           :environment => "production",
+           :strategy => 'blue_green',
+           :version_label => 44)
+
+    assert_match(/simple-production-inactive/,  @eb_driver.environment_cname_prefix('simple', 'production-green'))
+
+    assert_equal 'simple-production',  @eb_driver.environment_cname_prefix('simple', 'production-blue')
+  end
+
+
+  def test_blue_green_deploy_should_run_smoke_test_before_cname_switch
+    smoked_host = []
+    smoke_test = lambda { |host| smoked_host << host }
+    [42, 43, 44].each do |version_label|
+      deploy(:application => 'simple',
+             :environment => "production",
+             :strategy => 'blue_green',
+             :smoke_test => smoke_test,
+             :version_label => version_label)
+    end
+
+    assert_equal ['simple-production.elasticbeanstalk.com',
+                  'simple-production-inactive.elasticbeanstalk.com',
+                  'simple-production-inactive.elasticbeanstalk.com'], smoked_host
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: eb_deployer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- wpc
+- betarelease
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Elastic Beanstalk Deployer with different deployment strategies.
+email:
+- alex.hal9000@gmail.com
+- sudhindra.r.rao@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- eb_deployer.gemspec
+- lib/eb_deployer.rb
+- lib/eb_deployer/beanstalk.rb
+- lib/eb_deployer/cloud_formation_provisioner.rb
+- lib/eb_deployer/deployment_strategy.rb
+- lib/eb_deployer/environment.rb
+- lib/eb_deployer/event_poller.rb
+- lib/eb_deployer/package.rb
+- lib/eb_deployer/s3_driver.rb
+- lib/eb_deployer/version.rb
+- test/aws_driver_stubs.rb
+- test/deploy_test.rb
+homepage: https://github.com/ThoughtWorksStudios/eb_deployer
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Pick strategies like InplaceUpdate, Blue/Green.
+test_files:
+- test/aws_driver_stubs.rb
+- test/deploy_test.rb