elastic-beanstalk 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+.idea

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.3@elastic_beanstalk --create

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 AlienFast, LLC
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,153 @@
+# ElasticBeanstalk
+
+Configure and deploy a rails app to Elastic Beanstalk via rake in 60 seconds.  Maintain multiple environment DRY configurations and .ebextensions in one easy to use configuration file.
+
+This gem simplifies configuration, and passes the heavy lifting to the [eb_deployer](https://github.com/ThoughtWorksStudios/eb_deployer) from ThoughtWorksStudios.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'elastic-beanstalk'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install elastic-beanstalk
+
+## Usage
+
+Given an application named 'acme':
+
+### Step 1: Add a ~/.aws.acme.yml
+This should contain the access and secret keys generated from the selected IAM user.  This is the only file that will need to reside outside the repository.
+
+    access_key_id: XXXXXX
+    secret_access_key: XXXXXX
+
+### Step 2.  Add a config/eb.yml to your rails project
+Something like this should get you started
+
+    app: acme
+    region: us-east-1
+    solution_stack_name: 64bit Amazon Linux running Ruby 1.9.3
+
+    development:
+      strategy: inplace_update
+      options:
+        aws:autoscaling:launchconfiguration:
+          InstanceType: t1.micro
+
+    production:
+      options:
+        aws:autoscaling:launchconfiguration:
+          InstanceType: t1.small
+
+### Step 3. Package and deploy
+The default is the 'development' environment, change this via command line by prefixing with i.e. RAILS_ENV=production
+
+    $ rake eb:package eb:deploy
+
+### Step 4. Get some coffee
+This will take a while.  We intend to provide an example in the wiki and/or samples dir that implements a [caching strategy detailed here](http://horewi.cz/faster-rails-3-deployments-to-aws-elastic-beanstalk.html) to speed up deployment.
+
+## Rake Tasks
+
+    eb:config       # Setup AWS.config and merge/override environments into one resolved configuration.
+    eb:show_config  # Show resolved configuration without doing anything. arguments[:version]
+    eb:clobber      # Remove any generated package.
+    eb:package      # Package zip source bundle for Elastic Beanstalk.
+    eb:deploy       # Deploy to Elastic Beanstalk. arguments[:version]
+    eb:destroy      # ** Warning: Destroy Elastic Beanstalk application and *all* environments. arguments[:force]
+
+## A real-world example
+
+Deploy version 1.1.3 of acme to production
+
+    $ RAILS_ENV=production rake eb:package eb:deploy[1.1.3]
+
+config/eb.yml
+
+    # This is a sample that has not been executed so it may not be exactly 100%, but is intended to show
+    #   that access to full options_settings and .ebextensions is intended.
+    #---
+    app: acme
+    region: us-east-1
+    solution_stack_name: 64bit Amazon Linux running Ruby 1.9.3
+    package:
+      verbose: true
+      exclude_dirs: [solr, features] # additional dirs that merge with default excludes
+      exclude_files: [rspec.xml, README*, db/*.sqlite3]
+    smoke_test: |
+        lambda { |host|
+
+          require 'eb_smoke_tester'
+
+          EbSmokeTester.test_url("http://#{host}/ping", 600, 5, 'All good! Everything is up and checks out.')
+        }
+    #--
+    ebextensions:
+      01settings.config:
+        # Run rake tasks before an application deployment
+        container_commands:
+          01seed:
+            command: rake db:seed
+            leader_only: true
+      # run any necessary commands
+      02commands.config:
+        container_commands:
+          01timezone:
+            command: "ln -sf /usr/share/zoneinfo/America/Chicago /etc/localtime"
+    #---
+    options:
+      aws:autoscaling:launchconfiguration:
+        EC2KeyName: eb-ssh
+        SecurityGroups: 'acme-production-control'
+
+      aws:autoscaling:asg:
+        MinSize: 1
+        MaxSize: 5
+
+      aws:elb:loadbalancer:
+        SSLCertificateId: 'arn:aws:iam::XXXXXXX:server-certificate/acme'
+        LoadBalancerHTTPSPort: 443
+
+      aws:elb:policies:
+        Stickiness Policy: true
+
+      aws:elasticbeanstalk:sns:topics:
+        Notification Endpoint: 'alerts@acme.com'
+
+      aws:elasticbeanstalk:application:
+        Application Healthcheck URL: '/'
+    #---
+    development:
+      strategy: inplace_update
+      options:
+        aws:autoscaling:launchconfiguration:
+          InstanceType: t1.micro
+        aws:elasticbeanstalk:application:environment:
+          RAILS_SKIP_ASSET_COMPILATION: true
+    #---
+    production:
+      options:
+        aws:autoscaling:launchconfiguration:
+          InstanceType: t1.small
+
+## Still to come
+1. RDS sample config
+2. Caching sample config
+3. More thorough access to the Elastic Beanstalk api as-needed.
+
+## Contributing
+
+Please contribute! While this is working great, a greater scope of functionality is certainly easily attainable with this foundation in place.
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+
+# add rspec task
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+task :default => :spec
+task :test => :spec
+

data/elastic-beanstalk.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elastic_beanstalk/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'elastic-beanstalk'
+  spec.version = ElasticBeanstalk::VERSION
+  spec.authors = ['Kevin Ross']
+  spec.email = ['kevin.ross@alienfast.com']
+  spec.description = %q{The simplest way to configure and deploy an Elastic Beanstalk application via rake.}
+  spec.summary = %q{Configure and deploy a rails app to Elastic Beanstalk via rake in 60 seconds.  Maintain multiple environment DRY configurations and .ebextensions in one easy to use configuration file.}
+  spec.homepage = 'https://github.com/alienfast/elastic-beanstalk'
+  spec.license = 'MIT'
+
+  spec.files = `git ls-files`.split($/).reject { |f| f =~ /^samples\// }
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(lib)
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '>= 2.14.1'
+
+  # spec.add_runtime_dependency
+  spec.add_development_dependency 'rails' #, '>=3.2.13'
+  spec.add_development_dependency 'eb_deployer'
+  spec.add_development_dependency 'awesome_print'
+  spec.add_development_dependency 'time_diff'
+  spec.add_development_dependency 'zipruby'
+  spec.add_development_dependency 'safe_yaml', '0.9.3'
+
+end

data/lib/deep_symbolize.rb

@@ -0,0 +1,74 @@
+# Slightly modified from https://gist.github.com/morhekil/998709
+
+# Symbolizes all of hash's keys and subkeys.
+# Also allows for custom pre-processing of keys (e.g. downcasing, etc)
+# if the block is given:
+#
+# somehash.deep_symbolize { |key| key.downcase }
+#
+# Usage: either include it into global Hash class to make it available to
+#        to all hashes, or extend only your own hash objects with this
+#        module.
+#        E.g.:
+#        1) class Hash; include DeepSymbolizable; end
+#        2) myhash.extend DeepSymbolizable
+module DeepSymbolizable
+  def deep_symbolize(invert = false, &block)
+    method = self.class.to_s.downcase.to_sym
+    symbolizers = DeepSymbolizable::Symbolizers
+    symbolizers.respond_to?(method) ? symbolizers.send(method, self, invert, &block) : self
+  end
+
+  module Symbolizers
+    extend self
+
+    # the primary method - symbolizes keys of the given hash,
+    # preprocessing them with a block if one was given, and recursively
+    # going into all nested enumerables
+    def hash(hash, invert, &block)
+      hash.inject({}) do |result, (key, value)|
+        # Recursively deep-symbolize subhashes
+        value = _recurse_(value, invert, &block)
+
+        # Pre-process the key with a block if it was given
+        key = yield key if block_given?
+
+        if invert
+          # UN-Symbolize the key
+          s_key = key.to_s rescue key
+
+          # write it back into the result and return the updated hash
+          result[s_key] = value
+
+        else
+          # Symbolize the key string if it responds to to_sym
+          sym_key = key.to_sym rescue key
+
+          # write it back into the result and return the updated hash
+          result[sym_key] = value
+        end
+        result
+      end
+    end
+
+    # walking over arrays and symbolizing all nested elements
+    def array(ary, invert, &block)
+      ary.map { |v| _recurse_(v, invert, &block) }
+    end
+
+    # handling recursion - any Enumerable elements (except String)
+    # is being extended with the module, and then symbolized
+    def _recurse_(value, invert, &block)
+      if value.is_a?(Enumerable) && !value.is_a?(String)
+        # support for a use case without extended core Hash
+        value.extend DeepSymbolizable unless value.class.include?(DeepSymbolizable)
+        value = value.deep_symbolize(invert, &block)
+      end
+      value
+    end
+  end
+
+end
+
+# include in all Hash objects
+class Hash; include DeepSymbolizable; end

data/lib/elastic_beanstalk.rb

@@ -0,0 +1,13 @@
+
+module ElasticBeanstalk
+  require 'deep_symbolize'
+  require 'elastic_beanstalk/eb_config'
+  require 'elastic_beanstalk/eb_extensions'
+  require 'elastic_beanstalk/eb_smoke_tester'
+  require 'elastic_beanstalk/railtie' if defined?(Rails)
+  require 'elastic_beanstalk/version'
+end
+
+EbConfig = ElasticBeanstalk::EbConfig
+EbExtensions = ElasticBeanstalk::EbExtensions
+EbSmokeTester = ElasticBeanstalk::EbSmokeTester

data/lib/elastic_beanstalk/eb_config.rb

@@ -0,0 +1,203 @@
+require 'deep_symbolize'
+require 'yaml'
+
+module ElasticBeanstalk
+#
+# EbConfig allows for default settings and mounting a specific environment with overriding
+#   hash values and merging of array values.
+#
+#   NOTE: Anything can be overridden and merged into top-level settings (hashes) including
+#   anything that is an array value.  Array values are merged *not* replaced.  If you think
+#   something is screwy, see the defaults in the #init as those add some default array values.
+#   If this behavior of merging arrays or the defaults are somehow un-sensible, file an issue and we'll revisit it.
+#
+  module EbConfig
+    # it's a singleton, thus implemented as a self-extended module
+    extend self
+
+    def init
+
+      # seed the sensible defaults here
+      @configuration = {
+          environment: nil,
+          disallow_environments: %w(cucumber test),
+          strategy: :blue_green,
+          package: {
+              dir: 'pkg',
+              verbose: false,
+              includes: %w(**/* .ebextensions/**/*),
+              exclude_files: [],
+              exclude_dirs: %w(pkg tmp log test-reports)
+          },
+          options: {}
+      }
+    end
+
+    init()
+    attr_reader :configuration
+
+    # This is the main point of entry - we call Settings.load! and provide
+    # a name of the file to read as it's argument. We can also pass in some
+    # options, but at the moment it's being used to allow per-environment
+    # overrides in Rails
+    def load!(environment = nil, filename = resolve_path('config/eb.yml'))
+
+      # merge all top level settings with the defaults set in the #init
+      #@configuration.deep_merge!( YAML::load_file(filename).deep_symbolize )
+      deep_merge!(@configuration, YAML::load_file(filename).deep_symbolize)
+
+      # add the environment to the top level settings
+      @configuration[:environment] = (environment.nil? ? nil : environment.to_s)
+
+      # overlay the specific environment if provided
+      if environment && @configuration[environment.to_sym]
+
+        # this is environment specific, so prune any environment
+        # based settings from the initial set so that they can be overlaid.
+        [:development, :test, :staging, :production].each do |env|
+          @configuration.delete(env)
+        end
+
+        # re-read the file
+        environment_settings = YAML::load_file(filename).deep_symbolize
+
+        # snag the requested environment
+        environment_settings = environment_settings[environment.to_sym]
+
+        # finally overlay what was provided
+        #@configuration.deep_merge!(environment_settings)
+        deep_merge!(@configuration, environment_settings)
+      end
+
+
+      #ap @configuration
+      #generate_accessors
+    end
+
+    def deep_merge!(target, data)
+      merger = proc { |key, v1, v2|
+        if (Hash === v1 && Hash === v2)
+          v1.merge(v2, &merger)
+        elsif (Array === v1 && Array === v2)
+          v1.concat(v2)
+        else
+          v2
+        end
+      }
+      target.merge! data, &merger
+    end
+
+    def reload!(options = {}, filename)
+      clear
+      #filename.nil? ?
+      load!(options) # : load!(options, filename)
+    end
+
+    def to_yaml
+
+    end
+
+    def method_missing(name, *args, &block)
+      @configuration[name.to_sym] ||
+          #fail(NoMethodError, "Unknown settings root \'#{name}\'", caller)
+          nil
+    end
+
+    def clear
+      init
+    end
+
+    def options
+      @configuration[:options] = {} if @configuration[:options].nil?
+      @configuration[:options]
+    end
+
+    # custom methods for the specifics of eb.yml settings
+    def option_settings
+      result = []
+      options.each_key do |namespace|
+        options[namespace].each do |option_name, value|
+          result << to_option_setting(namespace, option_name, value)
+        end
+      end
+
+      #{"option_settings" => result}
+      result
+    end
+
+    def set_option(namespace, option_name, value)
+      namespace = namespace.to_sym
+
+      if options[namespace].nil?
+        options[namespace] = {option_name.to_sym => value}
+      else
+        options[namespace][option_name.to_sym] = value
+      end
+
+      #puts '888888hello'
+    end
+
+    def find_option_setting(name)
+      name = name.to_sym
+      options.each_key do |namespace|
+        options[namespace].each do |option_name, value|
+          if option_name.eql? name
+            return to_option_setting(namespace, option_name, value)
+          end
+        end
+      end
+      return nil
+    end
+
+    def find_option_setting_value(name)
+      o = find_option_setting(name)
+      o[:value] unless o.nil?
+    end
+
+    def to_option_setting(namespace, option_name, value)
+      {
+          :"namespace" => "#{namespace}",
+          :"option_name" => "#{option_name}",
+          :"value" => "#{value}"
+      }
+    end
+
+    def resolve_path(relative_path)
+      if defined?(Rails)
+
+        puts '**********************Using Rails.root'
+        Rails.root.join(relative_path)
+      elsif defined?(Rake.original_dir)
+
+        puts '**********************Using Rake.original_dir'
+        Rake.original_dir.join(relative_path)
+      else
+
+        puts '**********************Using Last resort Dir.pwd'
+        #raise 'I have no idea what the root dir is yet.'
+        File.expand_path(relative_path, Dir.pwd)
+      end
+    end
+
+
+    #def environment
+    #  @configuration[:environment]
+    #end
+    #
+    #def options
+    #  @configuration[:options]
+    #end
+
+    private
+
+    #def generate_accessors
+    #  # generate a method for accessors
+    #  @configuration.each do |key, value|
+    #    define_method(key) do
+    #      value
+    #    end unless ['options', 'environment'].include? key
+    #  end
+    #end
+  end
+
+end