eb_deployer 0.3.6 → 0.3.7

data/.ruby-version

@@ -1 +1 @@
-1.9.3-p429
+1.9.3-p484

data/.travis.yml

@@ -0,0 +1,10 @@
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-1.7.10
+script: "bundle exec rake"
+bundler_args: "--without repl documentation"
+branches:
+  only:
+    - master

data/Gemfile

@@ -5,4 +5,4 @@ gemspec
 
 gem 'redcarpet'
 gem 'yard'
-
+gem 'rake'

data/README.md

@@ -1,4 +1,4 @@
-# EbDeployer
+# EbDeployer [![Build Status](https://travis-ci.org/ThoughtWorksStudios/eb_deployer.png?branch=master)](https://travis-ci.org/ThoughtWorksStudios/eb_deployer)
 
 Low friction deployments should be a breeze. Elastic Beanstalk provides a great foundation for performing Blue-Green deployments, and EbDeployer add a missing link to automate the whole flow out of box.
 

data/lib/eb_deployer/application.rb

@@ -1,5 +1,7 @@
 module EbDeployer
   class Application
+    attr_reader :name
+
     def initialize(name, eb_driver, s3_driver, bucket = nil)
       @name = name
       @eb_driver = eb_driver
@@ -34,7 +36,7 @@ module EbDeployer
 
     def delete(env_name=nil)
       if @eb_driver.application_exists?(@name)
-        env_name = Environment.unique_ebenv_name(@name, env_name) unless env_name.nil?
+        env_name = EbEnvironment.unique_ebenv_name(@name, env_name) unless env_name.nil?
         available_envs = @eb_driver.environment_names_for_application(@name)
 
         unless env_name.nil? || available_envs.include?(env_name)
@@ -75,6 +77,10 @@ module EbDeployer
       end
     end
 
+    def clean_versions(version_prefix, retentions)
+      VersionCleaner.new(self, retentions).clean(version_prefix)
+    end
+
     private
 
     def create_application_if_not_exists

data/lib/eb_deployer/aws_driver/beanstalk.rb

@@ -0,0 +1,127 @@
+module EbDeployer
+  module AWSDriver
+    class Beanstalk
+      attr_reader :client
+
+      def initialize(client=AWS::ElasticBeanstalk.new.client)
+        @client = client
+      end
+
+      def create_application(app)
+        @client.create_application(:application_name => app)
+      end
+
+      def delete_application(app)
+        @client.delete_application(:application_name => app)
+      end
+
+      def application_exists?(app)
+        @client.describe_applications(:application_names => [app])[:applications].any?
+      end
+
+      def update_environment(app_name, env_name, version, tier, settings)
+        env_id = convert_env_name_to_id(app_name, [env_name]).first
+        request = {
+          :environment_id => env_id,
+          :version_label => version,
+          :option_settings => settings,
+          :tier => tier
+        }
+
+        @client.update_environment(request)
+      end
+
+      def environment_exists?(app_name, env_name)
+        alive_envs(app_name, [env_name]).any?
+      end
+
+      def environment_names_for_application(app_name)
+        alive_envs(app_name).collect { |env| env[:environment_name] }
+      end
+
+      def create_environment(app_name, env_name, stack_name, cname_prefix, version, tier, settings)
+        request = {
+          :application_name => app_name,
+          :environment_name => env_name,
+          :solution_stack_name => stack_name,
+          :version_label => version,
+          :option_settings => settings,
+          :tier => tier,
+          :cname_prefix => cname_prefix
+        }
+
+        @client.create_environment(request)
+      end
+
+      def delete_environment(app_name, env_name)
+        @client.terminate_environment(:environment_name => env_name)
+      end
+
+      def delete_application_version(app_name, version, delete_source_bundle)
+        request = {
+          :application_name => app_name,
+          :version_label => version,
+          :delete_source_bundle => delete_source_bundle
+        }
+        @client.delete_application_version(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(app_name)
+        application_versions(app_name).map { |apv| apv[:version_label] }
+      end
+
+      def application_versions(app_name)
+        request = { :application_name => app_name }
+        @client.describe_application_versions(request)[:application_versions]
+      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
+end

data/lib/eb_deployer/aws_driver/cloud_formation_driver.rb

@@ -0,0 +1,49 @@
+module EbDeployer
+  module AWSDriver
+    class CloudFormationDriver
+
+      def stack_exists?(name)
+        stack(name).exists?
+      end
+
+      def create_stack(name, template, opts)
+        cloud_formation.stacks.create(name, template, opts)
+      end
+
+      def update_stack(name, template, opts)
+        begin
+          stack(name).update(opts.merge(:template => template))
+        rescue AWS::CloudFormation::Errors::ValidationError => e
+          if e.message =~ /No updates are to be performed/
+            log(e.message)
+          else
+            raise
+          end
+        end
+      end
+
+      def stack_status(name)
+        stack(name).status.downcase.to_sym
+      end
+
+      def query_output(name, key)
+        output = stack(name).outputs.find { |o| o.key == key }
+        output && output.value
+      end
+
+      private
+
+      def cloud_formation
+        AWS::CloudFormation.new
+      end
+
+      def stack(name)
+        cloud_formation.stacks[name]
+      end
+
+      def log(msg)
+        puts "[#{Time.now.utc}][cloud_formation_driver] #{msg}"
+      end
+    end
+  end
+end

data/lib/eb_deployer/aws_driver/s3_driver.rb

@@ -0,0 +1,35 @@
+module EbDeployer
+  module AWSDriver
+    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
+end

data/lib/eb_deployer/aws_driver.rb

@@ -0,0 +1,8 @@
+require 'eb_deployer/aws_driver/s3_driver'
+require 'eb_deployer/aws_driver/beanstalk'
+require 'eb_deployer/aws_driver/cloud_formation_driver'
+
+module EbDeployer
+  module AWSDriver
+  end
+end

data/lib/eb_deployer/config_loader.rb

@@ -62,7 +62,6 @@ module EbDeployer
 
     def package_digest(package)
       return nil unless package
-      return package unless File.exists?(package)
       Digest::MD5.file(package).hexdigest
     end
   end

data/lib/eb_deployer/deployment_strategy/blue_green.rb

@@ -0,0 +1,40 @@
+module EbDeployer
+  module DeploymentStrategy
+    class BlueGreen
+      def initialize(env)
+        @env = env
+      end
+
+      def deploy(version_label, env_settings)
+        if !envs.any?(&method(:active_env?))
+          env('a', @env.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 == @env.cname_prefix
+      end
+
+      def envs
+        [env('a'), env('b')]
+      end
+
+      def env(suffix, cname_prefix=nil)
+        @env.new_eb_env(suffix, cname_prefix || inactive_cname_prefix)
+      end
+
+      def inactive_cname_prefix
+        "#{@env.cname_prefix}-inactive"
+      end
+    end
+  end
+end

data/lib/eb_deployer/deployment_strategy/inplace_update.rb

@@ -0,0 +1,13 @@
+module EbDeployer
+  module DeploymentStrategy
+    class InplaceUpdate
+      def initialize(env)
+        @env = env
+      end
+
+      def deploy(version_label, env_settings)
+        @env.new_eb_env.deploy(version_label, env_settings)
+      end
+    end
+  end
+end

data/lib/eb_deployer/deployment_strategy.rb

@@ -1,72 +1,17 @@
+require 'eb_deployer/deployment_strategy/inplace_update'
+require 'eb_deployer/deployment_strategy/blue_green'
+
 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
-        @env_creation_opts = env_creation_opts
-        @major_cname_prefix = env_creation_opts[:cname_prefix]
-      end
-
-      def deploy(version_label, env_settings)
-        if !envs.any?(&method(:active_env?))
-          env('a', @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('a'), env('b')]
-      end
-
-      def env(suffix, cname_prefix=nil)
-        Environment.new(@app, @env_name + '-' + suffix,
-                        @eb_driver,
-                        @env_creation_opts.merge({:cname_prefix => cname_prefix || inactive_cname_prefix}))
-      end
-
-      def inactive_cname_prefix
-        "#{@app}-#{@env_name}-inactive"
-      end
-    end
-
-    def self.create(strategy_name, app, env_name, eb_driver, env_creation_opts={})
+    def self.create(env, strategy_name)
       case strategy_name.to_s
       when 'inplace_update', 'inplace-update'
-        InplaceUpdate.new(app, env_name, eb_driver, env_creation_opts)
+        InplaceUpdate.new(env)
       when 'blue_green', 'blue-green'
-        BlueGreen.new(app, env_name, eb_driver, env_creation_opts)
+        BlueGreen.new(env)
       else
         raise 'strategy_name: ' + strategy_name.to_s + ' not supported'
       end
-
     end
   end
 end

data/lib/eb_deployer/eb_environment.rb

@@ -0,0 +1,111 @@
+module EbDeployer
+  class EbEnvironment
+    attr_reader :app, :name
+    attr_writer :event_poller
+
+    def self.unique_ebenv_name(app_name, env_name)
+      raise "Environment name #{env_name} is too long, it must be under 15 chars" if env_name.size > 15
+      digest = Digest::SHA1.hexdigest(app_name + '-' + env_name)[0..6]
+      "#{env_name}-#{digest}"
+    end
+
+    def initialize(app, env_name, eb_driver, creation_opts={})
+      @app = app
+      @name = self.class.unique_ebenv_name(app, env_name)
+      @bs = eb_driver
+      @creation_opts = creation_opts
+    end
+
+    def deploy(version_label, settings={})
+      terminate if @creation_opts[:phoenix_mode]
+      create_or_update_env(version_label, settings)
+      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)
+      log("Swap CNAME with env #{another.name}")
+      @bs.environment_swap_cname(self.app, self.name, another.name)
+    end
+
+    def log(msg)
+      puts "[#{Time.now.utc}][environment:#{@name}] #{msg}"
+    end
+
+    def terminate
+      if @bs.environment_exists?(@app, @name)
+        with_polling_events(/terminateEnvironment completed successfully/i) do
+          @bs.delete_environment(@app, @name)
+        end
+      end
+    end
+
+
+    private
+
+    def create_or_update_env(version_label, settings)
+      if @bs.environment_exists?(@app, @name)
+        with_polling_events(/Environment update completed successfully/i) do
+          @bs.update_environment(@app, @name, version_label, @creation_opts[:tier], settings)
+        end
+      else
+        with_polling_events(/Successfully launched environment/i) do
+          @bs.create_environment(@app, @name, @creation_opts[:solution_stack], @creation_opts[:cname_prefix], version_label, @creation_opts[:tier], settings)
+        end
+      end
+    end
+
+    def smoke_test
+      host_name = @bs.environment_cname(@app, @name)
+      SmokeTest.new(@creation_opts[:smoke_test]).run(host_name, self)
+    end
+
+    def with_polling_events(terminate_pattern, &block)
+      event_start_time = Time.now
+      yield
+      event_poller.poll(event_start_time) do |event|
+        if event[:message] =~ /Failed to deploy application/
+          raise event[:message]
+        end
+
+        if event[:message] =~ /Command failed on instance/
+          raise "Elasticbeanstalk instance provision failed (maybe a problem with your .ebextension files). The original message: #{event[:message]}"
+        end
+
+        log_event(event)
+        break if event[:message] =~ terminate_pattern
+      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 event_poller
+      @event_poller || EventPoller.new(@app, @name, @bs)
+    end
+
+
+    def log_event(event)
+      puts "[#{event[:event_date]}][environment:#{@name}] #{event[:message]}"
+    end
+  end
+end

data/lib/eb_deployer/environment.rb

@@ -1,111 +1,45 @@
 module EbDeployer
   class Environment
-    attr_reader :app, :name
-    attr_writer :event_poller
 
-    def self.unique_ebenv_name(app_name, env_name)
-      raise "Environment name #{env_name} is too long, it must be under 15 chars" if env_name.size > 15
-      digest = Digest::SHA1.hexdigest(app_name + '-' + env_name)[0..6]
-      "#{env_name}-#{digest}"
-    end
-
-    def initialize(app, env_name, eb_driver, creation_opts={})
+    def initialize(app, name, resource_stacks, settings, creation_opts, bs_driver)
       @app = app
-      @name = self.class.unique_ebenv_name(app, env_name)
-      @bs = eb_driver
+      @name = name
+      @resource_stacks = resource_stacks
+      @settings = settings
       @creation_opts = creation_opts
-    end
-
-    def deploy(version_label, settings={})
-      terminate if @creation_opts[:phoenix_mode]
-      create_or_update_env(version_label, settings)
-      smoke_test
-      wait_for_env_become_healthy
+      @bs_driver = bs_driver
     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)
-      log("Swap CNAME with env #{another.name}")
-      @bs.environment_swap_cname(self.app, self.name, another.name)
+      @creation_opts[:cname_prefix] || default_cname_prefix
     end
 
-    def log(msg)
-      puts "[#{Time.now.utc}][environment:#{@name}] #{msg}"
+    def deploy(version_label, strategy_name)
+      strategy = create_strategy(strategy_name)
+      strategy.deploy(version_label,
+                       @settings + @resource_stacks.provision(resource_stack_name))
     end
 
-    def terminate
-      if @bs.environment_exists?(@app, @name)
-        with_polling_events(/terminateEnvironment completed successfully/i) do
-          @bs.delete_environment(@app, @name)
-        end
-      end
+    def new_eb_env(suffix=nil, cname_prefix_overriding=nil)
+      EbEnvironment.new(@app.name,
+                        [@name, suffix].compact.join('-'),
+                        @bs_driver,
+                        @creation_opts.merge(:cname_prefix => cname_prefix_overriding || cname_prefix))
     end
 
-
     private
 
-    def create_or_update_env(version_label, settings)
-      if @bs.environment_exists?(@app, @name)
-        with_polling_events(/Environment update completed successfully/i) do
-          @bs.update_environment(@app, @name, version_label, @creation_opts[:tier], settings)
-        end
-      else
-        with_polling_events(/Successfully launched environment/i) do
-          @bs.create_environment(@app, @name, @creation_opts[:solution_stack], @creation_opts[:cname_prefix], version_label, @creation_opts[:tier], settings)
-        end
-      end
+    def default_cname_prefix
+      [@app.name, @name].join('-')
     end
 
-    def smoke_test
-      host_name = @bs.environment_cname(@app, @name)
-      SmokeTest.new(@creation_opts[:smoke_test]).run(host_name, self)
-    end
 
-    def with_polling_events(terminate_pattern, &block)
-      event_start_time = Time.now
-      yield
-      event_poller.poll(event_start_time) do |event|
-        if event[:message] =~ /Failed to deploy application/
-          raise event[:message]
-        end
-
-        if event[:message] =~ /Command failed on instance/
-          raise "Elasticbeanstalk instance provision failed (maybe a problem with your .ebextension files). The original message: #{event[:message]}"
-        end
-
-        log_event(event)
-        break if event[:message] =~ terminate_pattern
-      end
+    def create_strategy(strategy_name)
+      DeploymentStrategy.create(self, strategy_name)
     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 event_poller
-      @event_poller || EventPoller.new(@app, @name, @bs)
-    end
-
-
-    def log_event(event)
-      puts "[#{event[:event_date]}][environment:#{@name}] #{event[:message]}"
+    def resource_stack_name
+      "#{@app.name}-#{@name}"
     end
   end
 end

data/lib/eb_deployer/resource_stacks.rb

@@ -0,0 +1,19 @@
+module EbDeployer
+  class ResourceStacks
+    def initialize(resources, cf_driver, skip_provision=false)
+      @resources = resources
+      @cf_driver = cf_driver
+      @skip_provision = skip_provision
+    end
+
+    def provision(stack_name)
+      provisioner = CloudFormationProvisioner.new(stack_name, @cf_driver)
+      if @resources
+        provisioner.provision(@resources) unless @skip_provision
+        provisioner.transform_outputs(@resources)
+      else
+        []
+      end
+    end
+  end
+end

data/lib/eb_deployer/version.rb

@@ -1,3 +1,3 @@
 module EbDeployer
-  VERSION = "0.3.6"
+  VERSION = "0.3.7"
 end

data/lib/eb_deployer.rb

@@ -1,17 +1,3 @@
-require "eb_deployer/version"
-require "eb_deployer/deployment_strategy"
-require "eb_deployer/beanstalk"
-require "eb_deployer/cloud_formation_provisioner"
-require 'eb_deployer/application'
-require "eb_deployer/environment"
-require "eb_deployer/event_poller"
-require "eb_deployer/package"
-require 'eb_deployer/s3_driver'
-require 'eb_deployer/cloud_formation_driver'
-require 'eb_deployer/config_loader'
-require 'eb_deployer/default_config'
-require 'eb_deployer/smoke_test'
-require 'eb_deployer/version_cleaner'
 require 'digest'
 require 'set'
 require 'time'
@@ -22,6 +8,21 @@ require 'optparse'
 require 'erb'
 require 'fileutils'
 
+require 'eb_deployer/version'
+require 'eb_deployer/aws_driver'
+require 'eb_deployer/deployment_strategy'
+require 'eb_deployer/cloud_formation_provisioner'
+require 'eb_deployer/application'
+require 'eb_deployer/resource_stacks'
+require 'eb_deployer/eb_environment'
+require 'eb_deployer/environment'
+require 'eb_deployer/event_poller'
+require 'eb_deployer/package'
+require 'eb_deployer/config_loader'
+require 'eb_deployer/default_config'
+require 'eb_deployer/smoke_test'
+require 'eb_deployer/version_cleaner'
+
 module EbDeployer
 
   TIERS = [
@@ -48,7 +49,7 @@ module EbDeployer
     end
     app = opts[:application]
     env_name = opts[:environment]
-    cf = opts[:cf_driver] || CloudFormationDriver.new
+    cf = opts[:cf_driver] || AWSDriver::CloudFormationDriver.new
     provisioner = CloudFormationProvisioner.new("#{app}-#{env_name}", cf)
     provisioner.output(key)
   end
@@ -177,9 +178,9 @@ module EbDeployer
       AWS.config(:region => region)
     end
 
-    bs = opts[:bs_driver] || Beanstalk.new
-    s3 = opts[:s3_driver] || S3Driver.new
-    cf = opts[:cf_driver] || CloudFormationDriver.new
+    bs = opts[:bs_driver] || AWSDriver::Beanstalk.new
+    s3 = opts[:s3_driver] || AWSDriver::S3Driver.new
+    cf = opts[:cf_driver] || AWSDriver::CloudFormationDriver.new
     stack_name = opts[:solution_stack_name] || "64bit Amazon Linux 2013.09 running Tomcat 7 Java 7"
     app = opts[:application]
     env_name = opts[:environment]
@@ -188,7 +189,7 @@ module EbDeployer
     cname = opts[:cname]
     env_settings = opts[:option_settings] || opts[:settings] || []
     strategy_name = opts[:strategy] || :blue_green
-    cname_prefix = opts[:cname_prefix] || [app, env_name].join('-')
+    cname_prefix = opts[:cname_prefix]
     smoke_test = opts[:smoke_test] || Proc.new {}
     phoenix_mode = opts[:phoenix_mode]
     bucket = opts[:package_bucket] || app
@@ -196,30 +197,24 @@ module EbDeployer
     keep_latest = opts[:keep_latest].to_i || 0
     app_tier = self.environment_tier(opts[:tier] || 'WebServer')
 
+    resource_stacks = ResourceStacks.new(opts[:resources], cf, skip_resource)
     application = Application.new(app, bs, s3, bucket)
-
-    cf = CloudFormationProvisioner.new("#{app}-#{env_name}", cf)
-
-    creation_opts = {
-      :solution_stack => stack_name,
-      :cname_prefix => cname_prefix,
-      :smoke_test => smoke_test,
-      :phoenix_mode => phoenix_mode,
-      :tier => app_tier
-    }
-
-    strategy = DeploymentStrategy.create(strategy_name, app, env_name, bs, creation_opts)
-
-    cleaner = VersionCleaner.new(application, keep_latest)
-
-    if resources = opts[:resources]
-      cf.provision(resources) unless skip_resource
-      env_settings += cf.transform_outputs(resources)
-    end
+    environment = Environment.new(application,
+                                  env_name,
+                                  resource_stacks,
+                                  env_settings,
+                                  {
+                                    :solution_stack => stack_name,
+                                    :cname_prefix => cname_prefix,
+                                    :smoke_test => smoke_test,
+                                    :phoenix_mode => phoenix_mode,
+                                    :tier => app_tier
+                                  },
+                                  bs)
 
     application.create_version(version_label, opts[:package])
-    strategy.deploy(version_label, env_settings)
-    cleaner.clean(version_prefix)
+    environment.deploy(version_label, strategy_name)
+    application.clean_versions(version_prefix, keep_latest)
   end
 
   def self.destroy(opts)
@@ -313,7 +308,6 @@ module EbDeployer
         puts "YAML package file format:"
         puts "s3_bucket: <bucket_name>"
         puts "s3_key: <object_path>"
-        exit(0)
       end
     end
   end

data/test/config_loader_test.rb

@@ -25,19 +25,6 @@ YAML
     assert_equal(nil, config[:common])
   end
 
-  def test_use_package_as_version_label_when_using_s3_obj_as_package
-    config = @loader.load(generate_input(<<-YAML, :package => 'bucket:obj'))
-application: myapp
-common:
-  strategy: inplace-update
-environments:
-  dev:
-YAML
-    assert_equal('myapp', config[:application])
-    assert_equal('bucket:obj', config[:package])
-    assert_equal('bucket:obj', config[:version_label])
-  end
-
   def test_common_settings_get_merge_into_the_config
     config = @loader.load(generate_input(<<-YAML))
 application: myapp

data/test/deploy_test.rb

@@ -432,6 +432,17 @@ class DeployTest < MiniTest::Unit::TestCase
     assert_equal({'s3_bucket' => 'test-bucket', 's3_key' => 'test-mingle.war'}, last_version[:source_bundle])
   end
 
+=begin
+  def test_deploy_with_components
+    deploy(:application => 'simple',
+           :environment => 'production',
+           :components => [{ :name => 'web' }])
+
+    assert !@eb_driver.environment_exists?('simple', eb_envname('simple', 'production'))
+
+  end
+=end
+
   private
 
   def temp_file(content)

data/test/{environment_test.rb → eb_environment_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class EnvironmentTest < MiniTest::Unit::TestCase
+class EbEnvironmentTest < MiniTest::Unit::TestCase
   class PollerStub
     class Deadloop < StandardError; end
 
@@ -25,13 +25,13 @@ class EnvironmentTest < MiniTest::Unit::TestCase
   end
 
   def test_deploy_should_create_corresponding_eb_env
-    env = EbDeployer::Environment.new("myapp", "production", @eb_driver)
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver)
     env.deploy("version1")
     assert @eb_driver.environment_exists?('myapp', eb_envname('myapp', 'production'))
   end
 
   def test_deploy_again_should_update_environment
-    env = EbDeployer::Environment.new("myapp", "production", @eb_driver)
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver)
     env.deploy("version1")
     env.deploy("version2")
     assert @eb_driver.environment_exists?('myapp', eb_envname('myapp', 'production'))
@@ -39,14 +39,14 @@ class EnvironmentTest < MiniTest::Unit::TestCase
   end
 
   def test_option_setttings_get_set_on_eb_env
-    env = EbDeployer::Environment.new("myapp", "production", @eb_driver)
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver)
     env.deploy("version1", {s1: 'v1'})
     assert_equal({s1: 'v1' },  @eb_driver.environment_settings('myapp', eb_envname('myapp', 'production')))
   end
 
   def test_should_run_smoke_test_after_deploy
     smoked_host = nil
-    env = EbDeployer::Environment.new("myapp", "production", @eb_driver, :smoke_test => Proc.new { |host| smoked_host = host })
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver, :smoke_test => Proc.new { |host| smoked_host = host })
     env.deploy("version1")
 
     assert !smoked_host.nil?
@@ -54,13 +54,13 @@ class EnvironmentTest < MiniTest::Unit::TestCase
   end
 
   def test_should_raise_runtime_error_when_deploy_failed
-    env = EbDeployer::Environment.new("myapp", "production", @eb_driver)
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver)
     env.event_poller = PollerStub.new(["start deploying", "Failed to deploy application"])
     assert_raises(RuntimeError) { env.deploy("version 1") }
   end
 
   def test_should_raise_runtime_error_when_eb_extension_execution_failed
-    env = EbDeployer::Environment.new("myapp", "production", @eb_driver)
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver)
 
     env.event_poller = PollerStub.new(["start deploying",
                                        "create environment",
@@ -72,7 +72,7 @@ class EnvironmentTest < MiniTest::Unit::TestCase
 
 
   def test_terminate_should_delete_environment
-    env = EbDeployer::Environment.new("myapp", "production", @eb_driver)
+    env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver)
     env.deploy("version1")
     env.terminate
     assert !@eb_driver.environment_exists?('myapp', eb_envname('myapp', 'production'))

data/test/test_helper.rb

@@ -15,7 +15,7 @@ class MiniTest::Unit::TestCase
   end
 
   def eb_envname(app_name, env_name)
-    EbDeployer::Environment.unique_ebenv_name(app_name, env_name)
+    EbDeployer::EbEnvironment.unique_ebenv_name(app_name, env_name)
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eb_deployer
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2014-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -40,6 +40,7 @@ files:
 - .gitignore
 - .ruby-gemset
 - .ruby-version
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
@@ -48,17 +49,22 @@ files:
 - eb_deployer.gemspec
 - lib/eb_deployer.rb
 - lib/eb_deployer/application.rb
-- lib/eb_deployer/beanstalk.rb
-- lib/eb_deployer/cloud_formation_driver.rb
+- lib/eb_deployer/aws_driver.rb
+- lib/eb_deployer/aws_driver/beanstalk.rb
+- lib/eb_deployer/aws_driver/cloud_formation_driver.rb
+- lib/eb_deployer/aws_driver/s3_driver.rb
 - lib/eb_deployer/cloud_formation_provisioner.rb
 - lib/eb_deployer/config_loader.rb
 - lib/eb_deployer/default_config.rb
 - lib/eb_deployer/default_config.yml
 - lib/eb_deployer/deployment_strategy.rb
+- lib/eb_deployer/deployment_strategy/blue_green.rb
+- lib/eb_deployer/deployment_strategy/inplace_update.rb
+- lib/eb_deployer/eb_environment.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/resource_stacks.rb
 - lib/eb_deployer/smoke_test.rb
 - lib/eb_deployer/version.rb
 - lib/eb_deployer/version_cleaner.rb
@@ -66,7 +72,7 @@ files:
 - test/cloud_formation_provisioner_test.rb
 - test/config_loader_test.rb
 - test/deploy_test.rb
-- test/environment_test.rb
+- test/eb_environment_test.rb
 - test/smoke_test_test.rb
 - test/test_helper.rb
 homepage: https://github.com/ThoughtWorksStudios/eb_deployer
@@ -82,15 +88,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 1041206842017006108
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 1041206842017006108
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.29
 signing_key: 
 specification_version: 3
 summary: Low friction deployments should be a breeze. Elastic Beanstalk provides a
@@ -101,7 +113,7 @@ test_files:
 - test/cloud_formation_provisioner_test.rb
 - test/config_loader_test.rb
 - test/deploy_test.rb
-- test/environment_test.rb
+- test/eb_environment_test.rb
 - test/smoke_test_test.rb
 - test/test_helper.rb
 has_rdoc: 

data/lib/eb_deployer/beanstalk.rb

@@ -1,126 +0,0 @@
-module EbDeployer
-  class Beanstalk
-    attr_reader :client
-
-    def initialize(client=AWS::ElasticBeanstalk.new.client)
-      @client = client
-    end
-
-    def create_application(app)
-      @client.create_application(:application_name => app)
-    end
-
-    def delete_application(app)
-      @client.delete_application(:application_name => app)
-    end
-
-    def application_exists?(app)
-      @client.describe_applications(:application_names => [app])[:applications].any?
-    end
-
-    def update_environment(app_name, env_name, version, tier, settings)
-      env_id = convert_env_name_to_id(app_name, [env_name]).first
-      request = {
-        :environment_id => env_id,
-        :version_label => version,
-        :option_settings => settings,
-        :tier => tier
-      }
-
-      @client.update_environment(request)
-    end
-
-    def environment_exists?(app_name, env_name)
-      alive_envs(app_name, [env_name]).any?
-    end
-
-    def environment_names_for_application(app_name)
-      alive_envs(app_name).collect { |env| env[:environment_name] }
-    end
-
-    def create_environment(app_name, env_name, stack_name, cname_prefix, version, tier, settings)
-      request = {
-        :application_name => app_name,
-        :environment_name => env_name,
-        :solution_stack_name => stack_name,
-        :version_label => version,
-        :option_settings => settings,
-        :tier => tier,
-        :cname_prefix => cname_prefix
-      }
-
-      @client.create_environment(request)
-    end
-
-    def delete_environment(app_name, env_name)
-      @client.terminate_environment(:environment_name => env_name)
-    end
-
-    def delete_application_version(app_name, version, delete_source_bundle)
-      request = {
-        :application_name => app_name,
-        :version_label => version,
-        :delete_source_bundle => delete_source_bundle
-      }
-      @client.delete_application_version(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(app_name)
-      application_versions(app_name).map { |apv| apv[:version_label] }
-    end
-
-    def application_versions(app_name)
-      request = { :application_name => app_name }
-      @client.describe_application_versions(request)[:application_versions]
-    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_driver.rb

@@ -1,48 +0,0 @@
-module EbDeployer
-  class CloudFormationDriver
-
-    def stack_exists?(name)
-      stack(name).exists?
-    end
-
-    def create_stack(name, template, opts)
-      cloud_formation.stacks.create(name, template, opts)
-    end
-
-    def update_stack(name, template, opts)
-      begin
-        stack(name).update(opts.merge(:template => template))
-      rescue AWS::CloudFormation::Errors::ValidationError => e
-        if e.message =~ /No updates are to be performed/
-          log(e.message)
-        else
-          raise
-        end
-      end
-    end
-
-    def stack_status(name)
-      stack(name).status.downcase.to_sym
-    end
-
-    def query_output(name, key)
-      output = stack(name).outputs.find { |o| o.key == key }
-      output && output.value
-    end
-
-    private
-
-    def cloud_formation
-      AWS::CloudFormation.new
-    end
-
-    def stack(name)
-      cloud_formation.stacks[name]
-    end
-
-    def log(msg)
-      puts "[#{Time.now.utc}][cloud_formation_driver] #{msg}"
-    end
-  end
-
-end

data/lib/eb_deployer/s3_driver.rb

@@ -1,33 +0,0 @@
-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