rebi 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e86f234a1a4dcdb347b576c07f449d68f4ef0918
+  data.tar.gz: 26fc0b37540c17cc4008f3bafb278db933591e01
+SHA512:
+  metadata.gz: 0b3818bc2410ee9b0bfb567b8ee76f6c98ffd312f11b806837dc21c4766c9428f5fb7c6c6cb4cbe7d8a4f49641aeada918c43c9557112c791676f1aecf9accf1
+  data.tar.gz: 14f13a7ced8fcec217bbff5149f86b18914a5b63b3a27444253631b57174a45dedd13c04d6ca897eb9b60f197074968276cc2bc36db00d7cfc4b8e22e139bc80

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 
+
+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,95 @@
+# Rebi
+Deployment tool for Elasticbeanstalk
+
+# Features
+  - Switchable  + multiple ebextensions folder
+  - Support erb in ebextension config files
+  - Support env_file for environment variables
+  - Multiple deployment
+  - Deploy source code along with updating beanstalk options
+  - Simple config
+
+## Installation
+Or install it yourself as:
+```bash
+$ gem install rebi
+```
+
+## Usage
+How to use my plugin.
+
+### AWS authentication
+Rebi uses environment variables to get aws credentials
+To set environment variables use `export` or `.env` file
+```bash
+# Use access key
+export AWS_ACCESS_KEY_ID=xxxxx
+export AWS_SECRET_ACCESS_KEY=xxxxxx
+```
+Or
+```bash
+# Use profile
+export AWS_PROFILE=xxxxx
+```
+
+Refer http://docs.aws.amazon.com/sdkforruby/api/Aws/ElasticBeanstalk/Client.html for other settings
+
+### Yaml config
+Default config file is `config/rebi.yml` use `-c` to switch
+```yaml
+app_name: app-name
+stages:
+  development:
+    web:
+      name: web01
+      env_file: .env.development
+      ebextensions: "web-ebextensions"
+```
+
+For other configs( key_name, instance_type, instance_num, service_role,...), please refer sample config
+```bash
+$ bundle exec rebi sample > rebi.yml
+```
+
+### Deploy
+```bash
+# Single deploy
+$ bundle exec rebi deploy development web
+```
+
+```bash
+# Multiple deploy (if development has more than one environments)
+$ bundle exec rebi deploy development
+```
+
+### Get envronment variables and status
+```bash
+# Running envronment variables
+$ bundle exec rebi get_env development
+# envronment variables for config
+$ bundle exec rebi get_env development --from-config
+# Status
+$ bundle exec rebi status development
+```
+
+###For more help
+```bash
+$ bundle exec rebi --help
+```
+
+### ERB in ebextensions config
+Use `rebi_env` to get environment variables config in .ebextensions
+```yaml
+# Ex
+# .ebextensions/00-envrionments.config
+option_settings:
+  - option_name: KEY
+    value: <%= rebi_env[KEY] %>
+```
+
+## Contributing
+Feel free to fork and request a pull, or submit a ticket
+https://github.com/khiemns54/rebi/issues
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Rebi'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/bin/rebi

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'commander/import'
+require 'rebi'
+
+REBI_PATH = File.join(File.dirname(File.expand_path(__FILE__)), "..")
+
+program :name, 'Rebi'
+program :version, Rebi::VERSION
+program :description, 'Elasticbeanstalk deployment tool'
+
+global_option('-c', '--config FILE', 'Load config data for your commands to use') do |file|
+  Rebi.config.config_file = file
+  Rebi.config.reload!
+end
+
+command :deploy do |c|
+  c.syntax = 'rebi deploy stage [env_name] [--options]'
+  c.description = 'Deploy single or multiple ElasticBeanstalk environments'
+  c.example 'Deploy only web environment in development', 'rebi deploy development web'
+  c.example 'Deploy all environments in development', 'rebi deploy development'
+  c.option '--source-only', 'Deploy source only'
+  c.option '--settings-only', 'Deploy option_settings and environment variables only'
+  c.action do |args, options|
+    stage, env_name = args
+    raise Rebi::Error.new("Stage cannot be nil") if stage.blank?
+    opts = options.__hash__
+    if env_name.present?
+      Rebi.app.deploy stage, env_name, opts
+    else
+      if agree("Do you want to deploy all environments in #{stage} stage?(Y/n)")
+        Rebi.log("Preparing for deployment")
+        Rebi.app.deploy stage, nil, opts
+      end
+    end
+  end
+end
+
+command :get_env do |c|
+  c.syntax = 'rebi get_env stage [env_name] [--options]'
+  c.description = 'Get using environment variables or environment variables from  config file'
+  c.example 'Get environment variables of web in development', 'rebi get_env development web'
+  c.example 'Get environment variables of development stages', 'rebi get_env development'
+  c.option '--from-config', 'Get environment variables from config'
+  c.action do |args, options|
+    stage, env_name = args
+    raise Rebi::Error.new("Stage cannot be nil") if stage.blank?
+    Rebi.app.print_environment_variables stage, env_name, options.from_config
+  end
+end
+
+command :status do |c|
+  c.syntax = 'rebi status stage [env_name]'
+  c.description = 'Get current status'
+  c.action do |args, options|
+    stage, env_name = args
+    raise Rebi::Error.new("Stage cannot be nil") if stage.blank?
+    Rebi.app.print_environment_status stage, env_name
+  end
+end
+
+command :sample do |c|
+  c.syntax = 'rebi sample '
+  c.description = 'Create sample config yaml'
+  c.example 'Create sample', 'rebi sample > rebi.yml '
+  c.action do |args, options|
+    puts File.read("#{REBI_PATH}/sample/rebi.yml")
+  end
+end
+
+command :terminate do |c|
+  c.syntax = 'rebi terminate stage env_name '
+  c.description = 'Terminate environment'
+  c.action do |args, options|
+    stage, env_name = args
+    raise Rebi::Error.new("Stage cannot be nil") if stage.blank?
+    raise Rebi::Error.new("Env name cannot be nil") if env_name.blank?
+    env_conf = Rebi.config.environment(stage, env_name)
+    if ask("Type '#{env_conf.name}' to confirm termination") == env_conf.name
+      Rebi.app.terminate! stage, env_name
+    end
+  end
+end

data/lib/rebi/application.rb

@@ -0,0 +1,152 @@
+module Rebi
+  class Application
+    attr_reader :app, :app_name, :client, :s3_client
+    def initialize app, client
+      @app = app
+      @app_name = app.application_name
+      @client = client
+      @s3_client = Aws::S3::Client.new
+    end
+
+    def bucket_name
+      @bucket_name ||= client.create_storage_location.s3_bucket
+    end
+
+    def environments
+      Rebi::Environment.all app_name
+    end
+
+    def deploy stage_name, env_name=nil, opts={}
+      return deploy_stage(stage_name, opts) if env_name.blank?
+      env = Rebi::Environment.new stage_name, env_name, client
+      app_version = create_app_version env
+      begin
+        req_id = env.deploy app_version, opts
+        env.watch_request req_id if req_id
+      rescue Rebi::Error::EnvironmentInUpdating => e
+        Rebi.log("Environment in updating", env.name)
+        raise e
+      end
+      req_id
+    end
+
+    def deploy_stage stage_name, opts={}
+      threads = []
+      Rebi.config.stage(stage_name).each do |env_name, conf|
+        next if conf.blank?
+        threads << Thread.new do
+          begin
+            deploy stage_name, env_name, opts
+          rescue Exception => e
+            Rebi.log(e.message, "ERROR")
+            e.backtrace.each do |m|
+              Rebi.log(m, "ERROR")
+            end
+          end
+        end
+      end
+
+      ThreadsWait.all_waits(*threads)
+    end
+
+    def print_environment_variables stage_name, env_name, from_config=false
+      if env_name.blank?
+        Rebi.config.stage(stage_name).each do |e_name, conf|
+          next if conf.blank?
+          print_environment_variables stage_name, e_name, from_config
+        end
+        return
+      end
+
+      env = Rebi::Environment.new stage_name, env_name, client
+      env_vars = from_config ? env.config.environment_variables : env.environment_variables
+
+      Rebi.log("#{from_config ? "Config" : "Current"} environment variables", env.name)
+      env_vars.each do |k,v|
+        Rebi.log("#{k}=#{v}")
+      end
+      Rebi.log("--------------------------------------", env.name)
+    end
+
+    def print_environment_status stage_name, env_name
+      if env_name.blank?
+        Rebi.config.stage(stage_name).each do |e_name, conf|
+          next if conf.blank?
+          print_environment_status stage_name, e_name
+        end
+        return
+      end
+
+      env = Rebi::Environment.new stage_name, env_name, client
+      env.check_created!
+      Rebi.log("--------- CURRENT STATUS -------------", env.name)
+      Rebi.log("id: #{env.id}", env.name)
+      Rebi.log("Status: #{env.status}", env.name)
+      Rebi.log("Health: #{env.health}", env.name)
+      Rebi.log("--------------------------------------", env.name)
+    end
+
+    def terminate! stage_name, env_name
+      env = Rebi::Environment.new stage_name, env_name, client
+      begin
+        req_id = env.terminate!
+        ThreadsWait.all_waits(env.watch_request req_id) if req_id
+      rescue Rebi::Error::EnvironmentInUpdating => e
+        Rebi.log("Environment in updating", env.name)
+        raise e
+      end
+    end
+
+    def create_app_version env
+      start = Time.now.utc
+      source_bundle = Rebi::ZipHelper.new.gen(env.config)
+      version_label = source_bundle[:label]
+      key = "#{app_name}/#{version_label}.zip"
+      Rebi.log("Uploading source bundle: #{version_label}.zip", env.config.name)
+      s3_client.put_object(
+        bucket: bucket_name,
+        key: key,
+        body: source_bundle[:file].read
+        )
+      Rebi.log("Creating app version: #{version_label}", env.config.name)
+      client.create_application_version({
+        application_name: app_name,
+        description: source_bundle[:message],
+        version_label: version_label,
+        source_bundle: {
+          s3_bucket: bucket_name,
+          s3_key: key
+          }
+        })
+      Rebi.log("App version was created in: #{Time.now.utc - start}s", env.config.name)
+      return version_label
+    end
+
+
+    def self.client
+      Rebi.client || Aws::ElasticBeanstalk::Client.new
+    end
+
+    def self.get_application app_name
+      raise Error::ApplicationNotFound.new unless app = client.describe_applications(application_names: [app_name]).applications.first
+      return Rebi::Application.new(app, client)
+    end
+
+    def self.create_application app_name, description=nil
+      res = client.create_application(
+        application_name: app_name,
+        description: description,
+      )
+      return Rebi::Application.new(res.application, client)
+    end
+
+    def self.get_or_create_application app_name
+      begin
+        return get_application app_name
+      rescue Error::ApplicationNotFound
+        return create_application app_name, Rebi.config.app_description
+      end
+    end
+
+  end
+end

data/lib/rebi/config.rb

@@ -0,0 +1,48 @@
+module Rebi
+  class Config
+    include Singleton
+
+    def config_file
+      @config_file ||= "#{Rebi.root}/config/rebi.yml"
+    end
+
+    def config_file=path
+      @config_file = Pathname.new(path).realpath.to_s
+    end
+
+    def reload!
+      @data = nil
+      return data
+    end
+
+    def app_name
+      data[:app_name]
+    end
+
+    def app_description
+      data[:app_description] || "Created via rebi"
+    end
+
+    def stage stage
+      data[:stages][stage] || raise(Rebi::Error::ConfigNotFound.new("Stage: #{stage}"))
+    end
+
+    def timeout
+      (data[:timeout] || 60*10).second
+    end
+
+    def environment stg_name, env_name
+      stg = stage stg_name
+      raise(Rebi::Error::ConfigNotFound.new("Environment config: #{env_name}")) unless stg.key?(env_name)
+      return Rebi::ConfigEnvironment.new(stg_name, env_name, stg[env_name] || {})
+    end
+
+    private
+    def data
+      @data ||= YAML::load(ERB.new(IO.read(config_file)).result).with_indifferent_access
+      raise Rebi::Error::ConfigInvalid.new("app_name cannot be nil") if @data[:app_name].blank?
+      raise Rebi::Error::ConfigInvalid.new("stages cannot be nil") if @data[:stages].blank?
+      return @data
+    end
+  end
+end

data/lib/rebi/config_environment.rb

@@ -0,0 +1,317 @@
+require 'pathname'
+
+module Rebi
+  class ConfigEnvironment
+
+    attr_reader :stage,
+                :env_name,
+                :name,
+                :description,
+                :cname_prefix,
+                :tier,
+                :instance_type,
+                :instance_num,
+                :key_name,
+                :service_role,
+                :ebextensions,
+                :solution_stack_name,
+                :cfg_file,
+                :env_file,
+                :environment_variables,
+                :option_settings,
+                :raw_conf
+
+    NAMESPACE ={
+      app_env: "aws:elasticbeanstalk:application:environment",
+      eb_env: "aws:elasticbeanstalk:environment",
+      autoscaling_launch: "aws:autoscaling:launchconfiguration",
+      autoscaling_asg: "aws:autoscaling:asg",
+      elb_policies: "aws:elb:policies",
+      elb_health: "aws:elb:healthcheck",
+      elb_loadbalancer: "aws:elb:loadbalancer",
+      healthreporting: "aws:elasticbeanstalk:healthreporting:system",
+      eb_command: "aws:elasticbeanstalk:command",
+    }
+
+    UPDATEABLE_NS = {
+      autoscaling_asg: [:MaxSize, :MinSize],
+      autoscaling_launch: [:InstanceType, :EC2KeyName],
+      eb_env: [:ServiceRole],
+    }
+
+    def initialize stage, env_name, env_conf={}
+      @raw_conf = env_conf.with_indifferent_access
+      @stage = stage.to_sym
+      @env_name = env_name.to_sym
+    end
+
+    def name
+      @name ||= raw_conf[:name] || "#{env_name}-#{stage}"
+    end
+
+    def app_name
+      Rebi.config.app_name
+    end
+
+    def description
+      @description ||= raw_conf[:description] || "Created via rebi"
+    end
+
+    def cname_prefix
+      @cname_prefix ||= raw_conf[:cname_prefix] || "#{name}-#{stage}"
+    end
+
+    def tier
+      return @tier if @tier
+      t = if raw_conf[:tier]
+        raw_conf[:tier].to_sym
+      elsif cfg.present? && cfg[:EnvironmentTier].present? && cfg[:EnvironmentTier][:Name].present?
+        cfg[:EnvironmentTier][:Name] == "Worker" ? :worker : :web
+      else
+        :web
+      end
+
+      @tier = if t == :web
+        {
+          name: "WebServer",
+          type: "Standard",
+        }
+      elsif t == :worker
+        {
+          name: "Worker",
+          type: "SQS/HTTP",
+        }
+      else
+        Rebi::Error::ConfigInvalid.new("Invalid tier")
+      end
+
+      return @tier = @tier.with_indifferent_access
+    end
+
+    def worker?
+      tier[:name] == "Worker" ? true : false
+    end
+
+    def instance_type
+      get_opt ns[:autoscaling_launch], :InstanceType
+    end
+
+    def instance_num
+      {
+        min: get_opt(ns[:autoscaling_asg], :MinSize),
+        max: get_opt(ns[:autoscaling_asg], :MaxSize)
+      }
+    end
+
+    def key_name
+      get_opt(ns[:autoscaling_launch], :EC2KeyName)
+    end
+
+    def service_role
+      get_opt(ns[:eb_env], :ServiceRole)
+    end
+
+    def cfg_file
+      @cfg_file ||= raw_conf[:cfg_file]
+      return @cfg_file if @cfg_file.blank?
+      return @cfg_file if Pathname.new(@cfg_file).absolute?
+      @cfg_file = ".elasticbeanstalk/saved_configs/#{@cfg_file}.cfg.yml" unless @cfg_file.match(".yml$")
+      return (@cfg_file = "#{Rebi.root}/#{@cfg_file}")
+    end
+
+    def env_file
+      @env_file ||= raw_conf[:env_file]
+    end
+
+    def cfg
+      begin
+        return nil if cfg_file.blank?
+        return (@cfg ||= YAML.load(ERB.new(IO.read(cfg_file)).result).with_indifferent_access)
+      rescue Errno::ENOENT
+        raise Rebi::Error::ConfigInvalid.new("cfg_file: #{cfg_file}")
+      end
+    end
+
+    def solution_stack_name
+      @solution_stack_name ||= raw_conf[:solution_stack_name] || "64bit Amazon Linux 2017.03 v2.4.1 running Ruby 2.3 (Puma)"
+    end
+
+    def platform_arn
+      cfg && cfg[:Platform] && cfg[:Platform][:PlatformArn]
+    end
+
+    def ebextensions
+      return @ebextensions ||= if (ebx = raw_conf[:ebextensions])
+        ebx = [ebx] if ebx.is_a?(String)
+        ebx.prepend(".ebextensions") unless ebx.include?(".ebextensions")
+        ebx
+      else
+        [".ebextensions"]
+      end
+    end
+
+    def raw_environment_variables
+      raw_conf[:environment_variables] || {}
+    end
+
+    def dotenv
+      env_file.present? ? Dotenv.load(env_file).with_indifferent_access : {}
+    end
+
+    def environment_variables
+      get_opt(ns(:app_env))
+    end
+
+    def get_opt namespace, opt_name=nil
+      has_value_by_keys(option_settings, namespace, opt_name)
+    end
+
+    def get_raw_opt namespace, opt_name=nil
+      has_value_by_keys(raw_conf[:option_settings], namespace, opt_name)
+    end
+
+    def opts_array opts=option_settings
+      res = []
+      opts.each do |namespace, v|
+        namespace, resource_name = namespace.split(".").reverse
+        v.each do |option_name, value|
+          res << {
+            resource_name: resource_name,
+            namespace: namespace,
+            option_name: option_name,
+            value: value.to_s,
+          }.with_indifferent_access
+        end
+      end
+      return res
+    end
+
+    def option_settings
+      return @opt if @opt.present?
+      opt = (cfg && cfg[:OptionSettings]) || {}.with_indifferent_access
+
+      opt = opt.deep_merge(raw_conf[:option_settings] || {})
+
+      ns.values.each do |ns|
+        opt[ns] = {}.with_indifferent_access if opt[ns].blank?
+      end
+
+      opt = set_opt_default opt
+      opt = set_opt_env_var opt
+      opt = set_opt_keyname opt
+      opt = set_opt_instance_type opt
+      opt = set_opt_instance_num opt
+      opt = set_opt_service_role opt
+
+      return @opt = opt
+    end
+
+    def ns key=nil
+      key.present? ? NAMESPACE[key.to_sym] : NAMESPACE
+    end
+
+    private
+
+    def has_value_by_keys(hash, *keys)
+      if keys.empty? || hash.blank?
+        return hash
+      else
+        return hash unless k = keys.shift
+        return hash[k] && has_value_by_keys(hash[k], *keys)
+      end
+    end
+
+    def set_opt_keyname opt
+      k = if raw_conf.key?(:key_name)
+        raw_conf[:key_name]
+      elsif get_raw_opt(ns[:autoscaling_launch], :EC2KeyName)
+        get_raw_opt(ns[:autoscaling_launch], :EC2KeyName)
+      else
+        nil
+      end
+      if k.present?
+        opt[ns[:autoscaling_launch]].merge!({
+          EC2KeyName: k
+        }.with_indifferent_access)
+      end
+      return opt
+    end
+
+    def set_opt_service_role opt
+      s_role = if raw_conf.key?(:service_role)
+        raw_conf[:service_role]
+      elsif role = get_raw_opt(ns[:eb_env], :ServiceRole)
+        role
+      else
+        'aws-elasticbeanstalk-service-role'
+      end
+      if s_role.present?
+        opt[ns[:eb_env]].merge!({
+          ServiceRole: s_role,
+        }.with_indifferent_access)
+      end
+      return opt
+    end
+
+    def set_opt_instance_type opt
+      itype = raw_conf[:instance_type] \
+              || get_raw_opt(ns[:autoscaling_launch], :InstanceType) \
+              || "t2.small"
+      if itype.present?
+        opt[ns[:autoscaling_launch]].merge!({
+          InstanceType: itype
+        }.with_indifferent_access)
+      end
+      return opt
+    end
+
+    def set_opt_instance_num opt
+      max = min = 1
+      if raw_conf[:instance_num].present?
+        min = raw_conf[:instance_num][:min]
+        max = raw_conf[:instance_num][:min]
+      elsif mi = get_raw_opt(ns[:autoscaling_asg], :MinSize) \
+            || ma = get_raw_opt(ns[:autoscaling_asg], :MaxSize)
+            min = mi if mi
+            max = ma if ma
+      end
+      opt[ns[:autoscaling_asg]].merge!({
+        MaxSize: max,
+        MinSize: min,
+      }.with_indifferent_access)
+      return opt
+    end
+
+    def set_opt_env_var opt
+      opt[ns[:app_env]].merge!(dotenv.merge(raw_environment_variables))
+      return opt
+    end
+
+    def set_opt_default opt
+
+      opt[ns[:healthreporting]].reverse_merge!({
+        SystemType: 'enhanced',
+      }.with_indifferent_access)
+
+      opt[ns[:eb_command]].reverse_merge!({
+        BatchSize: "50",
+        BatchSizeType: "Percentage",
+      }.with_indifferent_access)
+
+      unless worker?
+        opt[ns[:elb_policies]].reverse_merge!({
+          ConnectionDrainingEnabled: true
+        }.with_indifferent_access)
+
+        opt[NAMESPACE[:elb_health]].reverse_merge!({
+          Interval: 30
+        }.with_indifferent_access)
+
+        opt[NAMESPACE[:elb_loadbalancer]].reverse_merge!({
+          CrossZone: true
+        }.with_indifferent_access)
+      end
+      return opt
+    end
+  end
+end

data/lib/rebi/environment.rb

@@ -0,0 +1,305 @@
+module Rebi
+  class Environment
+
+    attr_reader :stage_name,
+                :env_name,
+                :app_name,
+                :name,
+                :config
+
+    attr_accessor :client,
+                  :api_data
+
+
+    RESPONSES = {
+        'event.createstarting': 'createEnvironment is starting.',
+        'event.terminatestarting': 'terminateEnvironment is starting.',
+        'event.updatestarting': 'Environment update is starting.',
+        'event.redmessage': 'Environment health has been set to RED',
+        'event.commandfailed': 'Command failed on instance',
+        'event.launchfailed': 'Failed to launch',
+        'event.deployfailed': 'Failed to deploy application.',
+        'event.redtoyellowmessage': 'Environment health has transitioned from YELLOW to RED',
+        'event.yellowmessage': 'Environment health has been set to YELLOW',
+        'event.greenmessage': 'Environment health has been set to GREEN',
+        'event.launchsuccess': 'Successfully launched environment:',
+        'event.launchbad': 'Create environment operation is complete, but with errors',
+        'event.updatebad': 'Update environment operation is complete, but with errors.',
+        'git.norepository': 'Error: Not a git repository (or any of the parent directories): .git',
+        'env.updatesuccess': 'Environment update completed successfully.',
+        'env.cnamenotavailable': 'DNS name \([^ ]+\) is not available.',
+        'env.nameexists': 'Environment [^ ]+ already exists.',
+        'app.deletesuccess': 'The application has been deleted successfully.',
+        'app.exists': 'Application {app-name} already exists.',
+        'app.notexists': 'No Application named {app-name} found.',
+        'logs.pulled': 'Pulled logs for environment instances.',
+        'logs.successtail': 'Successfully finished tailing',
+        'logs.successbundle': 'Successfully finished bundling',
+        'env.terminated': 'terminateEnvironment completed successfully.',
+        'env.invalidstate': 'Environment named {env-name} is in an invalid state for this operation. Must be Ready.',
+        'loadbalancer.notfound': 'There is no ACTIVE Load Balancer named',
+        'ec2.sshalreadyopen': 'the specified rule "peer: 0.0.0.0/0, TCP, from port: 22, to port: 22,',
+    }
+
+    def initialize stage_name, env_name, client=Rebi.client
+      @stage_name = stage_name
+      @env_name = env_name
+      @client = client
+      @config = Rebi.config.environment(stage_name, env_name)
+      @app_name = @config.app_name
+      @api_data
+    end
+
+    def name
+      created? ? api_data.environment_name : config.name
+    end
+
+    def cname
+      created? ? api_data.cname : nil
+    end
+
+    def version_label
+      created? ? api_data.version_label : nil
+    end
+
+    def id
+      created? ? api_data.environment_id : nil
+    end
+
+    def status
+      check_created! && api_data.status
+    end
+
+    def in_updating?
+      !!status.match("ing$")
+    end
+
+    def health
+      check_created! && api_data.health
+    end
+
+    def option_settings
+      check_created!
+      client.describe_configuration_settings({
+        application_name: app_name,
+        environment_name: name
+      }).configuration_settings.first.option_settings.map do |o|
+        {
+          namespace: o.namespace,
+          value: o.value,
+          resource_name: o.resource_name,
+          option_name: o.option_name,
+        }.with_indifferent_access
+      end
+    end
+
+    def environment_variables
+      option_settings.select do |o|
+          o[:namespace] == config.ns(:app_env)
+      end.map do |o|
+            [o[:option_name], o[:value]]
+      end.to_h.with_indifferent_access
+    end
+
+    def check_created
+      raise Rebi::Error::EnvironmentNotExisted.new("#{name} not exists") unless created?
+      return created?
+    end
+
+    # refresh data
+    def check_created!
+      refresh
+      check_created
+    end
+
+    def created?
+      !!api_data
+    end
+
+    def api_data
+      @api_data ||= client.describe_environments(application_name: config.app_name,
+                                                 environment_names:[config.name],
+                                                 include_deleted: false).environments.first
+    end
+
+    def response_msgs key=nil
+      @response_msgs ||= RESPONSES.with_indifferent_access
+      return key ? @response_msgs[key] : @response_msgs
+    end
+
+    def watch_request request_id
+      check_created!
+      start = Time.now
+      finished = false
+      last_time = Time.now - 30.minute
+      thread = Thread.new do
+        while (start + Rebi.config.timeout) > Time.now && !finished
+          events(last_time, request_id).reverse.each do |e|
+            finished ||= success_message?(e.message)
+            last_time = [last_time + 1.second, e.event_date + 1.second].max
+            log(e.message)
+          end
+          sleep(5) unless finished
+        end
+        log ("Timeout") unless finished
+      end
+      thread.join
+      return thread
+    end
+
+    def events start_time=Time.now, request_id=nil
+      client.describe_events({
+        application_name: app_name,
+        environment_name: name,
+        start_time: start_time,
+      }.merge( request_id ? {request_id: request_id} : {})).events
+    end
+
+    def refresh
+      self.api_data = nil
+      return self
+    end
+
+    def init version_label, opts={}
+      log("Creating new environment")
+      start_time = Time.now
+      self.api_data = client.create_environment({
+        application_name: config.app_name,
+        cname_prefix: config.cname_prefix,
+        environment_name: config.name,
+        version_label: version_label,
+        tier: config.tier,
+        description: config.description,
+        option_settings: config.opts_array,
+      }.merge(if(config.platform_arn)
+        { platform_arn: config.platform_arn}
+      else
+        { solution_stack_name: config.solution_stack_name}
+      end))
+      request_id = events(start_time).select do |e|
+        e.message.match(response_msgs('event.createstarting'))
+      end.map(&:request_id).first
+      return request_id
+    end
+
+    def update version_label, opts={}
+      raise Rebi::Error::EnvironmentInUpdating.new(name) if in_updating?
+      log("Start updating")
+      start_time = Time.now
+      deploy_opts = gen_deploy_opts
+      deploy_args = {
+        application_name: config.app_name,
+        environment_name: config.name,
+        version_label: version_label,
+        description: config.description,
+        option_settings: deploy_opts[:option_settings],
+        options_to_remove: deploy_opts[:options_to_remove],
+      }
+
+      if opts[:source_only]
+        deploy_args.delete(:option_settings)
+        deploy_args.delete(:options_to_remove)
+      elsif opts[:settings_only]
+        deploy_args.delete(:version_label)
+      end
+
+      self.api_data = client.update_environment(deploy_args)
+
+      request_id = events(start_time).select do |e|
+        e.message.match(response_msgs('event.updatestarting'))
+      end.map(&:request_id).first
+
+      return request_id
+    end
+
+    def deploy version_label, opts={}
+      request_id = if created?
+        update version_label, opts
+      else
+        init version_label, opts
+      end
+      return request_id
+    end
+
+    def terminate!
+      check_created
+      log("Start terminating")
+      client.terminate_environment({
+        environment_name: name,
+        environment_id: id,
+        })
+      start_time = Time.now
+
+      request_id = events(start_time).select do |e|
+        e.message.match(response_msgs('event.updatestarting'))
+      end.map(&:request_id).first
+      return request_id
+    end
+
+    def log mes
+      Rebi.log(mes, name)
+    end
+
+    def success_message? mes
+      return true if [
+        'event.greenmessage',
+        'event.launchsuccess',
+        'logs.pulled',
+        'env.terminated',
+        'env.updatesuccess',
+        'app.deletesuccess',
+      ].map{|k| response_msgs(k)}.any?{|s| mes.match(s)}
+
+      if [
+            'event.redmessage',
+            'event.launchbad',
+            'event.updatebad',
+            'event.commandfailed',
+            'event.launchfailed',
+            'event.deployfailed',
+          ].map {|k| response_msgs(k)}.any? {|s| mes.match(s)}
+        raise Rebi::Error::ServiceError.new(mes)
+      end
+
+      return false
+    end
+
+    def gen_deploy_opts
+      to_deploy = []
+      to_remove = []
+      config.opts_array.each do |o|
+        o = o.deep_dup
+        if o[:namespace] == config.ns(:app_env) && o[:value].blank?
+          o.delete(:value)
+          to_remove << o
+          next
+        end
+        to_deploy << o
+      end
+      return {
+        option_settings: to_deploy,
+        options_to_remove:  to_remove,
+      }
+    end
+
+    def self.create stage_name, env_name, version_label, client
+      env =  new stage_name, env_name, client
+      raise Rebi::Error::EnvironmentExisted.new if env.created?
+
+      env.init version_label
+      return env
+    end
+
+    # TODO
+    def self.all client=Rebi.client
+      client.describe_environments(application_name: app_name,
+                                   include_deleted: false).environments
+    end
+
+    def self.get stage_name, env_name, client=Rebi.client
+      env = new stage_name, env_name, client
+      return env.created? ? env : nil
+    end
+
+  end
+end

data/lib/rebi/erb_helper.rb

@@ -0,0 +1,16 @@
+module Rebi
+  class ErbHelper
+    def initialize input, env_vars
+      @input = input
+      @env = env_vars || {}
+    end
+
+    def rebi_env k=nil
+      k.present? ? @env[k] : @env
+    end
+
+    def result
+      ERB.new(@input).result(binding)
+    end
+  end
+end

data/lib/rebi/error.rb

@@ -0,0 +1,13 @@
+module Rebi
+  class Error < StandardError
+    ApplicationNotFound = Class.new(self)
+    EnvironmentExisted = Class.new(self)
+    EnvironmentNotExisted = Class.new(self)
+    ConfigFileNotFound = Class.new(self)
+    ConfigNotFound = Class.new(self)
+    ConfigInvalid = Class.new(self)
+    NoGit = Class.new(self)
+    ServiceError = Class.new(self)
+    EnvironmentInUpdating = Class.new(self)
+  end
+end

data/lib/rebi/version.rb

@@ -0,0 +1,3 @@
+module Rebi
+  VERSION = '0.1.6'
+end

data/lib/rebi/zip_helper.rb

@@ -0,0 +1,61 @@
+module Rebi
+  class ZipHelper
+
+    def initialize
+      `git status`
+      raise Rebi::Error::NoGit.new("Not a git repository") unless $?.success?
+    end
+
+    def ls_files
+      `git ls-files`.split("\n")
+    end
+
+    def raw_zip_archive opts={}
+      tmp_file = Tempfile.new("git_archive")
+      system "git archive --format=zip HEAD > #{tmp_file.path}"
+      return tmp_file
+    end
+
+    def version_label
+      `git describe --always --abbrev=8`.chomp
+    end
+
+    def message
+      `git log --oneline -1`.chomp.split(" ")[1..-1].join(" ")[0..190]
+    end
+
+    # Create zip archivement
+    def gen env_conf
+      Rebi.log("Creating zip archivement", env_conf.name)
+      start = Time.now
+      ebextensions = env_conf.ebextensions
+      files = ls_files
+      tmp_file = raw_zip_archive
+      tmp_folder = Dir.mktmpdir
+      Zip::File.open(tmp_file) do |z|
+        ebextensions.each do |ex_folder|
+          Dir.glob("#{ex_folder}/*.config") do |fname|
+            next unless (File.file?(fname) && files.include?(fname))
+            next unless y = YAML::load(ErbHelper.new(File.read(fname), env_conf.environment_variables).result)
+            basename = File.basename(fname)
+            target = ".ebextensions/#{basename}"
+            tmp_yaml = "#{tmp_folder}/#{basename}"
+            File.open(tmp_yaml, 'w') do |f|
+              f.write y.to_yaml
+            end
+            z.remove target if z.find_entry target
+            z.add target, tmp_yaml
+          end
+        end
+      end
+      FileUtils.rm_rf tmp_folder
+      Rebi.log("Zip was created in: #{Time.now - start}s", env_conf.name)
+      return {
+        label: Time.now.strftime("app_#{env_conf.name}_#{version_label}_%Y%m%d_%H%M%S"),
+        file: File.open(tmp_file.path),
+        message: message,
+      }
+    end
+
+  end
+end

data/lib/rebi.rb

@@ -0,0 +1,66 @@
+require 'active_support/all'
+require 'aws-sdk'
+require 'colorized_string'
+require 'singleton'
+require 'yaml'
+require 'dotenv'
+require 'tempfile'
+require 'pathname'
+require 'zip'
+require 'fileutils'
+require 'erb'
+require 'ostruct'
+require 'thread'
+require 'thwait'
+
+require 'rebi/erb_helper'
+require 'rebi/zip_helper'
+require 'rebi/application'
+require 'rebi/environment'
+require 'rebi/config'
+require 'rebi/config_environment'
+require 'rebi/error'
+require 'rebi/version'
+
+Dotenv.load
+
+module Rebi
+  extend self
+
+  attr_accessor :config_file
+  @config_file = "config/rebi.yml"
+
+  def root
+    Dir.pwd
+  end
+
+  def client c=nil
+    @@client = c || Aws::ElasticBeanstalk::Client.new
+  end
+
+  def app
+    return Rebi::Application.get_or_create_application(config.app_name)
+  end
+
+  def config
+    yield Rebi::Config.instance if block_given?
+    return Rebi::Config.instance
+  end
+
+  def reload!
+    config.reload!
+  end
+
+  def log mes, prefix=nil
+    puts "#{prefix ? "#{colorize_prefix(prefix)}: " : ""}#{mes}"
+  end
+
+  COLORS = [:red, :green, :yellow, :blue, :magenta, :cyan, :white]
+  def colorize_prefix(prefix)
+    h = prefix.chars.inject(0) do |m, c|
+      m + c.ord
+    end
+    return ColorizedString[prefix].colorize(COLORS[h % COLORS.count])
+  end
+
+end

data/lib/tasks/rebi.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rebi do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: rebi
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- KhiemNS
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+description: Deploy ElasticBeanstalk with multiple deploy, switchable and dynamic
+  generated ebextensions with erb
+email:
+- khiemns.k54@gmail.com
+executables:
+- rebi
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/rebi
+- lib/rebi.rb
+- lib/rebi/application.rb
+- lib/rebi/config.rb
+- lib/rebi/config_environment.rb
+- lib/rebi/environment.rb
+- lib/rebi/erb_helper.rb
+- lib/rebi/error.rb
+- lib/rebi/version.rb
+- lib/rebi/zip_helper.rb
+- lib/tasks/rebi.rake
+homepage: https://github.com/khiemns54/rebi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: ElasticBeanstalk Deployment Tool
+test_files: []