eb_deployer_updated 0.8.0

data/lib/eb_deployer/deployment_strategy/blue_only.rb

@@ -0,0 +1,45 @@
+module EbDeployer
+  module DeploymentStrategy
+    class BlueOnly
+      def initialize(component)
+        @component = component
+      end
+
+      def test_compatibility(env_create_options)
+        tier = env_create_options[:tier]
+        if tier && tier.downcase == 'worker'
+          raise "Blue only deployment is not supported for Worker tier"
+        end
+      end
+
+      def deploy(version_label, env_settings, inactive_settings=[])
+        if !ebenvs.any?(&method(:active_ebenv?))
+          ebenv('a', @component.cname_prefix).
+            deploy(version_label, env_settings)
+          return
+        end
+
+        inactive_ebenv = ebenvs.reject(&method(:active_ebenv?)).first
+
+        inactive_ebenv.deploy(version_label, env_settings)
+      end
+
+      private
+      def active_ebenv?(ebenv)
+        ebenv.cname_prefix == @component.cname_prefix
+      end
+
+      def ebenvs
+        [ebenv('a'), ebenv('b')]
+      end
+
+      def ebenv(suffix, cname_prefix=nil)
+        @component.new_eb_env(suffix, cname_prefix || inactive_cname_prefix)
+      end
+
+      def inactive_cname_prefix
+        "#{@component.cname_prefix}-inactive"
+      end
+    end
+  end
+end

data/lib/eb_deployer/deployment_strategy/inplace_update.rb

@@ -0,0 +1,16 @@
+module EbDeployer
+  module DeploymentStrategy
+    class InplaceUpdate
+      def initialize(component)
+        @component = component
+      end
+
+      def test_compatibility(env_create_opts)
+      end
+
+      def deploy(version_label, env_settings, inactive_settings)
+        @component.new_eb_env.deploy(version_label, env_settings)
+      end
+    end
+  end
+end

data/lib/eb_deployer/deployment_strategy.rb

@@ -0,0 +1,20 @@
+require 'eb_deployer/deployment_strategy/inplace_update'
+require 'eb_deployer/deployment_strategy/blue_green'
+require 'eb_deployer/deployment_strategy/blue_only'
+
+module EbDeployer
+  module DeploymentStrategy
+    def self.create(component, strategy_name)
+      case strategy_name.to_s
+      when 'inplace_update', 'inplace-update'
+        InplaceUpdate.new(component)
+      when 'blue_green', 'blue-green'
+        BlueGreen.new(component)
+      when 'blue_only', 'blue-only'
+        BlueOnly.new(component)
+      else
+        raise 'strategy_name: ' + strategy_name.to_s + ' not supported'
+      end
+    end
+  end
+end

data/lib/eb_deployer/eb_environment.rb

@@ -0,0 +1,204 @@
+module EbDeployer
+  class EbEnvironment
+    include Utils
+
+    attr_reader :app, :name
+    attr_writer :event_poller
+
+    def self.unique_ebenv_name(env_name, app_name)
+      raise "Environment name #{env_name} is too long, it must be under 32 chars" if env_name.size > 32
+      digest = Digest::SHA1.hexdigest(app_name + '-' + env_name)[0..6]
+      "#{env_name}-#{digest}"
+    end
+
+    def initialize(app, name, eb_driver, creation_opts={})
+      @app = app
+      @name = self.class.unique_ebenv_name(name, app)
+      @bs = eb_driver
+      @creation_opts = default_create_options.merge(reject_nil(creation_opts))
+      @accepted_healthy_states = @creation_opts[:accepted_healthy_states]
+      @event_poller = nil
+    end
+
+    def deploy(version_label, settings={})
+      terminate if @creation_opts[:phoenix_mode]
+
+      if @bs.environment_exists?(@app, @name)
+        update_eb_env(settings, version_label)
+      else
+        create_eb_env(settings, version_label)
+      end
+
+      smoke_test
+      wait_for_env_become_healthy
+    end
+
+    def apply_settings(settings)
+      raise "Env #{self.name} not exists for applying settings" unless @bs.environment_exists?(@app, @name)
+      wait_for_env_status_to_be_ready
+      with_polling_events(/Successfully deployed new configuration to environment/i) do
+        @bs.update_environment_settings(@app, @name, settings)
+      end
+    end
+
+    def cname_prefix
+      @bs.environment_cname_prefix(@app, @name)
+    end
+
+    def swap_cname_with(another)
+      log("Swap CNAME with env #{another.name}")
+      with_polling_events(/Completed swapping CNAMEs for environments/i) do
+        @bs.environment_swap_cname(self.app, self.name, another.name)
+      end
+    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
+
+    def health_state
+      @bs.environment_health_state(@app, @name)
+    end
+
+    private
+
+    def configured_tier
+      @creation_opts[:tier]
+    end
+
+    def template_name
+      @creation_opts[:template_name]
+    end
+
+    def has_cname?
+      !configured_tier || configured_tier.downcase == 'webserver'
+    end
+
+    def configured_cname_prefix
+      @creation_opts[:cname_prefix]
+    end
+
+    def create_eb_env(settings, version_label)
+      solution_stack = @creation_opts[:solution_stack]
+      tags = convert_tags_hash_to_array(@creation_opts.delete(:tags))
+      validate_solutions_stack(solution_stack)
+      with_polling_events(/Successfully launched environment/i) do
+        @bs.create_environment(@app,
+                               @name,
+                               solution_stack,
+                               has_cname? ? configured_cname_prefix : nil,
+                               version_label,
+                               configured_tier,
+                               tags,
+                               settings,
+                               template_name)
+      end
+    end
+
+    def update_eb_env(settings, version_label)
+      with_polling_events(/Successfully deployed new configuration to environment/i) do
+        @bs.update_environment(@app,
+                               @name,
+                               version_label,
+                               configured_tier,
+                               settings,
+                               template_name)
+      end
+    end
+
+    def validate_solutions_stack(stack_name)
+      names = @bs.list_solution_stack_names
+      raise "'#{stack_name}' is not a valid solution stack name, available solution stack names are: #{names.join(', ')}" unless names.include?(stack_name)
+    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)
+      anchor = event_poller.get_anchor
+      yield
+      event_poller.poll(anchor) 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
+
+        if event[:message] =~ /complete, but with errors/
+          raise event[:message]
+        end
+
+        if event[:message] =~ /However, there were issues during launch\. See event log for details\./
+          raise "Environment launched, but with errors.  The original message: #{event[:message]}"
+        end
+
+        log_event(event)
+        break if event[:message] =~ terminate_pattern
+      end
+    end
+
+    def convert_tags_hash_to_array tags
+      tags ||= {}
+      tags.inject([]) do |arr, (k, v)|
+        arr << {:key => k, :value => v}
+        arr
+      end
+    end
+
+    def wait_for_env_status_to_be_ready
+      Timeout.timeout(600) do
+        current_status = @bs.environment_status(@app, @name)
+
+        while current_status.downcase != 'ready'
+          log("Environment status: #{current_status}")
+          sleep 15
+          current_status = @bs.environment_status(@app, @name)
+        end
+
+        log("Environment status: #{current_status}")
+      end
+    end
+
+    def wait_for_env_become_healthy
+      Timeout.timeout(600) do
+        current_health_status = @bs.environment_health_state(@app, @name)
+        while !@accepted_healthy_states.include?(current_health_status)
+          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(EbEventSource.new(@app, @name, @bs))
+    end
+
+    def default_create_options
+      {
+        :solution_stack => "64bit Amazon Linux 2014.09 v1.1.0 running Tomcat 7 Java 7",
+        :smoke_test =>  Proc.new {},
+        :tier => 'WebServer',
+        :accepted_healthy_states => ['Green']
+      }
+    end
+
+    def log_event(event)
+      puts "[#{event[:event_date]}][environment:#{@name}] #{event[:message]}"
+    end
+  end
+end

data/lib/eb_deployer/eb_event_source.rb

@@ -0,0 +1,35 @@
+module EbDeployer
+  class EbEventSource
+    def initialize(app, env, eb_driver)
+      @app, @env, @eb_driver = app, env, eb_driver
+    end
+
+    def get_anchor
+      events, _ = fetch_events_from_eb(:max_records => 1)
+      events.first
+    end
+
+    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
+
+    private
+
+    def fetch_next(next_token, &block)
+      events, next_token = fetch_events_from_eb(:next_token => next_token)
+      should_continue = yield(events)
+      fetch_next(next_token, &block) if next_token && should_continue
+    end
+
+    def fetch_events_from_eb(options)
+      @eb_driver.fetch_events(@app, @env, options)
+    end
+
+  end
+end

data/lib/eb_deployer/environment.rb

@@ -0,0 +1,60 @@
+module EbDeployer
+  class Environment
+    include Utils
+    attr_accessor :creation_opts, :strategy_name
+
+    attr_writer :resource_stacks, :settings, :inactive_settings, :component_under_deploy
+
+    attr_reader :name
+
+    def initialize(app, name, stack_name, eb_driver, &block)
+      @app = app
+      @name = name
+      @stack_name = stack_name
+      @eb_driver = eb_driver
+      @creation_opts = {}
+      @settings = []
+      @inactive_settings = []
+      @strategy_name = :blue_green
+      @components = nil
+      yield(self) if block_given?
+      unless @components
+        @components = [DefaultComponent.new(self, @creation_opts, @strategy_name, @eb_driver)]
+      end
+    end
+
+    def app_name
+      @app.name
+    end
+
+    def deploy(version_label)
+      resource_settings = @resource_stacks.provision(@stack_name)
+      components_to_deploy.each do |component|
+        component.deploy(version_label, @settings + resource_settings, @inactive_settings)
+      end
+    end
+
+    def components=(components_attrs)
+      return unless components_attrs
+      @components = components_attrs.map do |attrs|
+        attrs = symbolize_keys(attrs)
+        Component.new(attrs.delete(:name), self, attrs, @eb_driver)
+      end
+    end
+
+    private
+    def components_to_deploy
+      if @component_under_deploy
+        component = component_named(@component_under_deploy)
+        raise "'#{@component_under_deploy}' is not in the configuration. Available components are #{@components.map(&:name) }" unless component
+        [component]
+      else
+        @components
+      end
+    end
+
+    def component_named(name)
+      @components.detect { |c| c.name == name }
+    end
+  end
+end

data/lib/eb_deployer/event_poller.rb

@@ -0,0 +1,51 @@
+module EbDeployer
+  class EventPoller
+    include Utils
+    POLL_INTERVAL = 15
+
+    def initialize(event_source)
+      @event_source = event_source
+    end
+
+    def get_anchor
+      @event_source.get_anchor
+    end
+
+    def poll(from_anchor, &block)
+      handled = Set.new
+      loop do
+        @event_source.fetch_events(from_anchor) do |events|
+          # events from event source 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 POLL_INTERVAL
+      end
+    end
+
+    private
+
+    def digest(event)
+      return nil unless event
+      event = event.to_h if event.respond_to?(:to_h)
+      event.to_json
+    end
+  end
+end

data/lib/eb_deployer/package.rb

@@ -0,0 +1,39 @@
+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)
+        log("start uploading to s3 bucket #{@bucket_name}...")
+        @s3.upload_file(@bucket_name, s3_path, file)
+        log("uploading finished")
+      end
+    end
+
+    def log(message)
+      puts "[#{Time.now.utc}][package:#{File.basename(@file)}] #{message}"
+    end
+  end
+end

data/lib/eb_deployer/resource_stacks.rb

@@ -0,0 +1,20 @@
+module EbDeployer
+  class ResourceStacks
+    def initialize(resources, cf_driver, skip_provision, tags)
+      @resources = resources
+      @cf_driver = cf_driver
+      @skip_provision = skip_provision
+      @tags = (tags || {}).map { |k, v| { key: k, value: v } }
+    end
+
+    def provision(stack_name)
+      provisioner = CloudFormationProvisioner.new(stack_name, @cf_driver)
+      if @resources
+        provisioner.provision(@resources, @tags) unless @skip_provision
+        provisioner.transform_outputs(@resources)
+      else
+        []
+      end
+    end
+  end
+end

data/lib/eb_deployer/smoke_test.rb

@@ -0,0 +1,23 @@
+module EbDeployer
+  class SmokeTest
+    def initialize(test_body)
+      @test_body = test_body
+    end
+
+    def run(host_name, logger=nil)
+      return unless @test_body
+      logger.log("running smoke test for #{host_name}...") if logger
+
+      case @test_body
+      when Proc
+        @test_body.call(host_name)
+      when String
+        eval(@test_body, binding)
+      else
+        raise "smoke test can only be a string to evaluate or a proc object such as lambda"
+      end
+
+      logger.log("smoke test succeeded.") if logger
+    end
+  end
+end

data/lib/eb_deployer/tasks.rb

@@ -0,0 +1,45 @@
+require 'fileutils'
+require 'open3'
+
+namespace :eb do
+  def eb_deployer_env
+    ENV['EB_DEPLOYER_ENV'] || 'dev'
+  end
+
+  def eb_deployer_package
+    name = File.basename(Dir.pwd).downcase.gsub(/[^0-9a-z]/, '-').gsub(/--/, '-')
+    "tmp/#{name}.zip"
+  end
+
+  def eb_package_files
+    ignore_file = File.join(Dir.pwd, ".ebdeployerignore")
+    ignore_patterns = File.exists?(ignore_file) ? File.readlines(ignore_file).map(&:strip) : []
+    `git ls-files`.lines.reject { |f| ignore_patterns.any? { |p| File.fnmatch(p, f.strip) } }
+  end
+
+  desc "Remove the package file we generated."
+  task :clean do
+    sh "rm -rf #{eb_deployer_package}"
+  end
+
+  desc "Build package for eb_deployer to deploy to a Ruby environment in tmp directory. It zips all file list by 'git ls-files'"
+  task :package => [:clean] do
+    package = eb_deployer_package
+    FileUtils.mkdir_p(File.dirname(package))
+    Open3.popen2("zip #{package} -@") do |i, o, t|
+      i.write(eb_package_files.join)
+      i.close
+      puts o.read
+    end
+  end
+
+  desc "Deploy package we built in tmp directory. default to dev environment, specify environment variable EB_DEPLOYER_ENV to override, for example: EB_DEPLOYER_ENV=production rake eb:deploy."
+  task :deploy => [:package] do
+    sh "eb_deploy -p #{eb_deployer_package} -e #{eb_deployer_env}"
+  end
+
+  desc "Destroy Elastic Beanstalk environments. It won't destroy resources defined in eb_deployer.yml. Default to dev environment, specify EB_DEPLOYER_ENV to override."
+  task :destroy do
+    sh "eb_deploy -d -e #{eb_deployer_env}"
+  end
+end

data/lib/eb_deployer/throttling_handling.rb

@@ -0,0 +1,17 @@
+module EbDeployer
+  class ThrottlingHandling
+    include Utils
+
+    def initialize(delegatee, throttling_error)
+      @delegatee = delegatee
+      @throttling_error = throttling_error
+    end
+
+    def method_missing(method, *args, &block)
+      super unless @delegatee.respond_to?(method)
+      backoff(@throttling_error) do
+        @delegatee.send(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/eb_deployer/utils.rb

@@ -0,0 +1,33 @@
+module EbDeployer
+  module Utils
+    BACKOFF_INITIAL_SLEEP = 1
+
+    # A util deal with throttling exceptions
+    # example:
+    #  backoff(Aws::EC2::Errors::RequestLimitExceeded) do
+    #     ...
+    #  end
+    def backoff(error_class, retry_limit=9, &block)
+      next_sleep = BACKOFF_INITIAL_SLEEP
+      begin
+        yield
+      rescue error_class
+        raise if retry_limit == 0
+        sleep(next_sleep)
+        next_sleep *= 2
+        retry_limit -= 1
+        retry
+      end
+    end
+
+    # convert top level key in a hash to symbol
+    def symbolize_keys(hash)
+      hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    end
+
+
+    def reject_nil(hash)
+      hash.reject{| k, v| v.nil?}
+    end
+  end
+end

data/lib/eb_deployer/version.rb

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

data/lib/eb_deployer/version_cleaner.rb

@@ -0,0 +1,30 @@
+module EbDeployer
+  class VersionCleaner
+    def initialize(app, number_to_keep)
+      @app = app
+      @number_to_keep = number_to_keep
+    end
+
+    def clean(version_prefix = "")
+      if @number_to_keep > 0
+        versions_to_remove = versions_to_clean(version_prefix)
+        @app.remove(versions_to_remove, true)
+      end
+    end
+
+    private
+    def versions_to_clean(version_prefix = "")
+      all_versions = @app.versions.select do |apv|
+        apv[:version].start_with?(version_prefix)
+      end
+
+      all_versions.sort! { |x, y| y[:date_updated] <=> x[:date_updated] }
+      all_versions.slice!(range_to_keep)
+      all_versions.map { |apv| apv[:version] }
+    end
+
+    def range_to_keep
+      (0..(@number_to_keep-1))
+    end
+  end
+end