man_eb_deployer 0.8.0

data/lib/eb_deployer/aws_driver/beanstalk.rb

@@ -0,0 +1,158 @@
+module EbDeployer
+  module AWSDriver
+    class Beanstalk
+      include Utils
+      attr_reader :client
+
+      def initialize(client=Aws::ElasticBeanstalk::Client.new)
+        @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_settings(app, env, settings)
+        env_id = convert_env_name_to_id(app, [env]).first
+        @client.update_environment(:environment_id => env_id, :option_settings => settings)
+      end
+
+      def update_environment(app_name, env_name, version, tier, settings, template_name)
+        env_id = convert_env_name_to_id(app_name, [env_name]).first
+        request = reject_nil({
+          :environment_id => env_id,
+          :version_label => version,
+          :option_settings => settings,
+          :tier => environment_tier(tier),
+          :template_name => template_name
+        })
+        @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, tags, settings, template_name)
+        request = reject_nil({
+          :application_name => app_name,
+          :environment_name => env_name,
+          :solution_stack_name => stack_name,
+          :version_label => version,
+          :option_settings => settings,
+          :tier => environment_tier(tier),
+          :cname_prefix => cname_prefix,
+          :tags => tags,
+          :template_name => template_name
+        })
+        @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 =~ /^([^\.]+)(?:\.(?:[a-z0-9\-]+))?\.elasticbeanstalk\.com/i
+          $1
+        end
+      end
+
+      def environment_cname(app_name, env_name)
+        get_environment_attribute(app_name, env_name, :cname)
+      end
+
+      def environment_health_state(app_name, env_name)
+        get_environment_attribute(app_name, env_name, :health)
+      end
+
+      def environment_status(app_name, env_name)
+        get_environment_attribute(app_name, env_name, :status)
+      end
+
+      def environment_verion_label(app_name, env_name)
+        get_environment_attribute(app_name, env_name, :version_label)
+      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_cnames(:source_environment_id => env1_id,
+                                         :destination_environment_id => env2_id)
+      end
+
+      def list_solution_stack_names
+        @client.list_available_solution_stacks[:solution_stacks]
+      end
+
+      private
+
+      TIERS = [
+               {:name=>"Worker", :type=>"SQS/HTTP"},
+               {:name=>"WebServer", :type=>"Standard"}
+              ]
+
+      def get_environment_attribute(app_name, env_name, attribute)
+        env = alive_envs(app_name, [env_name]).first
+        env && env[attribute]
+      end
+
+      def environment_tier(name)
+        TIERS.find {|t| t[:name].downcase == name.downcase} || raise("No tier found with name #{name.inspect}")
+      end
+
+      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,53 @@
+module EbDeployer
+  module AWSDriver
+    class CloudFormationDriver
+
+      def initialize
+        @client = Aws::CloudFormation::Client.new
+      end
+
+      def stack_exists?(name)
+        describe_stack(name)
+        true
+      rescue Aws::CloudFormation::Errors::ValidationError
+        false
+      end
+
+      def create_stack(name, template, opts)
+        @client.create_stack(opts.merge(:stack_name => name,
+                                        :template_body => template,
+                                        :parameters => convert_parameters(opts[:parameters])))
+      end
+
+      def update_stack(name, template, opts)
+        @client.update_stack(opts.merge(:stack_name => name,
+                                        :template_body => template,
+                                        :parameters => convert_parameters(opts[:parameters])))
+      end
+
+      def query_output(name, key)
+        output = describe_stack(name)[:outputs].find { |o| o[:output_key] == key }
+        output && output[:output_value]
+      end
+
+      def fetch_events(name, options={})
+        response = @client.describe_stack_events(options.merge(:stack_name => name))
+        return response.stack_events, response.next_token
+      end
+
+      private
+
+      def describe_stack(name)
+        @client.describe_stacks(:stack_name => name)[:stacks].first
+      end
+
+      def log(msg)
+        puts "[#{Time.now.utc}][cloud_formation_driver] #{msg}"
+      end
+
+      def convert_parameters(params)
+        params.map { |k, v| {:parameter_key => k, :parameter_value => v}}
+      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)
+        s3.create_bucket(:bucket => bucket_name)
+      end
+
+      def bucket_exists?(bucket_name)
+        s3.bucket(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)
+        o.upload_file(file)
+      end
+
+      private
+      def s3
+        Aws::S3::Resource.new(client: Aws::S3::Client.new)
+      end
+
+      def obj(bucket_name, obj_name)
+        s3.bucket(bucket_name).object(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/cf_event_source.rb

@@ -0,0 +1,26 @@
+module EbDeployer
+  class CfEventSource
+    def initialize(stack_name, cf_driver)
+      @stack_name = stack_name
+      @cf_driver = cf_driver
+    end
+
+    def get_anchor
+      events, _ = @cf_driver.fetch_events(@stack_name)
+      events.first
+    end
+
+    def fetch_events(from_anchor, &block)
+      events, next_token = @cf_driver.fetch_events(@stack_name)
+      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 = @cf_driver.fetch_events(@stack_name, :next_token => next_token)
+      should_continue = yield(events)
+      fetch_next(next_token, &block) if next_token && should_continue
+    end
+  end
+end

data/lib/eb_deployer/cloud_formation_provisioner.rb

@@ -0,0 +1,120 @@
+module EbDeployer
+  class ResourceNotInReadyState < StandardError
+  end
+
+  class CloudFormationProvisioner
+    SUCCESS_STATS = ["CREATE_COMPLETE", "UPDATE_COMPLETE"]
+    FAILED_STATS = ["CREATE_FAILED", "UPDATE_FAILED", "UPDATE_ROLLBACK_COMPLETE"]
+
+    def initialize(stack_name, cf_driver)
+      @stack_name = stack_name
+      @cf_driver = cf_driver
+      @poller = EventPoller.new(CfEventSource.new(@stack_name, @cf_driver))
+    end
+
+    def provision(resources, tags)
+      resources = symbolize_keys(resources)
+      template = File.read(resources[:template])
+      capabilities = resources[:capabilities] || []
+      params = resources[:inputs] || resources[:parameters] || {}
+      policy = File.read(resources[:policy]) if resources[:policy]
+      override_policy = resources[:override_policy] || false
+      anchor = nil
+      begin
+        if stack_exists?
+          anchor = @poller.get_anchor
+          update_stack(template, params, capabilities, policy, override_policy, tags)
+        else
+          create_stack(template, params, capabilities, policy, tags)
+        end
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        if e.message =~ /No updates are to be performed/
+          log(e.message)
+          return
+        else
+          raise
+        end
+      end
+      wait_for_stack_op_terminate(anchor)
+      log("Resource stack provisioned successfully")
+    end
+
+    def transform_outputs(resources)
+      resources = symbolize_keys(resources)
+      outputs = resources[:outputs] || {}
+      transforms = resources[:transforms] || {}
+      transform_output_to_settings(convert_to_transforms(outputs).merge(transforms))
+    end
+
+    def output(key)
+      @cf_driver.query_output(@stack_name, key)
+    rescue Aws::CloudFormation::Errors::ValidationError
+      raise ResourceNotInReadyState.new("Resource stack not in ready state yet, perhaps you should provision it first?")
+    end
+
+    private
+
+    #todo: remove duplication
+    def symbolize_keys(hash)
+      hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    end
+
+
+    def convert_to_transforms(outputs)
+      outputs.inject({}) do |memo, (key, value)|
+        memo[key] = lambda { |output_value| value.merge('value' => output_value) }
+        memo
+      end
+    end
+
+    def update_stack(template, params, capabilities, policy, override_policy, tags)
+      opts = {:capabilities => capabilities, :parameters => params, :tags => tags}
+      if (policy)
+        opts[:stack_policy_during_update_body] = policy if override_policy
+        log("Using temporary stack policy to apply resource stack updates") if override_policy
+        opts[:stack_policy_body] = policy unless override_policy
+        log("Applying new stack policy to existing resource stack") unless override_policy
+      end
+      @cf_driver.update_stack(@stack_name, template, opts)
+    end
+
+    def stack_exists?
+      @cf_driver.stack_exists?(@stack_name)
+    end
+
+    def create_stack(template, params, capabilities, policy, tags)
+      opts = {:disable_rollback => true, :capabilities => capabilities, :parameters => params, :tags => tags}
+      opts[:stack_policy_body] = policy if policy
+      log("Applying stack policy to new resource stack") if policy
+      @cf_driver.create_stack(@stack_name, template, opts)
+    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(anchor)
+      @poller.poll(anchor) do |event|
+        log_event(event)
+        if FAILED_STATS.include?(event.resource_status)
+          raise "Resource stack update failed!"
+        end
+
+        break if event.logical_resource_id == @stack_name && SUCCESS_STATS.include?(event.resource_status)
+      end
+    end
+
+    def log_event(event)
+      puts "[#{event.timestamp}][cloud_formation_provisioner] #{event.resource_type}(#{event.logical_resource_id}) #{event.resource_status} \"#{event.resource_status_reason}\""
+    end
+
+
+    def log(msg)
+      puts "[#{Time.now.utc}][cloud_formation_provisioner] #{msg}"
+    end
+  end
+end

data/lib/eb_deployer/component.rb

@@ -0,0 +1,45 @@
+module EbDeployer
+  class Component
+    attr_reader :name
+
+    def initialize(name, env, options, eb_driver)
+      @name = name
+      @env = env
+      @eb_driver = eb_driver
+      @options = options.dup
+      @component_eb_settings = @options.delete(:option_settings) || []
+      @component_inactive_settings = @options.delete(:inactive_settings) || []
+      strategy_name = @options[:strategy] || @env.strategy_name
+      @strategy = DeploymentStrategy.create(self, strategy_name)
+    end
+
+    def cname_prefix
+      @options[:cname_prefix] || default_cname_prefix
+    end
+
+    def deploy(version_label, eb_settings, inactive_settings=[])
+      @strategy.test_compatibility(create_options)
+      @strategy.deploy(version_label,
+                       eb_settings + @component_eb_settings,
+                       inactive_settings + @component_inactive_settings)
+    end
+
+    def new_eb_env(suffix=nil, cname_prefix_overriding=nil)
+      EbEnvironment.new(@env.app_name,
+                        [@env.name, @name, suffix].compact.join('-'),
+                        @eb_driver,
+                        create_options.merge(:cname_prefix => cname_prefix_overriding || cname_prefix))
+
+    end
+
+    private
+
+    def create_options
+      @env.creation_opts.merge(@options)
+    end
+
+    def default_cname_prefix
+      [@env.app_name, @env.name, @name].join('-')
+    end
+  end
+end

data/lib/eb_deployer/config_loader.rb

@@ -0,0 +1,64 @@
+require 'securerandom'
+require 'digest'
+require 'yaml'
+
+module EbDeployer
+  class ConfigLoader
+    include Utils
+
+    class EvalBinding
+      attr_reader :environment, :package_digest
+      def initialize(package_digest, env)
+        @package_digest = package_digest
+        @environment = env
+      end
+
+      def random_hash
+        SecureRandom.hex[0..9]
+      end
+    end
+
+    def load(options)
+      options = options.dup
+      package_digest = package_digest(options[:package])
+      config_file = options.delete(:config_file)
+
+      env = options[:environment]
+      config_settings = load_config_settings(config_file, package_digest, env)
+
+      app_name = config_settings[:application]
+
+      common_settings = symbolize_keys(config_settings[:common])
+      common_settings[:version_label] ||= package_digest
+
+      envs = config_settings[:environments]
+      raise "Environment #{env} is not defined in #{config_file}" unless envs.has_key?(env)
+      env_settings = symbolize_keys(envs[env] || {})
+      env_option_settings = env_settings.delete(:option_settings) || []
+
+      ret = options.merge(common_settings).merge(env_settings)
+      ret[:application] = app_name
+      ret[:option_settings] ||= []
+      ret[:option_settings] += env_option_settings
+      ret
+    end
+
+    private
+
+    def load_config_settings(config_file, package_digest, env)
+      yaml = ERB.new(File.read(config_file)).
+             result(eval_binding(package_digest, env))
+      symbolize_keys(YAML.load(yaml))
+    end
+
+    def eval_binding(package_digest, env)
+      EvalBinding.new(package_digest, env).instance_eval { binding }
+    end
+
+    def package_digest(package)
+      return nil unless package
+      return package unless File.exist?(package)
+      Digest::MD5.file(package).hexdigest
+    end
+  end
+end

data/lib/eb_deployer/default_component.rb

@@ -0,0 +1,32 @@
+module EbDeployer
+  class DefaultComponent
+    def initialize(env, creation_opts, strategy_name, eb_driver)
+      @env = env
+      @eb_driver = eb_driver
+      @creation_opts = creation_opts
+      @strategy = DeploymentStrategy.create(self, strategy_name)
+    end
+
+    def cname_prefix
+      @creation_opts[:cname_prefix] || default_cname_prefix
+    end
+
+    def deploy(version_label, eb_settings, inactive_settings=[])
+      @strategy.test_compatibility(@creation_opts)
+      @strategy.deploy(version_label, eb_settings, inactive_settings)
+    end
+
+    def new_eb_env(suffix=nil, cname_prefix_overriding=nil)
+      EbEnvironment.new(@env.app_name,
+                        [@env.name, suffix].compact.join('-'),
+                        @eb_driver,
+                        @creation_opts.merge(:cname_prefix => cname_prefix_overriding || cname_prefix))
+    end
+
+    private
+
+    def default_cname_prefix
+      [@env.app_name, @env.name].join('-')
+    end
+  end
+end

data/lib/eb_deployer/default_config.rb

@@ -0,0 +1,20 @@
+module EbDeployer
+  class DefaultConfig
+    attr_reader :app_name
+
+    def initialize(app_name)
+      @app_name = app_name.gsub('_', '-')
+    end
+
+    def write_to(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w') { |f| f << ERB.new(File.read(config_template)).result(binding) }
+    end
+
+    private
+
+    def config_template
+      File.expand_path("../default_config.yml", __FILE__)
+    end
+  end
+end