eb_deployer 0.1.1 → 0.2.0

data/README.md

@@ -6,16 +6,6 @@ ElasticBeanstalk Deployer thus allows you to do continuous delivery on AWS.
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
-    gem 'eb_deployer'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
     $ gem install eb_deployer
 
 ## Usage
@@ -26,57 +16,50 @@ Create an AWS IAM user for deploy and give it privilege to operate Elastic Beans
 
 ### Step Two: Packaging
 
-You need package your application for Elastic Beanstalk stack first. For Java app an warball is appropriate. For Ruby on Rails app a tar.gz file is good. You can also package a Rails/Sinatra app as war ball using warbler and deploy to Java stack.
+You need package your application for Elastic Beanstalk stack first. For Java app an warball is appropriate. For Ruby on Rails app a tar.gz file is good. You can also package a Rails/Sinatra app as war ball using warbler and deploy to Java stack. (Please remember do rake assets:precompile first for rails app)
+
 
+### Step Three: Generate configuration and Configure deployment process
 
-### Step Three: Define the task
-Add a deploy task for deployment in your Rakefile
+    $ eb_deploy
 
-    require 'digest'
+This will generate a default configuration at location 'config/eb_deployer.yml'. It is almost empty but working one. And it will generate settings for two environment 'dev' and 'production'. If you had time please try to read through it to see the options you can tweak.
 
-    desc "deploy our beloved app to elastic beanstalk"
-    task :deploy, [:package] do |t, args|
-      EbDeployer.deploy(:application => "MYAPP",
-                        :environment => "production",
-                        :solution_stack_name => <SOLUTION_STACK_NAME>
-                        :package => args[:package],
-                        :version_label => "dev-" + Digest::MD5.file(args[:package]).hexdigest)
-    end
 
 ### Step Four: Fasten your seat belt
-run deploy task:
+run deploy
+
+    $ eb_deploy -p <package built> -e <environment>
 
-    rake deploy[<package built>] AWS_ACCESS_KEY_ID=<deployers_aws_key> AWS_SECRET_ACCESS_KEY=<secret>
 Then open aws console for Elastic Beanstalk to see what happened.
 
 
 ### Smoke Testing your stack
 
-EB_Deployer allows you to automate your deployment and then some. You can also add smoke tests to your deployment - thus ensuring that the app you deployed is also working correctly. 
-Adding a smoke test suite is also simple. All that you need to do is edit your rake task as follows:
-
-    desc "deploy our simple java app with one page"
-    task :deploy, [:package] do |t, args|
-      EbDeployer.deploy(:application => "MYAPP",
-                        :environment => "production",
-                        :solution_stack_name => <SOLUTION_STACK_NAME>
-                        :package => args[:package],
-                        :version_label => "dev-" + Digest::MD5.file(args[:package]).hexdigest)
-                        :smoke_test => lambda { |host|
-                          Timeout.timeout(600) do
-                            until `curl http://#{host}`.include?('Hello, World')
-                              sleep 5
-                            end
-                          end
-                        })
-    end                
-You can add more smoke tests by calling arbitrary tasks from this rake task.
+EB_Deployer allows you to automate your deployment and then some. You can also add smoke tests to your deployment - thus ensuring that the app you deployed is also working correctly.
+Adding a smoke test suite is also simple. Check "smoke_test" section in your eb_deployer.yml. The simplest thing you can do is using curl make sure landing page get loaded, e.g.:
+
+    smoke_test: >
+      curl_http_code = "curl -s -o /dev/null -w \"%{http_code}\" http://#{host_name}"
+      Timeout.timeout(600) do
+        while `#{curl_http_code}`.strip != '200'
+          sleep 5
+        end
+      end
+
+
+You can add more smoke tests by calling arbitrary rake tasks (Please make sure check return status):
+   
+    smoke_test: >
+      `rake test:smoke HOST_NAME=#{host_name}`
+      raise("Smoke failed!") unless $?.success?
+
 Smoke testing gets you one step closer to continuous delivery.
-                      
+
 ### Blue-Green deployment
-Since every deployment now runs smoke test, you now have a better safety net around your deployments. This allows us to trigger automatic blue-green deployments. 
+Since every deployment now runs smoke test, you now have a better safety net around your deployments. This allows us to trigger automatic blue-green deployments.
 
-To do this you need not do anything special. So far we have deployed the application only once. Let's call this the 'green' stack. Any subsequent calls to deployment will deployment a copy of this application to a new stack - the 'blue' stack. Smoke tests will be run on it and once everything passes the 'blue'(new) stack will be switched to the 'green' stack. Thus your new code will now be on the active stack and the user will experience no downtime. 
+To do this you need not do anything special. So far we have deployed the application only once. Let's call this the 'green' stack. Any subsequent calls to deployment will deployment a copy of this application to a new stack - the 'blue' stack. Smoke tests will be run on it and once everything passes the 'blue'(new) stack will be switched to the 'green' stack. Thus your new code will now be on the active stack and the user will experience no downtime.
 
 Once this new stack is stable or has run for a while you can choose to delete the old stack. Or if you are doing continuous delivery you may be ready to another 'blue' deployment. You could just trigger another deployment and repeat this every hour/day/week... you get the idea.
 
@@ -84,12 +67,9 @@ Once this new stack is stable or has run for a while you can choose to delete th
 
 ### Destroying a stack
 So you are done with this application or environment, you can destroy it easily as well.
+   
+    $ eb_deployer -d -e <environment>
 
-    desc "clean up everything"
-    task :teardown do |t, args|
-      EbDeployer.destroy(:application => "ebtest-simple")
-    end
-    
 and you are done!
 
 Later tutorials coming soon will cover

data/bin/eb_deploy

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+git_path = File.join(File.expand_path('../..', __FILE__), '.git')
+
+if File.exists?(git_path)
+  lib_path = File.expand_path('../../lib', __FILE__)
+  $:.unshift(lib_path)
+end
+
+require 'eb_deployer'
+EbDeployer.cli

data/lib/eb_deployer/cloud_formation_driver.rb

@@ -26,7 +26,8 @@ module EbDeployer
     end
 
     def query_output(name, key)
-      stack(name).outputs.find { |o| o.key == key }.try(:value)
+      output = stack(name).outputs.find { |o| o.key == key }
+      output && output.value
     end
 
     private

data/lib/eb_deployer/cloud_formation_provisioner.rb

@@ -12,14 +12,17 @@ module EbDeployer
     end
 
     def provision(resources)
+      resources = symbolize_keys(resources)
       template = File.read(resources[:template])
-      transforms = resources[:transforms]
+      outputs = resources[:outputs] || {}
+      transforms = resources[:transforms] || {}
       capabilities = resources[:capabilities] || []
-      params = resources[:parameters] || {}
+      params = resources[:inputs] || resources[:parameters] || {}
 
       stack_exists? ? update_stack(template, params, capabilities) : create_stack(template, params, capabilities)
       wait_for_stack_op_terminate
-      transform_output_to_settings(transforms)
+
+      transform_output_to_settings(convert_to_transforms(outputs).merge(transforms))
     end
 
     def output(key)
@@ -30,6 +33,19 @@ module EbDeployer
 
     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)
       @cf_driver.update_stack(@stack_name, template,
                               :capabilities => capabilities,

data/lib/eb_deployer/config_loader.rb

@@ -0,0 +1,62 @@
+require 'securerandom'
+require 'digest'
+
+module EbDeployer
+  class ConfigLoader
+
+    class EvalBinding
+      def initialize(package_digest)
+        @package_digest = package_digest
+      end
+
+      def random_hash
+        SecureRandom.hex[0..9]
+      end
+
+      def package_digest
+        @package_digest
+      end
+    end
+
+    def load(options)
+      options = options.dup
+      package_digest = package_digest(options[:package])
+      config_file = options.delete(:config_file)
+      config_settings = load_config_settings(config_file, package_digest)
+
+      common_settings = symbolize_keys(config_settings.delete(:common))
+      common_settings[:version_label] ||= package_digest
+
+      env = options[:environment]
+      envs = config_settings.delete(:environments)
+      raise 'Environment #{evn} 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(config_settings).merge(common_settings).merge(env_settings)
+
+      ret[:option_settings] ||= []
+      ret[:option_settings] += env_option_settings
+      ret
+    end
+
+    private
+
+    def symbolize_keys(hash)
+      hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    end
+
+    def load_config_settings(config_file, package_digest)
+      yaml = ERB.new(File.read(config_file)).result(eval_binding(package_digest))
+      symbolize_keys(YAML.load(yaml))
+    end
+
+    def eval_binding(package_digest)
+      EvalBinding.new(package_digest).instance_eval { binding }
+    end
+
+    def package_digest(package)
+      Digest::MD5.file(package).hexdigest
+    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
+    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

data/lib/eb_deployer/default_config.yml

@@ -0,0 +1,109 @@
+# applicaiton name
+application: <%= app_name %>
+
+# common settings for all environments
+common:
+  # Solution stack for elastic beanstalk, default is 64bit tomcat 7 for JAVA app
+  # solution_stack_name: 64bit Amazon Linux running Tomcat 7
+
+  # AWS region to deploy. Default to us-east-1
+  # region: us-west-1
+
+  # There are two deployment strategies: blue-green or inplace-update.
+  # Blue green keep two elastic beanstalk environments and always deploy to
+  # inactive one, to achive zero downtime. inplace-update strategy
+  # will only keep one environment, and update the version inplace on
+  # deploy. inplace-update will save resources but will have downtime. Default
+  # strategy is blue-green. PS. All old environments need be destroyed when you
+  # switching between strategies.
+  # strategy: blue-green
+
+  # If phoenix mode is turn on, it will terminate the old elastic
+  # beanstalk environment and recreate on deploy. For blue-green
+  # deployment it terminate the inactive environment first then
+  # recreate it. This is useful to avoiding configuration drift and
+  # accumulating state on the ec2 instances. Also it has the benifit of
+  # keeping your ec2 instance system package upto date, because everytime ec2
+  # instance boot up from AMI it does a system update. Default is off but we suggest
+  # overriden it to on for production environment.
+  # phoenix_mode: false
+
+  # Generating version label for package be deployed. A readable version label will
+  # provide better traceablity of your deployment process.
+  # By default setting is:
+  # version_label: <%%= package_digest %>
+  # which means using MD5 digest of the package file. If you deploy using build
+  # pipeline tool such as GO, switching to pipline counter is highly suggested to
+  # increase the readability. Following example read pipeline counter from environment
+  # variable with a fall back to digest for local deployment:
+  # version_label: <%%= ENV['GO_PIPELINE_COUNTER'] || package_digest %>
+
+
+  # Smoke test value should be a piece of ruby code with access to single variable
+  # "host_name" -- environment DNS name. Smoke test snippet will be evaluated at
+  # the end of the deployment for inplace-update deployment. For blue-green
+  # deployment it will run after inactive environment update finish and before
+  # switching.
+  # Defining a smoke test is high recommended for serious usage. The
+  # simplest one could just be checking server landing page using curl, e.g.
+  # smoke_test: >
+  #   curl_http_code = "curl -s -o /dev/null -w \"%{http_code}\" http://#{host_name}"
+  #   Timeout.timeout(600) do
+  #     while `#{curl_http_code}`.strip != '200'
+  #       sleep 5
+  #     end
+  #   end
+
+
+  # Elastic Beanstalk settings that will apply to the environments you
+  # deploying.
+  # For all available options take a look at
+  # http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/command-options.html
+  option_settings:
+    # Following is an option_settings example which changes EC2 instance type
+    # from t1.micro (default) to m1.small. Intances with t1.micro type sometime
+    # are not very responsible, so m1.small is suggested for saving time.
+    # But if you care about the marginal cost difference you can comment this out to
+    # go back to t1.micro.
+    - namespace: aws:autoscaling:launchconfiguration
+      option_name: InstanceType
+      value: m1.small
+
+  # If resources specified, eb_deployer will use the CloudFormation
+  # template you provide to create a default CloudFormation stack with
+  # name <application_name>-<env-name> for the environment current
+  # deploying. And Outputs of the CloudFormation can be mapped to Elastic Beanstalk
+  # options settings.
+  # keys:
+  #    template => CloudFormation template file with JSON format
+  #    inputs => A Hash, input values for the CloudFormation template
+  #    outputs => A Hash with key map to your CloudFormation
+  # template outputs and value as elastic beanstalk settings namespace and option_name.
+  #    :capabilities => An array. You need set it to ['CAPABILITY_IAM'] if the
+  # template include IAM Instance Profile.
+  resources:
+    # For example creating a RDS instance for blue green deployment:
+    # template: config/my_rds.json
+    # inputs:
+    #   DBPassword: <%%= random_hash %>
+    # outputs:
+    #   RDSPassSecurityGroup:
+    #     namespace: aws:autoscaling:launchconfiguration
+    #     option_name: SecurityGroups
+    #   RDSDatabaseConfig:
+    #     namespace: aws:elasticbeanstalk:application:environment
+    #     option_name: databaseConfig
+
+
+# You can define environment here. Each environment can overriden any common settings
+environments:
+  dev:
+    # example for overriding common settings
+    # strategy: inplace-update
+  production:
+    option_settings:
+      # example for overriding common option_settings: providing least redanduncy
+      # in production environment.
+      # - namespace: aws:autoscaling:asg
+      #   option_name: MinSize
+      #    value: "2"

data/lib/eb_deployer/environment.rb

@@ -34,6 +34,10 @@ module EbDeployer
       @bs.environment_swap_cname(self.app, self.name, another.name)
     end
 
+    def log(msg)
+      puts "[#{Time.now.utc}][beanstalk:#{@name}] #{msg}"
+    end
+
     private
 
     def shorten(str, max_length, digest_length=5)
@@ -64,12 +68,8 @@ module EbDeployer
     end
 
     def smoke_test
-      if smoke = @creation_opts[:smoke_test]
-        host = @bs.environment_cname(@app, @name)
-        log("running smoke test for #{host}...")
-        smoke.call(host)
-        log("smoke test succeeded.")
-      end
+      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)
@@ -97,12 +97,9 @@ module EbDeployer
       end
     end
 
-    def log(msg)
-      puts "[#{Time.now.utc}][beanstalk-#{@name}] #{msg}"
-    end
 
     def log_event(event)
-      puts "[#{event[:event_date]}][beanstalk-#{@name}] #{event[:message]}"
+      puts "[#{event[:event_date]}][beanstalk:#{@name}] #{event[:message]}"
     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/version.rb

@@ -1,3 +1,3 @@
 module EbDeployer
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/eb_deployer.rb

@@ -8,12 +8,17 @@ 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 'digest'
 require 'set'
 require 'time'
 require 'json'
 require 'timeout'
 require 'aws-sdk'
+require 'optparse'
+require 'erb'
 
 module EbDeployer
 
@@ -39,6 +44,8 @@ module EbDeployer
   end
 
 
+  # #
+  # Deploy a package to specfied environments on elastic beanstalk
   #
   # Options available:
   #
@@ -70,7 +77,7 @@ module EbDeployer
   # The elastic beanstalk solution stack you want to deploy on top of.
   # Current possible values include:
   #
-  # :settings  (optional)
+  # :option_settings (or :settings)  (optional)
   # Elastic Beanstalk settings that will apply to the environments you
   # deploying. Value should be array of hash with format such as:
   #     [{
@@ -90,7 +97,7 @@ module EbDeployer
   # deploying.  Value of resources need to be hash with following
   # keys:
   #    :template => CloudFormation template file with JSON format
-  #    :parameters => A Hash, input values for the CloudFormation
+  #    :parameters (or :inputs) => A Hash, input values for the CloudFormation
   # template
   #    :transforms => A Hash with key map to your CloudFormation
   # template outputs and value as lambda that return a single or array of
@@ -133,7 +140,6 @@ module EbDeployer
   #  }
   #
   #
-  # deploy a package to specfied environments on elastic beanstalk
   #
 
   def self.deploy(opts)
@@ -150,7 +156,7 @@ module EbDeployer
     env_name = opts[:environment]
     version_label = opts[:version_label].to_s.strip
     cname = opts[:cname]
-    env_settings = opts[:settings] || []
+    env_settings = opts[:option_settings] || opts[:settings] || []
     strategy_name = opts[:strategy] || :blue_green
     cname_prefix = opts[:cname_prefix] || [app, env_name].join('-')
     smoke_test = opts[:smoke_test] || Proc.new {}
@@ -186,4 +192,61 @@ module EbDeployer
     Application.new(app, bs, s3).delete
   end
 
+  def self.cli
+    options = {
+      :action => :deploy,
+      :environment => 'dev',
+      :config_file => 'config/eb_deployer.yml'
+    }
+
+    parser = cli_parser(options)
+    parser.parse!
+    action = options.delete(:action)
+
+    unless File.exists?(options[:config_file])
+      puts "Generat default configuration one at location #{options[:config_file]}."
+      DefaultConfig.new(File.basename(Dir.pwd)).write_to(options[:config_file])
+      exit(2)
+    end
+
+    if !options[:package] && action == :deploy
+      puts "Missing options: -p (--package)"
+      puts parser
+      exit(-1)
+    end
+
+
+    self.send(action, ConfigLoader.new.load(options))
+  end
+
+  private
+
+  def self.cli_parser(options)
+    OptionParser.new do |opts|
+      opts.banner = "Usage: eb_deployer [options]"
+      opts.on("-p", "--package [FILE]", "Package to deploy, for example a war file for java application") do |v|
+        options[:package] = v
+      end
+
+      opts.on("-e", "--environment [ENV_NAME]", "(Default to 'dev') Environment to operating on, for example dev, staging or production. This must be defined in 'environments' section of the config file") do |v|
+        options[:environment] = v
+      end
+
+      opts.on("-c", "--config-file [FILE]", "eb_deployer config file. Default location is config/eb_deployer.yml") do |v|
+        options[:config_file] = v
+      end
+
+      opts.on("-d", "--destroy", "Destroy specified environment") do |v|
+        action = :destroy
+      end
+
+      opts.on("-v", "--version", "Print current version") do |v|
+        puts "eb_deployer v#{VERSION}"
+        exit(0)
+      end
+
+    end
+  end
+
+
 end

data/test/cloud_formation_provisioner_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class CloudFormationProvisionerTest < Minitest::Test
+  def setup
+    @cf = CFStub.new
+    @provisioner = EbDeployer::CloudFormationProvisioner.new("myresources", @cf)
+    @template = sample_file("sample_template.json")
+  end
+
+
+  def test_convert_inputs_as_params_to_cf
+    @provisioner.provision(:template => @template,
+                           :inputs => { 'Foo' => 'Bar' })
+
+    assert_equal({ 'Foo' => 'Bar' }, @cf.stack_config("myresources")[:parameters])
+  end
+
+  def test_transform_to_eb_settings
+    settings = @provisioner.provision(:template => @template,
+                                      :outputs => {
+                                        'S' => {
+                                          'namespace' => "foo",
+                                          "option_name" => "bar"
+                                        }
+                                      })
+    assert_equal [{'namespace' => 'foo', 'option_name' => 'bar', 'value' => 'value of S'}], settings
+  end
+end

data/test/config_loader_test.rb

@@ -0,0 +1,124 @@
+require 'test_helper'
+
+class ConfigLoaderTest < Minitest::Test
+  def setup
+    @loader = EbDeployer::ConfigLoader.new
+    @sample_package = sample_file('app-package.war')
+  end
+
+  def test_all_default_cases
+    config = @loader.load(generate_input(<<-YAML))
+application: myapp
+common:
+  option_settings:
+  resources:
+environments:
+  dev:
+  production:
+YAML
+    assert_equal('myapp', config[:application])
+    assert_equal(@sample_package, config[:package])
+    assert_equal('dev', config[:environment])
+    assert_equal(md5_digest(@sample_package), config[:version_label])
+    assert_equal([], config[:option_settings])
+    assert_equal(nil, config[:resources])
+    assert_equal(nil, config[:common])
+  end
+
+  def test_common_settings_get_merge_into_the_config
+    config = @loader.load(generate_input(<<-YAML))
+application: myapp
+common:
+  strategy: inplace-update
+  phoenix_mode: true
+  option_settings:
+    - namespace: aws:autoscaling:launchconfiguration
+      option_name: InstanceType
+      value: m1.small
+  resources:
+environments:
+  dev:
+  production:
+YAML
+    assert_equal('inplace-update', config[:strategy])
+    assert_equal([{'namespace' => 'aws:autoscaling:launchconfiguration',
+                    'option_name' => 'InstanceType',
+                    'value' => 'm1.small'}], config[:option_settings])
+  end
+
+  def test_eval_random_hash
+    yaml = <<-YAML
+application: myapp
+common:
+  resources:
+    template: config/my_rds.json
+    inputs:
+      DBPassword: <%= random_hash %>
+environments:
+  dev:
+  production:
+YAML
+    first_time = @loader.load(generate_input(yaml))[:resources]['inputs']['DBPassword']
+    second_time = @loader.load(generate_input(yaml))[:resources]['inputs']['DBPassword']
+    assert first_time &&  second_time
+    assert first_time != second_time
+  end
+
+  def test_environment_specific_setting_will_override_common_settings
+    yaml = <<-YAML
+application: myapp
+common:
+  phoenix_mode: true
+environments:
+  dev:
+    phoenix_mode: false
+  production:
+YAML
+
+    assert !@loader.load(generate_input(yaml, :environment => 'dev'))[:phoenix_mode]
+    assert  @loader.load(generate_input(yaml, :environment => 'production'))[:phoenix_mode]
+  end
+
+  def test_env_specific_option_settings_will_merge_with_commons
+    config = @loader.load(generate_input(<<-YAML, :environment => 'production'))
+application: myapp
+common:
+  strategy: inplace-update
+  phoenix_mode: true
+  option_settings:
+    - namespace: aws:autoscaling:launchconfiguration
+      option_name: InstanceType
+      value: m1.small
+  resources:
+environments:
+  dev:
+  production:
+    option_settings:
+      - namespace: aws:autoscaling:asg
+        option_name: MinSize
+        value: "2"
+YAML
+    assert_equal([{'namespace' => 'aws:autoscaling:launchconfiguration',
+                    'option_name' => 'InstanceType',
+                    'value' => 'm1.small'},
+                  {'namespace' => 'aws:autoscaling:asg',
+                    'option_name' => 'MinSize',
+                    'value' => "2"}], config[:option_settings])
+  end
+
+  private
+
+  def md5_digest(file)
+    Digest::MD5.file(file).hexdigest
+  end
+
+  def generate_input(config_file_content, overriding={})
+    { :environment => 'dev',
+      :package => @sample_package,
+      :config_file => generate_config(config_file_content)}.merge(overriding)
+  end
+
+  def generate_config(content)
+    sample_file('eb_deployer.yml', content)
+  end
+end

data/test/deploy_test.rb

@@ -1,16 +1,11 @@
-$:.unshift(File.expand_path("../../lib", __FILE__))
-require 'tempfile'
-require 'eb_deployer'
-require 'aws_driver_stubs'
-require 'minitest/autorun'
+require 'test_helper'
 
 class DeployTest < Minitest::Test
   def setup
     @eb_driver = EBStub.new
     @s3_driver = S3Stub.new
     @cf_driver = CFStub.new
-    @sample_package = '/tmp/app-package.war'
-    File.open(@sample_package, 'w') { |f| f << 's' * 100 }
+    @sample_package = sample_file('app-package.war')
   end
 
   def test_first_deplyment_create_eb_application
@@ -19,6 +14,17 @@ class DeployTest < Minitest::Test
     assert @eb_driver.application_exists?('simple')
   end
 
+  def test_set_option_settings_on_deployment
+    redudant = [{:namespace => 'aws:autoscaling:launchconfiguration',
+                                  :option_name => 'MinSize',
+                                  :value => '2' }]
+    deploy(:application => 'simple', :environment => "production",
+           :option_settings => [redudant])
+
+    assert_equal [redudant], @eb_driver.environment_settings('simple', eb_envname('simple', 'production'))
+
+  end
+
   def test_destroy_should_clean_up_eb_application_and_env
     deploy(:application => 'simple', :environment => "production")
     destroy(:application => 'simple')
@@ -304,7 +310,4 @@ class DeployTest < Minitest::Test
       :cf_driver => @cf_driver
     }
   end
-
-
-
 end

data/test/smoke_test_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class SmokeTestTest < MiniTest::Test
+  def test_call_proc_type_smoke_tests
+    host_name_in_proc = nil
+    EbDeployer::SmokeTest.new(lambda {|v| host_name_in_proc = v }).run("foo")
+
+    assert_equal 'foo', host_name_in_proc
+  end
+
+  def test_eval_string_type_smoke_test
+    $host_name_in_proc = nil
+    EbDeployer::SmokeTest.new("$host_name_in_proc=host_name").run("foo")
+    assert_equal 'foo', $host_name_in_proc
+  end
+
+  def test_should_raise_if_test_body_raise
+    assert_raises(RuntimeError) do
+      EbDeployer::SmokeTest.new("raise host_name").run("foo")
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
+require 'tempfile'
+require 'eb_deployer'
+require 'aws_driver_stubs'
+require 'minitest/autorun'
+require 'minitest/pride'
+
+
+class Minitest::Test
+  def sample_file(file_name, content='s' * 100)
+    path = File.join('/tmp', file_name)
+    File.open(path, 'w') { |f| f << content }
+    path
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eb_deployer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-06 00:00:00.000000000 Z
+date: 2013-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -48,7 +48,8 @@ description: For automate blue green deployment flow on Elasti Beanstalk.
 email:
 - alex.hal9000@gmail.com
 - sudhindra.r.rao@gmail.com
-executables: []
+executables:
+- eb_deploy
 extensions: []
 extra_rdoc_files: []
 files:
@@ -57,20 +58,29 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/eb_deploy
 - 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/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/environment.rb
 - lib/eb_deployer/event_poller.rb
 - lib/eb_deployer/package.rb
 - lib/eb_deployer/s3_driver.rb
+- lib/eb_deployer/smoke_test.rb
 - lib/eb_deployer/version.rb
 - test/aws_driver_stubs.rb
+- test/cloud_formation_provisioner_test.rb
+- test/config_loader_test.rb
 - test/deploy_test.rb
+- test/smoke_test_test.rb
+- test/test_helper.rb
 homepage: https://github.com/ThoughtWorksStudios/eb_deployer
 licenses: []
 post_install_message: 
@@ -91,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Low friction deployments should be a breeze. Elastic Beanstalk provides a
@@ -99,5 +109,8 @@ summary: Low friction deployments should be a breeze. Elastic Beanstalk provides
   top to automate the whole flow out of box.
 test_files:
 - test/aws_driver_stubs.rb
+- test/cloud_formation_provisioner_test.rb
+- test/config_loader_test.rb
 - test/deploy_test.rb
-has_rdoc: 
+- test/smoke_test_test.rb
+- test/test_helper.rb