eb_deployer 0.4.5 → 0.4.6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    eb_deployer (0.4.4)
+    eb_deployer (0.4.6)
       aws-sdk (>= 1.33.0)
 
 GEM
@@ -23,7 +23,7 @@ GEM
     activesupport (3.2.18)
       i18n (~> 0.6, >= 0.6.4)
       multi_json (~> 1.0)
-    aws-sdk (1.42.0)
+    aws-sdk (1.43.1)
       json (~> 1.4)
       nokogiri (>= 1.4.4)
     builder (3.0.4)

data/README.md

@@ -5,6 +5,8 @@ Low friction deployments should be a breeze. Elastic Beanstalk provides a great
 
 EbDeployer thus allows you to do continuous delivery on AWS.
 
+[Introduction to EbDeployer](http://getmingle.io/scaling/2014/06/13/introduction-to-eb-deployer.html)
+
 ## Installation
 
     $ gem install eb_deployer
@@ -88,71 +90,11 @@ Later tutorials coming soon will cover
 
 Take a look at code if you can not wait for the documentation.
 
-## Rails 3+ support
-
-EbDeployer ships with a Rails 3+ generator since version 0.4.5.
-
-### Install
-
-Add eb_deployer to your Gemfile
-
-		gem 'eb_deployer'
-
-Setup AWS credentials:
-
-    $ export AWS_ACCESS_KEY_ID=xxx
-    $ export AWS_SECRET_ACCESS_KEY=xxx
-
-### Initial configurations and rake tasks
-
-Run Rails generator to generate configurations and rake file:
-
-		rails generate eb_deployer:install
-
-It will setup AWS Elastic Beanstalk blue-green deployment configuration with a Postgres RDS instance as your Rails' backend database.
-The followings are details:
-
-* Add file "lib/tasks/eb_deployer.rake", please run "rake -T eb" for tasks description. These tasks are simple and designed for you to customize.
-* Add file "config/eb_deployer.yml", it includes basic blue-green configurations with a Postgres RDS instance resource.
-* Add file "config/rds.json", it is a CloudFormation template file which provisions the Postgres RDS instance. A separated CloudFormation stack maintains all resources that are shared between different Elastic Beanstalk environments in blue-green deployment. Notice: each eb_deployer environment will create one.
-* Add "gem 'pg'" to your Gemfile, as this initial configuration is hooking up with a Postgres RDS instance, we need postgres driver.
-* Add file ".ebextenstions/01_postgres_packages.config", which installs Postgres dev packages on EC2 instances, so that we can build gem "pg" on your EC2 machine after deployed.
-* Add a new production database configuration into "config/database.yml" file. Your original production configuration will be commented out.
-
-### Deploy
-
-Add all files that need to be deployed into your Git repository, because we will simply use "git ls-files" to find all files need to be packaged.
-
-Deploy a dev environment for testing your application deployment:
-
-		rake eb:deploy
-
-Then, when you're ready to deploy a production environment:
-
-		EB_DEPLOYER_ENV=production rake eb:deploy
-
-## EbDeployer environment
-
-There are so many things called environment:
-
-* Rails environment: development, test, production
-* Elastic Beanstalk environment
-* Development environment
-* Staging environment
-* Production environment
-
-An EbDeployer environment is your application running environment (= your running application + infrastructure), e.g. staging environment, production environment.
-All EbDeployer environments including dev environment are deployed as Rails production environment.
+## More
 
-What is different between EbDeployer environment and Elastic Beanstalk environment?
+[Rails 3 Support](https://github.com/ThoughtWorksStudios/eb_deployer/wiki/Rails-3-Support)
 
-* There are 2 level concepts in Elastic Beanstalk: Application and Environment
-* EbDeployer environment sits between Elastic Beanstalk Application and Elastic Beanstalk Environment:
-	* One Elastic Beanstalk Application has many EbDeployer environments: dev, staging, production, or whatever names you like.
-	* Depending on deployment strategy, one EbDeployer environment has one or more Elastic Beanstalk environments
-		* For 'inplace-update' deployment strategy, it's one Elastic Beanstalk environment.
-		* For 'blue-green' deployment strategy, it's two Elastic Beanstalk environments.
-* You should consider an Elastic Beanstalk environment is designed to be replacable (by another Elastic Beanstalk environment).
+[EbDeployer environment](https://github.com/ThoughtWorksStudios/eb_deployer/wiki/EbDeployer-environment)
 
 ## Contributing
 

data/lib/eb_deployer/eb_environment.rb

@@ -89,9 +89,9 @@ module EbDeployer
     end
 
     def with_polling_events(terminate_pattern, &block)
-      event_start_time = Time.now
+      anchor = event_poller.get_anchor
       yield
-      event_poller.poll(event_start_time) do |event|
+      event_poller.poll(anchor) do |event|
         if event[:message] =~ /Failed to deploy application/
           raise event[:message]
         end

data/lib/eb_deployer/event_poller.rb

@@ -6,13 +6,35 @@ module EbDeployer
       @app, @env, @eb_driver = app, env, eb_driver
     end
 
-    def poll(start_time = Time.now, &block)
+    def get_anchor
+      events, _ = fetch_events_from_eb(:max_records => 1)
+      events.first
+    end
+
+    def poll(from_anchor, &block)
       handled = Set.new
       loop do
-        fetch_events(start_time) do |events|
-          new_events = events.reject { |e| handled.include?(digest(e)) }
-          handle(new_events, &block)
-          handled += new_events.map { |e| digest(e) }
+        fetch_events(from_anchor) do |events|
+          # events from api is latest first order
+          to_be_handled = []
+          reached_anchor = false
+
+          events.each do |event|
+            if digest(event) == digest(from_anchor)
+              reached_anchor = true
+            end
+
+            if !handled.include?(digest(event)) && !reached_anchor
+              to_be_handled << event
+            end
+          end
+
+          to_be_handled.reverse.each do |event|
+            yield(event)
+            handled << digest(event)
+          end
+
+          !reached_anchor
         end
         sleep 15
       end
@@ -21,23 +43,24 @@ module EbDeployer
     private
 
     def digest(event)
+      return nil unless event
       JSON.dump(event)
     end
 
-    def handle(events, &block)
-      events.reverse.each(&block)
-    end
-
-    def fetch_events(start_time, &block)
-      events, next_token = fetch_events_from_eb(:start_time => start_time.iso8601)
-      yield(events)
-      fetch_next(next_token, &block) if next_token
+    def fetch_events(from_anchor, &block)
+      options = {}
+      if from_anchor && from_anchor[:event_date]
+        options[:start_time] = from_anchor[:event_date].iso8601
+      end
+      events, next_token = fetch_events_from_eb(options)
+      should_continue = yield(events)
+      fetch_next(next_token, &block) if next_token && should_continue
     end
 
     def fetch_next(next_token, &block)
       events, next_token = fetch_events_from_eb(:next_token => next_token)
-      yield(events)
-      fetch_next(next_token, &block) if next_token
+      should_continue = yield(events)
+      fetch_next(next_token, &block) if next_token && should_continue
     end
 
     def fetch_events_from_eb(options)

data/lib/eb_deployer/version.rb

@@ -1,3 +1,3 @@
 module EbDeployer
-  VERSION = "0.4.5"
+  VERSION = "0.4.6"
 end

data/test/aws_driver_stubs.rb

@@ -1,11 +1,12 @@
 class EBStub
-  attr_reader :envs
+  attr_reader :envs, :events
   def initialize
     @apps = []
     @envs = {}
     @versions = {}
     @envs_been_deleted = {}
     @versions_deleted = {}
+    @event_fetched_times = 0
   end
 
   def create_application(app)
@@ -88,21 +89,53 @@ class EBStub
     end
   end
 
+  # simulating elasticbeanstalk events api behavior
+  #  use set_events and append_events to set fake events
   def fetch_events(app_name, env_name, options={})
-    set_env_ready(app_name, env_name, true)
+    @event_fetched_times += 1
+    set_env_ready(app_name, env_name, true) # assume env become ready after it spit out all the events
 
     unless @events # unrestricted mode for testing if no explicit events set
-      return generate_event_from_messages(['Environment update completed successfully',
+      return [generate_event_from_messages(['Environment update completed successfully',
                                            'terminateEnvironment completed successfully',
                                            'Successfully launched environment',
                                            'Completed swapping CNAMEs for environments'
-                                          ])
+                                          ], Time.now + @event_fetched_times), nil]
     end
 
-    @events[env_key(app_name, env_name)]
-    # assume env become ready after it spit out all the events
-  end
+    events = @events[env_key(app_name, env_name)][@event_fetched_times - 1]
+
+    if options.has_key?(:start_time)
+      start_time = Time.parse(options[:start_time])
+      events = events.select { |e| e[:event_date] >= start_time  }
+    end
+
+    if limit = options[:max_records]
+      events = events[0..limit]
+    end
 
+    [events, nil]
+  end
+
+  # add fake events for each times of fetch events call
+  # message passed in should be old to new order
+  # e.g.  given set_events("myapp", "test", ['a'], ['b', 'c'])
+  # then
+  #    fetch_events('myapp', 'test') # => [{message: 'a'}]  for first time
+  #    fetch_events('myapp', 'test') # => [{message: 'c'}, {message: 'b'}, {message: 'a'}] for the second time call
+  def set_events(app_name, env_name, *messages)
+    events_seq = []
+    messages.each do |messages_for_call_seq|
+      if old_events = events_seq.last
+        last_event_date = old_events.first && old_events.first[:event_date]
+        events_seq << (generate_event_from_messages(messages_for_call_seq, last_event_date) + old_events)
+      else
+        events_seq << generate_event_from_messages(messages_for_call_seq)
+      end
+    end
+    @events ||= {}
+    @events[env_key(app_name, env_name)] = events_seq
+  end
 
   def environment_cname_prefix(app_name, env_name)
     return unless @envs[env_key(app_name, env_name)]
@@ -135,7 +168,7 @@ class EBStub
   end
 
   def list_solution_stack_names
-    @solution_stacks || ["64bit Amazon Linux 2014.02 v1.0.1 running Tomcat 7 Java 7"]
+    @solution_stacks || ["64bit Amazon Linux 2014.03 v1.0.3 running Tomcat 7 Java 7"]
   end
 
   #test only
@@ -175,11 +208,6 @@ class EBStub
     @versions_deleted[app_name]
   end
 
-  def set_events(app_name, env_name, messages)
-    @events ||= {}
-    @events[env_key(app_name, env_name)] = generate_event_from_messages(messages)
-  end
-
   private
 
   def set_env_ready(app, env, ready)
@@ -192,11 +220,17 @@ class EBStub
     @envs[env_key(app, env)][:ready]
   end
 
-  def generate_event_from_messages(messages)
-    [messages.reverse.map do |m|
-       {:event_date => Time.now.utc,
-         :message => m}
-     end, nil]
+  def generate_event_from_messages(messages, start_time=Time.now)
+    start_time ||= Time.now
+    events = messages.map do |m|
+      { :message => m }
+    end
+
+    events.each_with_index do |e, i|
+      e[:event_date] = start_time + (i + 1)
+    end
+
+    events.reverse
   end
 
   def env_key(app, name)

data/test/eb_environment_test.rb

@@ -43,16 +43,20 @@ class EbEnvironmentTest < MiniTest::Unit::TestCase
 
   def test_should_raise_runtime_error_when_deploy_failed
     env = EbDeployer::EbEnvironment.new("myapp", "production", @eb_driver)
-    @eb_driver.set_events("myapp", t("production", 'myapp'), ["start deploying", "Failed to deploy application"])
+    @eb_driver.set_events("myapp", t("production", 'myapp'),
+                          [],
+                          ["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::EbEnvironment.new("myapp", "production", @eb_driver)
-    @eb_driver.set_events("myapp", t("production", 'myapp'), ["start deploying",
-                                                  "create environment",
-                                                  "Command failed on instance. Return code: 1 Output: Error occurred during build: Command hooks failed",
-                                                  "Successfully launched environment"])
+    @eb_driver.set_events("myapp", t("production", 'myapp'),
+                          [],
+                          ["start deploying",
+                           "create environment",
+                           "Command failed on instance. Return code: 1 Output: Error occurred during build: Command hooks failed",
+                           "Successfully launched environment"])
 
     assert_raises(RuntimeError) { env.deploy("version 1") }
   end

data/test/event_poller_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class EventPollerTest < MiniTest::Unit::TestCase
+  def setup
+    @eb = EBStub.new
+    @poller = EbDeployer::EventPoller.new("myapp", "test", @eb)
+  end
+
+  def test_run_handle_block_through_all_events_when_there_is_no_from_anchor
+    messages_handled = []
+    @eb.set_events('myapp', 'test', ['a', 'b', nil])
+    @poller.poll(nil) do |event|
+      break if event[:message].nil?
+      messages_handled << event[:message]
+    end
+
+    assert_equal ['a', 'b'], messages_handled
+  end
+
+
+  def test_can_poll_all_events_after_an_anchor
+    @eb.set_events('myapp', 'test', ['a', 'b'], ['c', 'd', nil])
+    anchor = @poller.get_anchor
+    messages_handled = []
+    @poller.poll(anchor) do |event|
+      break if event[:message].nil?
+      messages_handled << event[:message]
+    end
+
+    assert_equal ['c', 'd'], messages_handled
+  end
+end

data/test/rails_generators_test.rb

@@ -22,7 +22,7 @@ class RailsGenratorsTest < Rails::Generators::TestCase
 
     assert_file 'config/rds.json'
     assert_file '.ebextensions/01_postgres_packages.config'
-    assert_file 'config/database.yml', /database: <%= ENV\['RDS_DB_NAME'\]/m, /host: <%= ENV\['RDS_HOSTNAME'\]/m
+    assert_file 'config/database.yml', /database: <%= ENV\['DATABASE_NAME'\]/m, /host: <%= ENV\['DATABASE_HOST'\]/m
     assert_file 'Gemfile', /gem "pg"/
   end
 
@@ -52,11 +52,11 @@ test:
 
 production:
   adapter: postgresql
-  database: <%= ENV['RDS_DB_NAME'] || 'tmp_production' %>
-  host: <%= ENV['RDS_HOSTNAME'] || 'localhost' %>
-  port: <%= ENV['RDS_PORT'] || 5432 %>
-  username: <%= ENV['RDS_USERNAME'] || \"xli\" %>
-  password: <%= ENV['RDS_PASSWORD'] %>
+  database: <%= ENV['DATABASE_NAME'] || 'tmp_production' %>
+  host: <%= ENV['DATABASE_HOST'] || 'localhost' %>
+  port: <%= ENV['DATABASE_PORT'] || 5432 %>
+  username: <%= ENV['DATABASE_USERNAME'] || #{ENV['USER'].inspect} %>
+  password: <%= ENV['DATABASE_PASSWORD'] %>
   min_messages: ERROR
 YAML
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eb_deployer
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.6
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-10 00:00:00.000000000 Z
+date: 2014-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -86,6 +86,7 @@ files:
 - test/config_loader_test.rb
 - test/deploy_test.rb
 - test/eb_environment_test.rb
+- test/event_poller_test.rb
 - test/inplace_update_deploy_test.rb
 - test/multi_components_deploy_test.rb
 - test/rails_generators_test.rb
@@ -128,6 +129,7 @@ test_files:
 - test/config_loader_test.rb
 - test/deploy_test.rb
 - test/eb_environment_test.rb
+- test/event_poller_test.rb
 - test/inplace_update_deploy_test.rb
 - test/multi_components_deploy_test.rb
 - test/rails_generators_test.rb